{"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": "import os  import pickle  import shutil  from datetime import datetime  from queue import Queue    import pandas as pd  import pytest  from sqlalchemy import create_engine, text    from src.taipy.core._core import Core  from src.taipy.core._orchestrator._orchestrator_factory import _OrchestratorFactory  from src.taipy.core._repository.db._sql_connection import _SQLConnection  from src.taipy.core._version._version import _Version  from src.taipy.core._version._version_manager_factory import _VersionManagerFactory  from src.taipy.core.config import (      CoreSection,      DataNodeConfig,      JobConfig,      MigrationConfig,      ScenarioConfig,      TaskConfig,      _ConfigIdChecker,      _CoreSectionChecker,      _DataNodeConfigChecker,      _JobConfigChecker,      _ScenarioConfigChecker,      _TaskConfigChecker,  )  from src.taipy.core.cycle._cycle_manager_factory import _CycleManagerFactory  from src.taipy.core.cycle._cycle_model import _CycleModel  from src.taipy.core.cycle.cycle import Cycle  from src.taipy.core.cycle.cycle_id import CycleId  from src.taipy.core.data._data_manager_factory import _DataManagerFactory  from src.taipy.core.data._data_model import _DataNodeModel  from src.taipy.core.data.in_memory import InMemoryDataNode  from src.taipy.core.job._job_manager_factory import _JobManagerFactory  from src.taipy.core.job.job import Job  from src.taipy.core.job.job_id import JobId  from src.taipy.core.notification.notifier import Notifier  from src.taipy.core.scenario._scenario_manager_factory import _ScenarioManagerFactory  from src.taipy.core.scenario._scenario_model import _ScenarioModel  from src.taipy.core.scenario.scenario import Scenario  from src.taipy.core.scenario.scenario_id import ScenarioId  from src.taipy.core.sequence._sequence_manager_factory import _SequenceManagerFactory  from src.taipy.core.sequence.sequence import Sequence  from src.taipy.core.sequence.sequence_id import SequenceId  from src.taipy.core.submission._submission_manager_factory import _SubmissionManagerFactory  from src.taipy.core.submission._submission_model import _SubmissionModel  from src.taipy.core.task._task_manager_factory import _TaskManagerFactory  from src.taipy.core.task.task import Task  from taipy.config import _inject_section  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.config.common.frequency import Frequency  from taipy.config.common.scope import Scope  from taipy.config.config import Config    current_time = datetime.now()  _OrchestratorFactory._build_orchestrator()      @pytest.fixture(scope=\"function\")  def csv_file(tmpdir_factory) -> str:      csv = pd.DataFrame([{\"a\": 1, \"b\": 2, \"c\": 3}, {\"a\": 4, \"b\": 5, \"c\": 6}])      fn = tmpdir_factory.mktemp(\"data\").join(\"df.csv\")      csv.to_csv(str(fn), index=False)      return fn.strpath      @pytest.fixture(scope=\"function\")  def excel_file(tmpdir_factory) -> str:      excel = pd.DataFrame([{\"a\": 1, \"b\": 2, \"c\": 3}, {\"a\": 4, \"b\": 5, \"c\": 6}])      fn = tmpdir_factory.mktemp(\"data\").join(\"df.xlsx\")      excel.to_excel(str(fn), index=False)      return fn.strpath      @pytest.fixture(scope=\"function\")  def excel_file_with_sheet_name(tmpdir_factory) -> str:      excel = pd.DataFrame([{\"a\": 1, \"b\": 2, \"c\": 3}, {\"a\": 4, \"b\": 5, \"c\": 6}])      fn = tmpdir_factory.mktemp(\"data\").join(\"df.xlsx\")      excel.to_excel(str(fn), sheet_name=\"sheet_name\", index=False)      return fn.strpath      @pytest.fixture(scope=\"function\")  def json_file(tmpdir_factory) -> str:      json_data = pd.DataFrame([{\"a\": 1, \"b\": 2, \"c\": 3}, {\"a\": 4, \"b\": 5, \"c\": 6}])      fn = tmpdir_factory.mktemp(\"data\").join(\"df.json\")      json_data.to_json(str(fn), orient=\"records\")      return fn.strpath      @pytest.fixture(scope=\"function\")  def excel_file_with_multi_sheet(tmpdir_factory) -> str:      excel_multi_sheet = {          \"Sheet1\": pd.DataFrame([{\"a\": 1, \"b\": 2, \"c\": 3}, {\"a\": 4, \"b\": 5, \"c\": 6}]),          \"Sheet2\": pd.DataFrame([{\"a\": 7, \"b\": 8, \"c\": 9}, {\"a\": 10, \"b\": 11, \"c\": 12}]),      }      fn = tmpdir_factory.mktemp(\"data\").join(\"df.xlsx\")        with pd.ExcelWriter(str(fn)) as writer:          for key in excel_multi_sheet.keys():              excel_multi_sheet[key].to_excel(writer, key, index=False)        return fn.strpath      @pytest.fixture(scope=\"function\")  def pickle_file_path(tmpdir_factory) -> str:      data = pd.DataFrame([{\"a\": 1, \"b\": 2, \"c\": 3}, {\"a\": 4, \"b\": 5, \"c\": 6}])      fn = tmpdir_factory.mktemp(\"data\").join(\"df.p\")      with open(str(fn), \"wb\") as f:          pickle.dump(data, f)      return fn.strpath      @pytest.fixture(scope=\"function\")  def parquet_file_path(tmpdir_factory) -> str:      data = pd.DataFrame([{\"a\": 1, \"b\": 2, \"c\": 3}, {\"a\": 4, \"b\": 5, \"c\": 6}])      fn = tmpdir_factory.mktemp(\"data\").join(\"df.parquet\")      data.to_parquet(str(fn))      return fn.strpath      @pytest.fixture(scope=\"function\")  def tmp_sqlite_db_file_path(tmpdir_factory):      fn = tmpdir_factory.mktemp(\"data\")      db_name = \"df\"      file_extension = \".db\"      db = create_engine(\"sqlite:///\" + os.path.join(fn.strpath, f\"{db_name}{file_extension}\"))      conn = db.connect()      conn.execute(text(\"CREATE TABLE example (foo int, bar int);\"))      conn.execute(text(\"INSERT INTO example (foo, bar) VALUES (1, 2);\"))      conn.execute(text(\"INSERT INTO example (foo, bar) VALUES (3, 4);\"))      conn.commit()      conn.close()      db.dispose()        return fn.strpath, db_name, file_extension      @pytest.fixture(scope=\"function\")  def tmp_sqlite_sqlite3_file_path(tmpdir_factory):      fn = tmpdir_factory.mktemp(\"data\")      db_name = \"df\"      file_extension = \".sqlite3\"        db = create_engine(\"sqlite:///\" + os.path.join(fn.strpath, f\"{db_name}{file_extension}\"))      conn = db.connect()      conn.execute(text(\"CREATE TABLE example (foo int, bar int);\"))      conn.execute(text(\"INSERT INTO example (foo, bar) VALUES (1, 2);\"))      conn.execute(text(\"INSERT INTO example (foo, bar) VALUES (3, 4);\"))      conn.commit()      conn.close()      db.dispose()        return fn.strpath, db_name, file_extension      @pytest.fixture(scope=\"function\")  def default_data_frame():      return pd.DataFrame([{\"a\": 1, \"b\": 2, \"c\": 3}, {\"a\": 4, \"b\": 5, \"c\": 6}])      @pytest.fixture(scope=\"function\")  def default_multi_sheet_data_frame():      return {          \"Sheet1\": pd.DataFrame([{\"a\": 1, \"b\": 2, \"c\": 3}, {\"a\": 4, \"b\": 5, \"c\": 6}]),          \"Sheet2\": pd.DataFrame([{\"a\": 7, \"b\": 8, \"c\": 9}, {\"a\": 10, \"b\": 11, \"c\": 12}]),      }      @pytest.fixture(scope=\"session\", autouse=True)  def cleanup_files():      yield        if os.path.exists(\".data\"):          shutil.rmtree(\".data\", ignore_errors=True)      if os.path.exists(\".my_data\"):          shutil.rmtree(\".my_data\", ignore_errors=True)      @pytest.fixture(scope=\"function\")  def current_datetime():      return current_time      @pytest.fixture(scope=\"function\")  def scenario(cycle):      return Scenario(          \"sc\",          set(),          {},          set(),          ScenarioId(\"sc_id\"),          current_time,          is_primary=False,          tags={\"foo\"},          version=\"random_version_number\",          cycle=None,      )      @pytest.fixture(scope=\"function\")  def data_node():      return InMemoryDataNode(\"data_node_config_id\", Scope.SCENARIO, version=\"random_version_number\")      @pytest.fixture(scope=\"function\")  def data_node_model():      return _DataNodeModel(          \"my_dn_id\",          \"test_data_node\",          Scope.SCENARIO,          \"csv\",          \"name\",          \"owner_id\",          list({\"parent_id_1\", \"parent_id_2\"}),          datetime(1985, 10, 14, 2, 30, 0).isoformat(),          [dict(timestamp=datetime(1985, 10, 14, 2, 30, 0).isoformat(), job_id=\"job_id\")],          \"latest\",          None,          None,          False,          {\"path\": \"/path\", \"has_header\": True, \"prop\": \"ENV[FOO]\", \"exposed_type\": \"pandas\"},      )      @pytest.fixture(scope=\"function\")  def task(data_node):      dn = InMemoryDataNode(\"dn_config_id\", Scope.SCENARIO, version=\"random_version_number\")      return Task(\"task_config_id\", {}, print, [data_node], [dn])      @pytest.fixture(scope=\"function\")  def scenario_model(cycle):      return _ScenarioModel(          ScenarioId(\"sc_id\"),          \"sc\",          set(),          set(),          {},          creation_date=current_time.isoformat(),          primary_scenario=False,          subscribers=[],          tags=[\"foo\"],          version=\"random_version_number\",          cycle=None,      )      @pytest.fixture(scope=\"function\")  def cycle():      example_date = datetime.fromisoformat(\"2021-11-11T11:11:01.000001\")      return Cycle(          Frequency.DAILY,          {},          creation_date=example_date,          start_date=example_date,          end_date=example_date,          name=\"cc\",          id=CycleId(\"cc_id\"),      )      @pytest.fixture(scope=\"class\")  def sequence():      return Sequence(          {},          [],          SequenceId(\"sequence_id\"),          owner_id=\"owner_id\",          parent_ids=set([\"parent_id_1\", \"parent_id_2\"]),          version=\"random_version_number\",      )      @pytest.fixture(scope=\"function\")  def job(task):      return Job(JobId(\"job\"), task, \"foo\", \"bar\", version=\"random_version_number\")      @pytest.fixture(scope=\"function\")  def _version():      return _Version(id=\"foo\", config=Config._applied_config)      @pytest.fixture(scope=\"function\")  def cycle_model():      return _CycleModel(          CycleId(\"cc_id\"),          \"cc\",          Frequency.DAILY,          {},          creation_date=\"2021-11-11T11:11:01.000001\",          start_date=\"2021-11-11T11:11:01.000001\",          end_date=\"2021-11-11T11:11:01.000001\",      )      @pytest.fixture(scope=\"function\")  def tmp_sqlite(tmpdir_factory):      fn = tmpdir_factory.mktemp(\"db\")      return os.path.join(fn.strpath, \"test.db\")      @pytest.fixture(scope=\"function\", autouse=True)  def clean_repository():      from sqlalchemy.orm import close_all_sessions        close_all_sessions()      init_config()      init_orchestrator()      init_managers()      init_config()      init_notifier()        yield      def init_config():      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()      _Checker._checkers = []        _inject_section(          JobConfig, \"job_config\", JobConfig(\"development\"), [(\"configure_job_executions\", JobConfig._configure)], True      )      _inject_section(          CoreSection,          \"core\",          CoreSection.default_config(),          [(\"configure_core\", CoreSection._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_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)],          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)        Config.configure_core(read_entity_retry=0)      Core._is_running = False      def init_managers():      _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()      _SubmissionManagerFactory._build_manager()._delete_all()      def init_orchestrator():      if _OrchestratorFactory._orchestrator is None:          _OrchestratorFactory._build_orchestrator()      _OrchestratorFactory._build_dispatcher()      _OrchestratorFactory._orchestrator.jobs_to_run = Queue()      _OrchestratorFactory._orchestrator.blocked_jobs = []      def init_notifier():      Notifier._topics_registrations_list = {}      @pytest.fixture  def sql_engine():      return create_engine(\"sqlite:///:memory:\")      @pytest.fixture  def init_sql_repo(tmp_sqlite):      Config.configure_core(repository_type=\"sql\", repository_properties={\"db_location\": tmp_sqlite})        # Clean SQLite database      if _SQLConnection._connection:          _SQLConnection._connection.close()          _SQLConnection._connection = None      _SQLConnection.init_db()        return tmp_sqlite "}
{"text": "import os  import pathlib  from time import sleep  from unittest.mock import patch    import pandas as pd    import src.taipy.core.taipy as tp  from src.taipy.core import Core, Status  from src.taipy.core._orchestrator._orchestrator_factory import _OrchestratorFactory  from src.taipy.core.config.job_config import JobConfig  from taipy.config import Config    # ################################  USER FUNCTIONS  ##################################      def sum(a, b):      a = a[\"number\"]      b = b[\"number\"]      return a + b      def subtract(a, b):      a = a[\"number\"]      b = b[\"number\"]      return a - b      def mult(a, b):      return a * b      def mult_by_2(a):      return a      def divide(a, b):      return a / b      def average(a):      return [a.sum() / len(a)]      def div_constant_with_sleep(a):      sleep(1)      return a[\"number\"] / 10      def return_a_number():      return 10      def return_a_number_with_sleep():      sleep(1)      return 10      # ################################  TEST METHODS    ##################################      def test_skipped_jobs():      Config.configure_job_executions(mode=JobConfig._DEVELOPMENT_MODE)      _OrchestratorFactory._build_orchestrator()      input_config = Config.configure_data_node(\"input\")      intermediate_config = Config.configure_data_node(\"intermediate\")      output_config = Config.configure_data_node(\"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_config_1, task_config_2])        with patch(\"sys.argv\", [\"prog\"]):          core = Core()          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          core.stop()      def test_complex():      # d1 --- t1      # |      # | --- t2 --- d5 --- |                   t10 --- d12      #        |            |                   |      #        |            |                   |      #        d2           | --- t5 --- d7 --- t7 --- d9 --- t8 --- d10 --- t9 --- d11      #                     |                   |             |      # d3 --- |            |                   |             |      # |      |            |     t6 --- d8 -------------------      # |      t3 --- d6 ---|      # |      |      # |      |      # t4     d4        Config.configure_job_executions(mode=JobConfig._DEVELOPMENT_MODE)      _OrchestratorFactory._build_orchestrator()        csv_path_inp = os.path.join(pathlib.Path(__file__).parent.resolve(), \"data_sample/example.csv\")      excel_path_inp = os.path.join(pathlib.Path(__file__).parent.resolve(), \"data_sample/example.xlsx\")        csv_path_sum = os.path.join(pathlib.Path(__file__).parent.resolve(), \"data_sample/sum.csv\")      excel_path_sum = os.path.join(pathlib.Path(__file__).parent.resolve(), \"data_sample/sum.xlsx\")        excel_path_out = os.path.join(pathlib.Path(__file__).parent.resolve(), \"data_sample/res.xlsx\")      csv_path_out = os.path.join(pathlib.Path(__file__).parent.resolve(), \"data_sample/res.csv\")        inp_csv_dn_1 = Config.configure_csv_data_node(\"dn_csv_in_1\", default_path=csv_path_inp)      inp_csv_dn_2 = Config.configure_csv_data_node(\"dn_csv_in_2\", default_path=csv_path_inp)        inp_excel_dn_1 = Config.configure_excel_data_node(\"dn_excel_in_1\", default_path=excel_path_inp, sheet_name=\"Sheet1\")      inp_excel_dn_2 = Config.configure_excel_data_node(\"dn_excel_in_2\", default_path=excel_path_inp, sheet_name=\"Sheet1\")        placeholder = Config.configure_data_node(\"dn_placeholder\", default_data=10)        dn_csv_sum = Config.configure_csv_data_node(\"dn_sum_csv\", default_path=csv_path_sum)      dn_excel_sum = Config.configure_excel_data_node(\"dn_sum_excel\", default_path=excel_path_sum, sheet_name=\"Sheet1\")        dn_subtract_csv_excel = Config.configure_pickle_data_node(\"dn_subtract_csv_excel\")      dn_mult = Config.configure_pickle_data_node(\"dn_mult\")      dn_div = Config.configure_pickle_data_node(\"dn_div\")        output_csv_dn = Config.configure_csv_data_node(\"csv_out\", csv_path_out)      output_excel_dn = Config.configure_excel_data_node(\"excel_out\", excel_path_out)        task_print_csv = Config.configure_task(\"task_print_csv\", print, input=inp_csv_dn_1)      task_print_excel = Config.configure_task(\"task_print_excel\", print, input=inp_excel_dn_1)      task_sum_csv = Config.configure_task(\"task_sum_csv\", sum, input=[inp_csv_dn_2, inp_csv_dn_1], output=dn_csv_sum)      task_sum_excel = Config.configure_task(          \"task_sum_excel\", sum, input=[inp_excel_dn_2, inp_excel_dn_1], output=dn_excel_sum      )        task_subtract_csv_excel = Config.configure_task(          \"task_subtract_csv_excel\", subtract, input=[dn_csv_sum, dn_excel_sum], output=dn_subtract_csv_excel      )      task_insert_placeholder = Config.configure_task(\"task_insert_placeholder\", return_a_number, output=[placeholder])      task_mult = Config.configure_task(          \"task_mult_by_placeholder\", mult, input=[dn_subtract_csv_excel, placeholder], output=dn_mult      )      task_div = Config.configure_task(\"task_div_by_placeholder\", divide, input=[dn_mult, placeholder], output=dn_div)      task_avg_div = Config.configure_task(\"task_avg_div\", average, input=dn_div, output=output_csv_dn)      task_avg_mult = Config.configure_task(\"task_avg_mult\", average, input=dn_mult, output=output_excel_dn)        scenario_config = Config.configure_scenario(          \"scenario\",          [              task_print_csv,              task_print_excel,              task_sum_csv,              task_sum_excel,              task_subtract_csv_excel,              task_insert_placeholder,              task_mult,              task_div,              task_avg_div,              task_avg_mult,          ],      )        with patch(\"sys.argv\", [\"prog\"]):          core = Core()          core.run()          scenario = tp.create_scenario(scenario_config)          tp.submit(scenario)          core.stop()        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) "}
{"text": "\"\"\"Unit test package for taipy.\"\"\" "}
{"text": "import datetime  import os  import pathlib  import shutil  from unittest import mock    import pytest    import src.taipy.core.taipy as tp  from src.taipy.core import (      Core,      Cycle,      CycleId,      DataNodeId,      JobId,      Scenario,      ScenarioId,      Sequence,      SequenceId,      Task,      TaskId,  )  from src.taipy.core._orchestrator._orchestrator_factory import _OrchestratorFactory  from src.taipy.core._version._version_manager import _VersionManager  from src.taipy.core.config.data_node_config import DataNodeConfig  from src.taipy.core.config.job_config import JobConfig  from src.taipy.core.config.scenario_config import ScenarioConfig  from src.taipy.core.cycle._cycle_manager import _CycleManager  from src.taipy.core.data._data_manager import _DataManager  from src.taipy.core.data.pickle import PickleDataNode  from src.taipy.core.exceptions.exceptions import DataNodeConfigIsNotGlobal, InvalidExportPath  from src.taipy.core.job._job_manager import _JobManager  from src.taipy.core.job.job import Job  from src.taipy.core.scenario._scenario_manager import _ScenarioManager  from src.taipy.core.sequence._sequence_manager import _SequenceManager  from src.taipy.core.task._task_manager import _TaskManager  from taipy.config.common.frequency import Frequency  from taipy.config.common.scope import Scope  from taipy.config.config import Config  from taipy.config.exceptions.exceptions import ConfigurationUpdateBlocked      class TestTaipy:      def test_set(self, scenario, cycle, sequence, data_node, task):          with mock.patch(\"src.taipy.core.data._data_manager._DataManager._set\") as mck:              tp.set(data_node)              mck.assert_called_once_with(data_node)          with mock.patch(\"src.taipy.core.task._task_manager._TaskManager._set\") as mck:              tp.set(task)              mck.assert_called_once_with(task)          with mock.patch(\"src.taipy.core.sequence._sequence_manager._SequenceManager._set\") as mck:              tp.set(sequence)              mck.assert_called_once_with(sequence)          with mock.patch(\"src.taipy.core.scenario._scenario_manager._ScenarioManager._set\") as mck:              tp.set(scenario)              mck.assert_called_once_with(scenario)          with mock.patch(\"src.taipy.core.cycle._cycle_manager._CycleManager._set\") as mck:              tp.set(cycle)              mck.assert_called_once_with(cycle)        def test_is_editable_is_called(self, cycle, job, data_node):          with mock.patch(\"src.taipy.core.cycle._cycle_manager._CycleManager._is_editable\") as mck:              cycle_id = CycleId(\"CYCLE_id\")              tp.is_editable(cycle_id)              mck.assert_called_once_with(cycle_id)            with mock.patch(\"src.taipy.core.cycle._cycle_manager._CycleManager._is_editable\") as mck:              tp.is_editable(cycle)              mck.assert_called_once_with(cycle)            with mock.patch(\"src.taipy.core.scenario._scenario_manager._ScenarioManager._is_editable\") as mck:              scenario_id = ScenarioId(\"SCENARIO_id\")              tp.is_editable(scenario_id)              mck.assert_called_once_with(scenario_id)            with mock.patch(\"src.taipy.core.scenario._scenario_manager._ScenarioManager._is_editable\") as mck:              scenario = Scenario(\"scenario_config_id\", [], {})              tp.is_editable(scenario)              mck.assert_called_once_with(scenario)            with mock.patch(\"src.taipy.core.sequence._sequence_manager._SequenceManager._is_editable\") as mck:              sequence_id = SequenceId(\"SEQUENCE_id\")              tp.is_editable(sequence_id)              mck.assert_called_once_with(sequence_id)            with mock.patch(\"src.taipy.core.sequence._sequence_manager._SequenceManager._is_editable\") as mck:              sequence = Sequence({}, [], \"sequence_id\")              tp.is_editable(sequence)              mck.assert_called_once_with(sequence)            with mock.patch(\"src.taipy.core.task._task_manager._TaskManager._is_editable\") as mck:              task_id = TaskId(\"TASK_id\")              tp.is_editable(task_id)              mck.assert_called_once_with(task_id)            with mock.patch(\"src.taipy.core.task._task_manager._TaskManager._is_editable\") as mck:              task = Task(\"task_config_id\", {}, print)              tp.is_editable(task)              mck.assert_called_once_with(task)            with mock.patch(\"src.taipy.core.job._job_manager._JobManager._is_editable\") as mck:              job_id = JobId(\"JOB_id\")              tp.is_editable(job_id)              mck.assert_called_once_with(job_id)            with mock.patch(\"src.taipy.core.job._job_manager._JobManager._is_editable\") as mck:              tp.is_editable(job)              mck.assert_called_once_with(job)            with mock.patch(\"src.taipy.core.data._data_manager._DataManager._is_editable\") as mck:              dn_id = DataNodeId(\"DATANODE_id\")              tp.is_editable(dn_id)              mck.assert_called_once_with(dn_id)            with mock.patch(\"src.taipy.core.data._data_manager._DataManager._is_editable\") as mck:              tp.is_editable(data_node)              mck.assert_called_once_with(data_node)        def test_is_editable(self):          current_date = datetime.datetime.now()            cycle = Cycle(Frequency.DAILY, {}, current_date, current_date, current_date)          scenario = Scenario(\"scenario_config_id\", [], {}, sequences={\"sequence\": {}})            task = Task(\"task_config_id\", {}, print)          job = Job(\"job_id\", task, \"submit_id\", scenario.id)          dn = PickleDataNode(\"data_node_config_id\", Scope.SCENARIO)            _CycleManager._set(cycle)          _ScenarioManager._set(scenario)          _TaskManager._set(task)          _JobManager._set(job)          _DataManager._set(dn)          sequence = scenario.sequences[\"sequence\"]            assert tp.is_editable(scenario)          assert tp.is_editable(sequence)          assert tp.is_editable(task)          assert tp.is_editable(cycle)          assert tp.is_editable(job)          assert tp.is_editable(dn)        def test_is_readable_is_called(self, cycle, job, data_node):          with mock.patch(\"src.taipy.core.cycle._cycle_manager._CycleManager._is_readable\") as mck:              cycle_id = CycleId(\"CYCLE_id\")              tp.is_readable(cycle_id)              mck.assert_called_once_with(cycle_id)            with mock.patch(\"src.taipy.core.cycle._cycle_manager._CycleManager._is_readable\") as mck:              tp.is_readable(cycle)              mck.assert_called_once_with(cycle)            with mock.patch(\"src.taipy.core.scenario._scenario_manager._ScenarioManager._is_readable\") as mck:              scenario_id = ScenarioId(\"SCENARIO_id\")              tp.is_readable(scenario_id)              mck.assert_called_once_with(scenario_id)            with mock.patch(\"src.taipy.core.scenario._scenario_manager._ScenarioManager._is_readable\") as mck:              scenario = Scenario(\"scenario_config_id\", [], {})              tp.is_readable(scenario)              mck.assert_called_once_with(scenario)            with mock.patch(\"src.taipy.core.sequence._sequence_manager._SequenceManager._is_readable\") as mck:              sequence_id = SequenceId(\"SEQUENCE_id\")              tp.is_readable(sequence_id)              mck.assert_called_once_with(sequence_id)            with mock.patch(\"src.taipy.core.sequence._sequence_manager._SequenceManager._is_readable\") as mck:              sequence = Sequence({}, [], \"sequence_id\")              tp.is_readable(sequence)              mck.assert_called_once_with(sequence)            with mock.patch(\"src.taipy.core.task._task_manager._TaskManager._is_readable\") as mck:              task_id = TaskId(\"TASK_id\")              tp.is_readable(task_id)              mck.assert_called_once_with(task_id)            with mock.patch(\"src.taipy.core.task._task_manager._TaskManager._is_readable\") as mck:              task = Task(\"task_config_id\", {}, print)              tp.is_readable(task)              mck.assert_called_once_with(task)            with mock.patch(\"src.taipy.core.job._job_manager._JobManager._is_readable\") as mck:              job_id = JobId(\"JOB_id\")              tp.is_readable(job_id)              mck.assert_called_once_with(job_id)            with mock.patch(\"src.taipy.core.job._job_manager._JobManager._is_readable\") as mck:              tp.is_readable(job)              mck.assert_called_once_with(job)            with mock.patch(\"src.taipy.core.data._data_manager._DataManager._is_readable\") as mck:              dn_id = DataNodeId(\"DATANODE_id\")              tp.is_readable(dn_id)              mck.assert_called_once_with(dn_id)            with mock.patch(\"src.taipy.core.data._data_manager._DataManager._is_readable\") as mck:              tp.is_readable(data_node)              mck.assert_called_once_with(data_node)        def test_is_readable(self):          current_date = datetime.datetime.now()            cycle = Cycle(Frequency.DAILY, {}, current_date, current_date, current_date)          scenario = Scenario(\"scenario_config_id\", [], {}, sequences={\"sequence\": {}})            task = Task(\"task_config_id\", {}, print)          job = Job(\"job_id\", task, \"submit_id\", scenario.id)          dn = PickleDataNode(\"data_node_config_id\", Scope.SCENARIO)            _CycleManager._set(cycle)          _ScenarioManager._set(scenario)          _TaskManager._set(task)          _JobManager._set(job)          _DataManager._set(dn)          sequence = scenario.sequences[\"sequence\"]            assert tp.is_readable(scenario)          assert tp.is_readable(sequence)          assert tp.is_readable(task)          assert tp.is_readable(cycle)          assert tp.is_readable(job)          assert tp.is_readable(dn)        def test_is_submittable_is_called(self):          with mock.patch(\"src.taipy.core.scenario._scenario_manager._ScenarioManager._is_submittable\") as mck:              scenario_id = ScenarioId(\"SCENARIO_id\")              tp.is_submittable(scenario_id)              mck.assert_called_once_with(scenario_id)            with mock.patch(\"src.taipy.core.scenario._scenario_manager._ScenarioManager._is_submittable\") as mck:              scenario = Scenario(\"scenario_config_id\", [], {})              tp.is_submittable(scenario)              mck.assert_called_once_with(scenario)            with mock.patch(\"src.taipy.core.sequence._sequence_manager._SequenceManager._is_submittable\") as mck:              sequence_id = SequenceId(\"SEQUENCE_id\")              tp.is_submittable(sequence_id)              mck.assert_called_once_with(sequence_id)            with mock.patch(\"src.taipy.core.sequence._sequence_manager._SequenceManager._is_submittable\") as mck:              sequence = Sequence({}, [], \"sequence_id\")              tp.is_submittable(sequence)              mck.assert_called_once_with(sequence)            with mock.patch(\"src.taipy.core.task._task_manager._TaskManager._is_submittable\") as mck:              task_id = TaskId(\"TASK_id\")              tp.is_submittable(task_id)              mck.assert_called_once_with(task_id)            with mock.patch(\"src.taipy.core.task._task_manager._TaskManager._is_submittable\") as mck:              task = Task(\"task_config_id\", {}, print)              tp.is_submittable(task)              mck.assert_called_once_with(task)        def test_is_submittable(self):          current_date = datetime.datetime.now()            cycle = Cycle(Frequency.DAILY, {}, current_date, current_date, current_date)          scenario = Scenario(\"scenario_config_id\", [], {}, sequences={\"sequence\": {}})            task = Task(\"task_config_id\", {}, print)          job = Job(\"job_id\", task, \"submit_id\", scenario.id)          dn = PickleDataNode(\"data_node_config_id\", Scope.SCENARIO)            _CycleManager._set(cycle)          _ScenarioManager._set(scenario)          _TaskManager._set(task)          _JobManager._set(job)          _DataManager._set(dn)          sequence = scenario.sequences[\"sequence\"]            assert tp.is_submittable(scenario)          assert tp.is_submittable(sequence)          assert tp.is_submittable(task)          assert not tp.is_submittable(cycle)          assert not tp.is_submittable(job)          assert not tp.is_submittable(dn)        def test_submit(self, scenario, sequence, task):          with mock.patch(\"src.taipy.core.scenario._scenario_manager._ScenarioManager._submit\") as mck:              tp.submit(scenario)              mck.assert_called_once_with(scenario, force=False, wait=False, timeout=None)          with mock.patch(\"src.taipy.core.sequence._sequence_manager._SequenceManager._submit\") as mck:              tp.submit(sequence)              mck.assert_called_once_with(sequence, force=False, wait=False, timeout=None)          with mock.patch(\"src.taipy.core.task._task_manager._TaskManager._submit\") as mck:              tp.submit(task)              mck.assert_called_once_with(task, force=False, wait=False, timeout=None)          with mock.patch(\"src.taipy.core.scenario._scenario_manager._ScenarioManager._submit\") as mck:              tp.submit(scenario, False, False, None)              mck.assert_called_once_with(scenario, force=False, wait=False, timeout=None)          with mock.patch(\"src.taipy.core.sequence._sequence_manager._SequenceManager._submit\") as mck:              tp.submit(sequence, False, False, None)              mck.assert_called_once_with(sequence, force=False, wait=False, timeout=None)          with mock.patch(\"src.taipy.core.task._task_manager._TaskManager._submit\") as mck:              tp.submit(task, False, False, None)              mck.assert_called_once_with(task, force=False, wait=False, timeout=None)          with mock.patch(\"src.taipy.core.scenario._scenario_manager._ScenarioManager._submit\") as mck:              tp.submit(scenario, True, True, 60)              mck.assert_called_once_with(scenario, force=True, wait=True, timeout=60)          with mock.patch(\"src.taipy.core.sequence._sequence_manager._SequenceManager._submit\") as mck:              tp.submit(sequence, True, True, 60)              mck.assert_called_once_with(sequence, force=True, wait=True, timeout=60)          with mock.patch(\"src.taipy.core.task._task_manager._TaskManager._submit\") as mck:              tp.submit(task, True, True, 60)              mck.assert_called_once_with(task, force=True, wait=True, timeout=60)        def test_warning_no_core_service_running(self, scenario):          _OrchestratorFactory._remove_dispatcher()            with pytest.warns(ResourceWarning) as warning:              with mock.patch(\"src.taipy.core.scenario._scenario_manager._ScenarioManager._submit\"):                  tp.submit(scenario)            assert len(warning) == 1          assert warning[0].message.args[0] == \"The Core service is NOT running\"        def test_get_tasks(self):          with mock.patch(\"src.taipy.core.task._task_manager._TaskManager._get_all\") as mck:              tp.get_tasks()              mck.assert_called_once_with()        def test_get_task(self, task):          with mock.patch(\"src.taipy.core.task._task_manager._TaskManager._get\") as mck:              task_id = TaskId(\"TASK_id\")              tp.get(task_id)              mck.assert_called_once_with(task_id)        def test_task_exists(self):          with mock.patch(\"src.taipy.core.task._task_manager._TaskManager._exists\") as mck:              task_id = TaskId(\"TASK_id\")              tp.exists(task_id)              mck.assert_called_once_with(task_id)        def test_is_deletable(self, task):          with mock.patch(\"src.taipy.core.scenario._scenario_manager._ScenarioManager._is_deletable\") as mck:              scenario_id = ScenarioId(\"SCENARIO_id\")              tp.is_deletable(scenario_id)              mck.assert_called_once_with(scenario_id)            with mock.patch(\"src.taipy.core.scenario._scenario_manager._ScenarioManager._is_deletable\") as mck:              scenario = Scenario(\"config_id\", [], {})              tp.is_deletable(scenario)              mck.assert_called_once_with(scenario)            with mock.patch(\"src.taipy.core.job._job_manager._JobManager._is_deletable\") as mck:              job_id = JobId(\"JOB_job_id\")              tp.is_deletable(job_id)              mck.assert_called_once_with(job_id)            with mock.patch(\"src.taipy.core.job._job_manager._JobManager._is_deletable\") as mck:              job = Job(\"job_id\", task, \"submit_id\", task.id)              tp.is_deletable(job)              mck.assert_called_once_with(job)        def test_is_promotable(self):          with mock.patch(\"src.taipy.core.scenario._scenario_manager._ScenarioManager._is_promotable_to_primary\") as mck:              scenario_id = ScenarioId(\"SCENARIO_id\")              tp.is_promotable(scenario_id)              mck.assert_called_once_with(scenario_id)            with mock.patch(\"src.taipy.core.scenario._scenario_manager._ScenarioManager._is_promotable_to_primary\") as mck:              scenario = Scenario(\"config_id\", [], {})              tp.is_promotable(scenario)              mck.assert_called_once_with(scenario)        def test_delete_scenario(self):          with mock.patch(\"src.taipy.core.scenario._scenario_manager._ScenarioManager._hard_delete\") as mck:              scenario_id = ScenarioId(\"SCENARIO_id\")              tp.delete(scenario_id)              mck.assert_called_once_with(scenario_id)        def test_delete(self):          with mock.patch(\"src.taipy.core.cycle._cycle_manager._CycleManager._hard_delete\") as mck:              cycle_id = CycleId(\"CYCLE_id\")              tp.delete(cycle_id)              mck.assert_called_once_with(cycle_id)        def test_get_scenarios(self, cycle):          with mock.patch(\"src.taipy.core.scenario._scenario_manager._ScenarioManager._get_all\") as mck:              tp.get_scenarios()              mck.assert_called_once_with()          with mock.patch(\"src.taipy.core.scenario._scenario_manager._ScenarioManager._get_all_by_cycle\") as mck:              tp.get_scenarios(cycle)              mck.assert_called_once_with(cycle)          with mock.patch(\"src.taipy.core.scenario._scenario_manager._ScenarioManager._get_all_by_tag\") as mck:              tp.get_scenarios(tag=\"tag\")              mck.assert_called_once_with(\"tag\")        def test_get_scenario(self, scenario):          with mock.patch(\"src.taipy.core.scenario._scenario_manager._ScenarioManager._get\") as mck:              scenario_id = ScenarioId(\"SCENARIO_id\")              tp.get(scenario_id)              mck.assert_called_once_with(scenario_id)        def test_scenario_exists(self):          with mock.patch(\"src.taipy.core.scenario._scenario_manager._ScenarioManager._exists\") as mck:              scenario_id = ScenarioId(\"SCENARIO_id\")              tp.exists(scenario_id)              mck.assert_called_once_with(scenario_id)        def test_get_primary(self, cycle):          with mock.patch(\"src.taipy.core.scenario._scenario_manager._ScenarioManager._get_primary\") as mck:              tp.get_primary(cycle)              mck.assert_called_once_with(cycle)        def test_get_primary_scenarios(self):          with mock.patch(\"src.taipy.core.scenario._scenario_manager._ScenarioManager._get_primary_scenarios\") as mck:              tp.get_primary_scenarios()              mck.assert_called_once_with()        def test_set_primary(self, scenario):          with mock.patch(\"src.taipy.core.scenario._scenario_manager._ScenarioManager._set_primary\") as mck:              tp.set_primary(scenario)              mck.assert_called_once_with(scenario)        def test_tag_and_untag(self, scenario):          with mock.patch(\"src.taipy.core.scenario._scenario_manager._ScenarioManager._tag\") as mck:              tp.tag(scenario, \"tag\")              mck.assert_called_once_with(scenario, \"tag\")          with mock.patch(\"src.taipy.core.scenario._scenario_manager._ScenarioManager._untag\") as mck:              tp.untag(scenario, \"tag\")              mck.assert_called_once_with(scenario, \"tag\")        def test_compare_scenarios(self, scenario):          with mock.patch(\"src.taipy.core.scenario._scenario_manager._ScenarioManager._compare\") as mck:              tp.compare_scenarios(scenario, scenario, data_node_config_id=\"dn\")              mck.assert_called_once_with(scenario, scenario, data_node_config_id=\"dn\")        def test_subscribe_scenario(self, scenario):          with mock.patch(\"src.taipy.core.scenario._scenario_manager._ScenarioManager._subscribe\") as mck:              tp.subscribe_scenario(print)              mck.assert_called_once_with(print, [], None)          with mock.patch(\"src.taipy.core.scenario._scenario_manager._ScenarioManager._subscribe\") as mck:              tp.subscribe_scenario(print, scenario=scenario)              mck.assert_called_once_with(print, [], scenario)        def test_unsubscribe_scenario(self, scenario):          with mock.patch(\"src.taipy.core.scenario._scenario_manager._ScenarioManager._unsubscribe\") as mck:              tp.unsubscribe_scenario(print)              mck.assert_called_once_with(print, None, None)          with mock.patch(\"src.taipy.core.scenario._scenario_manager._ScenarioManager._unsubscribe\") as mck:              tp.unsubscribe_scenario(print, scenario=scenario)              mck.assert_called_once_with(print, None, scenario)        def test_subscribe_sequence(self, sequence):          with mock.patch(\"src.taipy.core.sequence._sequence_manager._SequenceManager._subscribe\") as mck:              tp.subscribe_sequence(print)              mck.assert_called_once_with(print, None, None)          with mock.patch(\"src.taipy.core.sequence._sequence_manager._SequenceManager._subscribe\") as mck:              tp.subscribe_sequence(print, sequence=sequence)              mck.assert_called_once_with(print, None, sequence)        def test_unsubscribe_sequence(self, sequence):          with mock.patch(\"src.taipy.core.sequence._sequence_manager._SequenceManager._unsubscribe\") as mck:              tp.unsubscribe_sequence(callback=print)              mck.assert_called_once_with(print, None, None)          with mock.patch(\"src.taipy.core.sequence._sequence_manager._SequenceManager._unsubscribe\") as mck:              tp.unsubscribe_sequence(callback=print, sequence=sequence)              mck.assert_called_once_with(print, None, sequence)        def test_delete_sequence(self):          with mock.patch(\"src.taipy.core.sequence._sequence_manager._SequenceManager._hard_delete\") as mck:              sequence_id = SequenceId(\"SEQUENCE_id\")              tp.delete(sequence_id)              mck.assert_called_once_with(sequence_id)        def test_get_sequence(self, sequence):          with mock.patch(\"src.taipy.core.sequence._sequence_manager._SequenceManager._get\") as mck:              sequence_id = SequenceId(\"SEQUENCE_id\")              tp.get(sequence_id)              mck.assert_called_once_with(sequence_id)        def test_get_sequences(self):          with mock.patch(\"src.taipy.core.sequence._sequence_manager._SequenceManager._get_all\") as mck:              tp.get_sequences()              mck.assert_called_once_with()        def test_sequence_exists(self):          with mock.patch(\"src.taipy.core.sequence._sequence_manager._SequenceManager._exists\") as mck:              sequence_id = SequenceId(\"SEQUENCE_id\")              tp.exists(sequence_id)              mck.assert_called_once_with(sequence_id)        def test_get_job(self):          with mock.patch(\"src.taipy.core.job._job_manager._JobManager._get\") as mck:              job_id = JobId(\"JOB_id\")              tp.get(job_id)              mck.assert_called_once_with(job_id)        def test_get_jobs(self):          with mock.patch(\"src.taipy.core.job._job_manager._JobManager._get_all\") as mck:              tp.get_jobs()              mck.assert_called_once_with()        def test_job_exists(self):          with mock.patch(\"src.taipy.core.job._job_manager._JobManager._exists\") as mck:              job_id = JobId(\"JOB_id\")              tp.exists(job_id)              mck.assert_called_once_with(job_id)        def test_delete_job(self, task):          with mock.patch(\"src.taipy.core.job._job_manager._JobManager._delete\") as mck:              job = Job(JobId(\"job_id\"), task, \"submit_id\", \"scenario_id\")              tp.delete_job(job)              mck.assert_called_once_with(job, False)          with mock.patch(\"src.taipy.core.job._job_manager._JobManager._delete\") as mck:              job = Job(JobId(\"job_id\"), task, \"submit_id\", \"scenario_id\")              tp.delete_job(job, False)              mck.assert_called_once_with(job, False)          with mock.patch(\"src.taipy.core.job._job_manager._JobManager._delete\") as mck:              job = Job(JobId(\"job_id\"), task, \"submit_id\", \"scenario_id\")              tp.delete_job(job, True)              mck.assert_called_once_with(job, True)        def test_delete_jobs(self):          with mock.patch(\"src.taipy.core.job._job_manager._JobManager._delete_all\") as mck:              tp.delete_jobs()              mck.assert_called_once_with()        def test_get_latest_job(self, task):          with mock.patch(\"src.taipy.core.job._job_manager._JobManager._get_latest\") as mck:              tp.get_latest_job(task)              mck.assert_called_once_with(task)        def test_get_latest_submission(self, task):          with mock.patch(\"src.taipy.core.submission._submission_manager._SubmissionManager._get_latest\") as mck:              tp.get_latest_submission(task)              mck.assert_called_once_with(task)        def test_cancel_job(self):          with mock.patch(\"src.taipy.core.job._job_manager._JobManager._cancel\") as mck:              tp.cancel_job(\"job_id\")              mck.assert_called_once_with(\"job_id\")        def test_block_config_when_core_is_running_in_development_mode(self):          input_cfg_1 = Config.configure_data_node(id=\"i1\", storage_type=\"pickle\", default_data=1, scope=Scope.SCENARIO)          output_cfg_1 = Config.configure_data_node(id=\"o1\", storage_type=\"pickle\", scope=Scope.SCENARIO)          task_cfg_1 = Config.configure_task(\"t1\", print, input_cfg_1, output_cfg_1)          scenario_cfg_1 = Config.configure_scenario(\"s1\", [task_cfg_1], [], Frequency.DAILY)            core = Core()          core.run()            scenario_1 = tp.create_scenario(scenario_cfg_1)          tp.submit(scenario_1)            with pytest.raises(ConfigurationUpdateBlocked):              Config.configure_scenario(\"block_scenario\", set([task_cfg_1]))          core.stop()        def test_block_config_when_core_is_running_in_standalone_mode(self):          Config.configure_job_executions(mode=JobConfig._STANDALONE_MODE)            input_cfg_1 = Config.configure_data_node(id=\"i1\", storage_type=\"pickle\", default_data=1, scope=Scope.SCENARIO)          output_cfg_1 = Config.configure_data_node(id=\"o1\", storage_type=\"pickle\", scope=Scope.SCENARIO)          task_cfg_1 = Config.configure_task(\"t1\", print, input_cfg_1, output_cfg_1)          scenario_cfg_1 = Config.configure_scenario(\"s1\", [task_cfg_1], [], Frequency.DAILY)            core = Core()          core.run()            scenario_1 = tp.create_scenario(scenario_cfg_1)          tp.submit(scenario_1, wait=True)            with pytest.raises(ConfigurationUpdateBlocked):              Config.configure_scenario(\"block_scenario\", set([task_cfg_1]))          core.stop()        def test_get_data_node(self, data_node):          with mock.patch(\"src.taipy.core.data._data_manager._DataManager._get\") as mck:              tp.get(data_node.id)              mck.assert_called_once_with(data_node.id)        def test_get_data_nodes(self):          with mock.patch(\"src.taipy.core.data._data_manager._DataManager._get_all\") as mck:              tp.get_data_nodes()              mck.assert_called_once_with()        def test_data_node_exists(self):          with mock.patch(\"src.taipy.core.data._data_manager._DataManager._exists\") as mck:              data_node_id = DataNodeId(\"DATANODE_id\")              tp.exists(data_node_id)              mck.assert_called_once_with(data_node_id)        def test_get_cycles(self):          with mock.patch(\"src.taipy.core.cycle._cycle_manager._CycleManager._get_all\") as mck:              tp.get_cycles()              mck.assert_called_once_with()        def test_cycle_exists(self):          with mock.patch(\"src.taipy.core.cycle._cycle_manager._CycleManager._exists\") as mck:              cycle_id = CycleId(\"CYCLE_id\")              tp.exists(cycle_id)              mck.assert_called_once_with(cycle_id)        def test_create_global_data_node(self):          dn_cfg = DataNodeConfig(\"id\", \"pickle\", Scope.GLOBAL)          with mock.patch(\"src.taipy.core.data._data_manager._DataManager._create_and_set\") as mck:              dn = tp.create_global_data_node(dn_cfg)              mck.assert_called_once_with(dn_cfg, None, None)            dn = tp.create_global_data_node(dn_cfg)          assert dn.scope == Scope.GLOBAL          assert dn.config_id == dn_cfg.id            # Create a global data node from the same configuration should return the same data node          dn_2 = tp.create_global_data_node(dn_cfg)          assert dn_2.id == dn.id            dn_cfg.scope = Scope.SCENARIO          with pytest.raises(DataNodeConfigIsNotGlobal):              tp.create_global_data_node(dn_cfg)        def test_create_scenario(self, scenario):          scenario_config = ScenarioConfig(\"scenario_config\")          with mock.patch(\"src.taipy.core.scenario._scenario_manager._ScenarioManager._create\") as mck:              tp.create_scenario(scenario_config)              mck.assert_called_once_with(scenario_config, None, None)          with mock.patch(\"src.taipy.core.scenario._scenario_manager._ScenarioManager._create\") as mck:              tp.create_scenario(scenario_config, datetime.datetime(2022, 2, 5))              mck.assert_called_once_with(scenario_config, datetime.datetime(2022, 2, 5), None)          with mock.patch(\"src.taipy.core.scenario._scenario_manager._ScenarioManager._create\") as mck:              tp.create_scenario(scenario_config, datetime.datetime(2022, 2, 5), \"displayable_name\")              mck.assert_called_once_with(scenario_config, datetime.datetime(2022, 2, 5), \"displayable_name\")        def test_export_scenario_filesystem(self):          shutil.rmtree(\"./tmp\", ignore_errors=True)            input_cfg_1 = Config.configure_data_node(id=\"i1\", storage_type=\"pickle\", default_data=1, scope=Scope.SCENARIO)          output_cfg_1 = Config.configure_data_node(id=\"o1\", storage_type=\"pickle\", scope=Scope.SCENARIO)          task_cfg_1 = Config.configure_task(\"t1\", print, input_cfg_1, output_cfg_1)          scenario_cfg_1 = Config.configure_scenario(\"s1\", [task_cfg_1], [], Frequency.DAILY)            input_cfg_2 = Config.configure_data_node(id=\"i2\", storage_type=\"pickle\", default_data=2, scope=Scope.SCENARIO)          output_cfg_2 = Config.configure_data_node(id=\"o2\", storage_type=\"pickle\", scope=Scope.SCENARIO)          task_cfg_2 = Config.configure_task(\"t2\", print, input_cfg_2, output_cfg_2)          scenario_cfg_2 = Config.configure_scenario(\"s2\", [task_cfg_2], [], Frequency.DAILY)            scenario_1 = tp.create_scenario(scenario_cfg_1)          job_1 = tp.submit(scenario_1)[0]            # Export scenario 1          tp.export_scenario(scenario_1.id, \"./tmp/exp_scenario_1\")          assert sorted(os.listdir(\"./tmp/exp_scenario_1/data_nodes\")) == sorted(              [f\"{scenario_1.i1.id}.json\", f\"{scenario_1.o1.id}.json\"]          )          assert sorted(os.listdir(\"./tmp/exp_scenario_1/tasks\")) == sorted([f\"{scenario_1.t1.id}.json\"])          assert sorted(os.listdir(\"./tmp/exp_scenario_1/scenarios\")) == sorted([f\"{scenario_1.id}.json\"])          assert sorted(os.listdir(\"./tmp/exp_scenario_1/jobs\")) == sorted([f\"{job_1.id}.json\"])          assert sorted(os.listdir(\"./tmp/exp_scenario_1/cycles\")) == sorted([f\"{scenario_1.cycle.id}.json\"])            scenario_2 = tp.create_scenario(scenario_cfg_2)          job_2 = tp.submit(scenario_2)[0]            # Export scenario 2          scenario_2.export(pathlib.Path.cwd() / \"./tmp/exp_scenario_2\")          assert sorted(os.listdir(\"./tmp/exp_scenario_2/data_nodes\")) == sorted(              [f\"{scenario_2.i2.id}.json\", f\"{scenario_2.o2.id}.json\"]          )          assert sorted(os.listdir(\"./tmp/exp_scenario_2/tasks\")) == sorted([f\"{scenario_2.t2.id}.json\"])          assert sorted(os.listdir(\"./tmp/exp_scenario_2/scenarios\")) == sorted([f\"{scenario_2.id}.json\"])          assert sorted(os.listdir(\"./tmp/exp_scenario_2/jobs\")) == sorted([f\"{job_2.id}.json\"])          assert sorted(os.listdir(\"./tmp/exp_scenario_2/cycles\")) == sorted([f\"{scenario_2.cycle.id}.json\"])            # Export scenario 2 into the folder containing scenario 1 files          tp.export_scenario(scenario_2.id, \"./tmp/exp_scenario_1\")          # Should have the files as scenario 1 only          assert sorted(os.listdir(\"./tmp/exp_scenario_1/tasks\")) == sorted([f\"{scenario_2.t2.id}.json\"])          assert sorted(os.listdir(\"./tmp/exp_scenario_1/scenarios\")) == sorted([f\"{scenario_2.id}.json\"])          assert sorted(os.listdir(\"./tmp/exp_scenario_1/jobs\")) == sorted([f\"{job_2.id}.json\"])          assert sorted(os.listdir(\"./tmp/exp_scenario_1/cycles\")) == sorted([f\"{scenario_2.cycle.id}.json\"])            with pytest.raises(InvalidExportPath):              tp.export_scenario(scenario_2.id, Config.core.storage_folder)            shutil.rmtree(\"./tmp\", ignore_errors=True)        def test_get_parents(self):          def assert_result_parents_and_expected_parents(parents, expected_parents):              for key, items in expected_parents.items():                  assert len(parents[key]) == len(expected_parents[key])                  parent_ids = [parent.id for parent in parents[key]]                  assert all([item.id in parent_ids for item in items])            dn_config_1 = Config.configure_data_node(id=\"d1\", storage_type=\"in_memory\", scope=Scope.SCENARIO)          dn_config_2 = Config.configure_data_node(id=\"d2\", storage_type=\"in_memory\", scope=Scope.SCENARIO)          dn_config_3 = Config.configure_data_node(id=\"d3\", storage_type=\"in_memory\", scope=Scope.SCENARIO)          dn_config_4 = Config.configure_data_node(id=\"d4\", storage_type=\"in_memory\", scope=Scope.SCENARIO)          task_config_1 = Config.configure_task(\"t1\", print, dn_config_1, dn_config_2)          task_config_2 = Config.configure_task(\"t2\", print, dn_config_2, dn_config_3)          scenario_cfg_1 = Config.configure_scenario(\"s1\", [task_config_1, task_config_2], [dn_config_4], Frequency.DAILY)            scenario = tp.create_scenario(scenario_cfg_1)          tasks = scenario.tasks            expected_parents = {              \"scenario\": {scenario},              \"task\": {tasks[\"t1\"]},          }          parents = tp.get_parents(scenario.tasks[\"t1\"].data_nodes[\"d1\"])          assert_result_parents_and_expected_parents(parents, expected_parents)            expected_parents = {              \"scenario\": {scenario},              \"task\": {tasks[\"t1\"], tasks[\"t2\"]},          }          parents = tp.get_parents(scenario.tasks[\"t1\"].data_nodes[\"d2\"])          assert_result_parents_and_expected_parents(parents, expected_parents)            expected_parents = {\"scenario\": {scenario}, \"task\": {tasks[\"t2\"]}}          parents = tp.get_parents(scenario.tasks[\"t2\"].data_nodes[\"d3\"])          assert_result_parents_and_expected_parents(parents, expected_parents)            expected_parents = {\"scenario\": {scenario}}          parents = tp.get_parents(scenario.tasks[\"t1\"])          assert_result_parents_and_expected_parents(parents, expected_parents)            expected_parents = {\"scenario\": {scenario}}          parents = tp.get_parents(scenario.tasks[\"t2\"])          assert_result_parents_and_expected_parents(parents, expected_parents)            expected_parents = {\"scenario\": {scenario}}          parents = tp.get_parents(scenario.additional_data_nodes[\"d4\"])          assert_result_parents_and_expected_parents(parents, expected_parents)            expected_parents = {}          parents = tp.get_parents(scenario)          assert_result_parents_and_expected_parents(parents, expected_parents)            expected_parents = {}          parents = tp.get_parents(scenario.cycle)          assert_result_parents_and_expected_parents(parents, expected_parents)        def test_get_cycles_scenarios(self):          scenario_cfg_1 = Config.configure_scenario(              \"s1\",              set(),              set(),              Frequency.DAILY,          )          scenario_cfg_2 = Config.configure_scenario(\"s2\", set(), set(), Frequency.WEEKLY)          scenario_cfg_3 = Config.configure_scenario(\"s3\", set(), set(), Frequency.MONTHLY)          scenario_cfg_4 = Config.configure_scenario(\"s4\", set(), set(), Frequency.YEARLY)          scenario_cfg_5 = Config.configure_scenario(\"s5\", set(), set(), None)            now = datetime.datetime.now()          scenario_1_1 = tp.create_scenario(scenario_cfg_1, now)          scenario_1_2 = tp.create_scenario(scenario_cfg_1, datetime.datetime.now())          scenario_1_3 = tp.create_scenario(scenario_cfg_1, now + datetime.timedelta(days=1))          scenario_1_4 = tp.create_scenario(scenario_cfg_1, now + datetime.timedelta(days=8))          scenario_1_5 = tp.create_scenario(scenario_cfg_1, now + datetime.timedelta(days=25))          scenario_2 = tp.create_scenario(scenario_cfg_2)          scenario_3 = tp.create_scenario(scenario_cfg_3)          scenario_4 = tp.create_scenario(scenario_cfg_4)          scenario_5_1 = tp.create_scenario(scenario_cfg_5)          scenario_5_2 = tp.create_scenario(scenario_cfg_5)          scenario_5_3 = tp.create_scenario(scenario_cfg_5)            expected_cycles_scenarios = {              scenario_1_1.cycle: [scenario_1_1.id, scenario_1_2.id],              scenario_1_3.cycle: [scenario_1_3.id],              scenario_1_4.cycle: [scenario_1_4.id],              scenario_1_5.cycle: [scenario_1_5.id],              scenario_2.cycle: [scenario_2.id],              scenario_3.cycle: [scenario_3.id],              scenario_4.cycle: [scenario_4.id],              None: [scenario_5_1.id, scenario_5_2.id, scenario_5_3.id],          }            cycles_scenarios = tp.get_cycles_scenarios()            assert expected_cycles_scenarios.keys() == cycles_scenarios.keys()          for cycle, scenarios in cycles_scenarios.items():              expected_scenarios = expected_cycles_scenarios[cycle]              assert sorted([scenario.id for scenario in scenarios]) == sorted(expected_scenarios)        def test_get_entities_by_config_id(self):          scenario_config_1 = Config.configure_scenario(\"s1\", sequence_configs=[])          scenario_config_2 = Config.configure_scenario(\"s2\", sequence_configs=[])            s_1_1 = tp.create_scenario(scenario_config_1)          s_1_2 = tp.create_scenario(scenario_config_1)          s_1_3 = tp.create_scenario(scenario_config_1)            assert len(tp.get_scenarios()) == 3            s_2_1 = tp.create_scenario(scenario_config_2)          s_2_2 = tp.create_scenario(scenario_config_2)          assert len(tp.get_scenarios()) == 5            s1_scenarios = tp.get_entities_by_config_id(scenario_config_1.id)          assert len(s1_scenarios) == 3          assert sorted([s_1_1.id, s_1_2.id, s_1_3.id]) == sorted([scenario.id for scenario in s1_scenarios])            s2_scenarios = tp.get_entities_by_config_id(scenario_config_2.id)          assert len(s2_scenarios) == 2          assert sorted([s_2_1.id, s_2_2.id]) == sorted([scenario.id for scenario in s2_scenarios])        def test_get_entities_by_config_id_in_multiple_versions_environment(self):          scenario_config_1 = Config.configure_scenario(\"s1\", sequence_configs=[])          scenario_config_2 = Config.configure_scenario(\"s2\", sequence_configs=[])            _VersionManager._set_experiment_version(\"1.0\")          tp.create_scenario(scenario_config_1)          tp.create_scenario(scenario_config_1)          tp.create_scenario(scenario_config_1)          tp.create_scenario(scenario_config_2)          tp.create_scenario(scenario_config_2)          assert len(tp.get_scenarios()) == 5          assert len(tp.get_entities_by_config_id(scenario_config_1.id)) == 3          assert len(tp.get_entities_by_config_id(scenario_config_2.id)) == 2            _VersionManager._set_experiment_version(\"2.0\")          tp.create_scenario(scenario_config_1)          tp.create_scenario(scenario_config_1)          tp.create_scenario(scenario_config_1)          tp.create_scenario(scenario_config_2)          tp.create_scenario(scenario_config_2)          assert len(tp.get_scenarios()) == 5          assert len(tp.get_entities_by_config_id(scenario_config_1.id)) == 3          assert len(tp.get_entities_by_config_id(scenario_config_2.id)) == 2 "}
{"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._version._version_manager_factory import _VersionManagerFactory  from src.taipy.core.common._utils import _load_fct  from src.taipy.core.cycle._cycle_manager import _CycleManager  from src.taipy.core.data._data_manager import _DataManager  from src.taipy.core.exceptions.exceptions import NonExistingVersion  from src.taipy.core.job._job_manager import _JobManager  from src.taipy.core.scenario._scenario_manager import _ScenarioManager  from src.taipy.core.sequence._sequence_manager import _SequenceManager  from src.taipy.core.task._task_manager import _TaskManager  from taipy.config.common.frequency import Frequency  from taipy.config.common.scope import Scope  from taipy.config.config import Config  from tests.conftest import init_config, init_managers  from tests.core.utils import assert_true_after_time      def test_core_cli_no_arguments(init_sql_repo):      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()      def test_core_cli_development_mode(init_sql_repo):      with patch(\"sys.argv\", [\"prog\", \"--development\"]):          core = Core()          core.run()          assert Config.core.mode == \"development\"          assert Config.core.version_number == _VersionManagerFactory._build_manager()._get_development_version()          core.stop()      def test_core_cli_dev_mode(init_sql_repo):      with patch(\"sys.argv\", [\"prog\", \"-dev\"]):          core = Core()          core.run()          assert Config.core.mode == \"development\"          assert Config.core.version_number == _VersionManagerFactory._build_manager()._get_development_version()          core.stop()      def test_core_cli_experiment_mode(init_sql_repo):      with patch(\"sys.argv\", [\"prog\", \"--experiment\"]):          core = Core()          core.run()          assert Config.core.mode == \"experiment\"          assert Config.core.version_number == _VersionManagerFactory._build_manager()._get_latest_version()          assert not Config.core.force          core.stop()      def test_core_cli_experiment_mode_with_version(init_sql_repo):      with patch(\"sys.argv\", [\"prog\", \"--experiment\", \"2.1\"]):          core = Core()          core.run()          assert Config.core.mode == \"experiment\"          assert Config.core.version_number == \"2.1\"          assert not Config.core.force          core.stop()      def test_core_cli_experiment_mode_with_force_version(init_sql_repo):      with patch(\"sys.argv\", [\"prog\", \"--experiment\", \"2.1\", \"--taipy-force\"]):          core = Core()          core.run()          assert Config.core.mode == \"experiment\"          assert Config.core.version_number == \"2.1\"          assert Config.core.force          core.stop()      def test_core_cli_production_mode(init_sql_repo):      with patch(\"sys.argv\", [\"prog\", \"--production\"]):          core = Core()          core.run()          assert Config.core.mode == \"production\"          assert Config.core.version_number == _VersionManagerFactory._build_manager()._get_latest_version()          assert not Config.core.force          core.stop()      def test_dev_mode_clean_all_entities_of_the_latest_version(init_sql_repo):      scenario_config = config_scenario()      init_managers()        # Create a scenario in development mode      with patch(\"sys.argv\", [\"prog\"]):          core = Core()          core.run()          scenario = _ScenarioManager._create(scenario_config)          _ScenarioManager._submit(scenario)          core.stop()            # Initial assertion          assert len(_DataManager._get_all(version_number=\"all\")) == 2          assert len(_TaskManager._get_all(version_number=\"all\")) == 1          assert len(_SequenceManager._get_all(version_number=\"all\")) == 1          assert len(_ScenarioManager._get_all(version_number=\"all\")) == 1          assert len(_CycleManager._get_all(version_number=\"all\")) == 1          assert len(_JobManager._get_all(version_number=\"all\")) == 1        # Create a new scenario in experiment mode      with patch(\"sys.argv\", [\"prog\", \"--experiment\"]):          core = Core()          core.run()          scenario = _ScenarioManager._create(scenario_config)          _ScenarioManager._submit(scenario)          core.stop()            # Assert number of entities in 2nd version          assert len(_DataManager._get_all(version_number=\"all\")) == 4          assert len(_TaskManager._get_all(version_number=\"all\")) == 2          assert len(_SequenceManager._get_all(version_number=\"all\")) == 2          assert len(_ScenarioManager._get_all(version_number=\"all\")) == 2          assert (              len(_CycleManager._get_all(version_number=\"all\")) == 1          )  # No new cycle is created since old dev version use the same cycle          assert len(_JobManager._get_all(version_number=\"all\")) == 2        # Run development mode again      with patch(\"sys.argv\", [\"prog\", \"--development\"]):          core = Core()          core.run()            # The 1st dev version should be deleted run with development mode          assert len(_DataManager._get_all(version_number=\"all\")) == 2          assert len(_TaskManager._get_all(version_number=\"all\")) == 1          assert len(_SequenceManager._get_all(version_number=\"all\")) == 1          assert len(_ScenarioManager._get_all(version_number=\"all\")) == 1          assert len(_CycleManager._get_all(version_number=\"all\")) == 1          assert len(_JobManager._get_all(version_number=\"all\")) == 1            # Submit new dev version          scenario = _ScenarioManager._create(scenario_config)          _ScenarioManager._submit(scenario)            # Assert number of entities with 1 dev version and 1 exp version          assert len(_DataManager._get_all(version_number=\"all\")) == 4          assert len(_TaskManager._get_all(version_number=\"all\")) == 2          assert len(_SequenceManager._get_all(version_number=\"all\")) == 2          assert len(_ScenarioManager._get_all(version_number=\"all\")) == 2          assert len(_CycleManager._get_all(version_number=\"all\")) == 1          assert len(_JobManager._get_all(version_number=\"all\")) == 2            # Assert number of entities of the latest version only          assert len(_DataManager._get_all(version_number=\"latest\")) == 2          assert len(_TaskManager._get_all(version_number=\"latest\")) == 1          assert len(_SequenceManager._get_all(version_number=\"latest\")) == 1          assert len(_ScenarioManager._get_all(version_number=\"latest\")) == 1          assert len(_JobManager._get_all(version_number=\"latest\")) == 1            # Assert number of entities of the development version only          assert len(_DataManager._get_all(version_number=\"development\")) == 2          assert len(_TaskManager._get_all(version_number=\"development\")) == 1          assert len(_SequenceManager._get_all(version_number=\"development\")) == 1          assert len(_ScenarioManager._get_all(version_number=\"development\")) == 1          assert len(_JobManager._get_all(version_number=\"development\")) == 1            # Assert number of entities of an unknown version          with pytest.raises(NonExistingVersion):              assert _DataManager._get_all(version_number=\"foo\")          with pytest.raises(NonExistingVersion):              assert _TaskManager._get_all(version_number=\"foo\")          with pytest.raises(NonExistingVersion):              assert _SequenceManager._get_all(version_number=\"foo\")          with pytest.raises(NonExistingVersion):              assert _ScenarioManager._get_all(version_number=\"foo\")          with pytest.raises(NonExistingVersion):              assert _JobManager._get_all(version_number=\"foo\")          core.stop()      def twice_doppelganger(a):      return a * 2      def test_dev_mode_clean_all_entities_when_config_is_alternated(init_sql_repo):      data_node_1_config = Config.configure_data_node(          id=\"d1\", storage_type=\"pickle\", default_data=\"abc\", scope=Scope.SCENARIO      )      data_node_2_config = Config.configure_data_node(id=\"d2\", storage_type=\"csv\", default_path=\"foo.csv\")      task_config = Config.configure_task(\"my_task\", twice_doppelganger, data_node_1_config, data_node_2_config)      scenario_config = Config.configure_scenario(\"my_scenario\", [task_config], frequency=Frequency.DAILY)        # Create a scenario in development mode with the doppelganger function      with patch(\"sys.argv\", [\"prog\"]):          core = Core()          core.run()          scenario = _ScenarioManager._create(scenario_config)          _ScenarioManager._submit(scenario)          core.stop()        # Delete the twice_doppelganger function      # and clear cache of _load_fct() to simulate a new run      del globals()[\"twice_doppelganger\"]      _load_fct.cache_clear()        # Create a scenario in development mode with another function      scenario_config = config_scenario()      with patch(\"sys.argv\", [\"prog\"]):          core = Core()          core.run()          scenario = _ScenarioManager._create(scenario_config)          _ScenarioManager._submit(scenario)          core.stop()      def test_version_number_when_switching_mode(init_sql_repo):      with patch(\"sys.argv\", [\"prog\", \"--development\"]):          core = Core()          core.run()          ver_1 = _VersionManager._get_latest_version()          ver_dev = _VersionManager._get_development_version()          assert ver_1 == ver_dev          assert len(_VersionManager._get_all()) == 1          core.stop()        # Run with dev mode, the version number is the same      with patch(\"sys.argv\", [\"prog\", \"--development\"]):          core = Core()          core.run()          ver_2 = _VersionManager._get_latest_version()          assert ver_2 == ver_dev          assert len(_VersionManager._get_all()) == 1          core.stop()        # When run with experiment mode, a new version is created      with patch(\"sys.argv\", [\"prog\", \"--experiment\"]):          core = Core()          core.run()          ver_3 = _VersionManager._get_latest_version()          assert ver_3 != ver_dev          assert len(_VersionManager._get_all()) == 2          core.stop()        with patch(\"sys.argv\", [\"prog\", \"--experiment\", \"2.1\"]):          core = Core()          core.run()          ver_4 = _VersionManager._get_latest_version()          assert ver_4 == \"2.1\"          assert len(_VersionManager._get_all()) == 3          core.stop()        with patch(\"sys.argv\", [\"prog\", \"--experiment\"]):          core = Core()          core.run()          ver_5 = _VersionManager._get_latest_version()          assert ver_5 != ver_3          assert ver_5 != ver_4          assert ver_5 != ver_dev          assert len(_VersionManager._get_all()) == 4          core.stop()        # When run with production mode, the latest version is used as production      with patch(\"sys.argv\", [\"prog\", \"--production\"]):          core = Core()          core.run()          ver_6 = _VersionManager._get_latest_version()          production_versions = _VersionManager._get_production_versions()          assert ver_6 == ver_5          assert production_versions == [ver_6]          assert len(_VersionManager._get_all()) == 4          core.stop()        # When run with production mode, the \"2.1\" version is used as production      with patch(\"sys.argv\", [\"prog\", \"--production\", \"2.1\"]):          core = Core()          core.run()          ver_7 = _VersionManager._get_latest_version()          production_versions = _VersionManager._get_production_versions()          assert ver_7 == \"2.1\"          assert production_versions == [ver_7, ver_6]          assert len(_VersionManager._get_all()) == 4          core.stop()        # Run with dev mode, the version number is the same as the first dev version to overide it      with patch(\"sys.argv\", [\"prog\", \"--development\"]):          core = Core()          core.run()          ver_7 = _VersionManager._get_latest_version()          assert ver_1 == ver_7          assert len(_VersionManager._get_all()) == 4          core.stop()      def test_production_mode_load_all_entities_from_previous_production_version(init_sql_repo):      scenario_config = config_scenario()      init_managers()        with patch(\"sys.argv\", [\"prog\", \"--development\"]):          core = Core()          core.run()          scenario = _ScenarioManager._create(scenario_config)          _ScenarioManager._submit(scenario)          core.stop()        with patch(\"sys.argv\", [\"prog\", \"--production\", \"1.0\"]):          core = Core()          core.run()          production_ver_1 = _VersionManager._get_latest_version()          assert _VersionManager._get_production_versions() == [production_ver_1]          # When run production mode on a new app, a dev version is created alongside          assert _VersionManager._get_development_version() not in _VersionManager._get_production_versions()          assert len(_VersionManager._get_all()) == 2            scenario = _ScenarioManager._create(scenario_config)          _ScenarioManager._submit(scenario)            assert len(_DataManager._get_all()) == 2          assert len(_TaskManager._get_all()) == 1          assert len(_SequenceManager._get_all()) == 1          assert len(_ScenarioManager._get_all()) == 1          assert len(_CycleManager._get_all()) == 1          assert len(_JobManager._get_all()) == 1          core.stop()        with patch(\"sys.argv\", [\"prog\", \"--production\", \"2.0\"]):          core = Core()          core.run()          production_ver_2 = _VersionManager._get_latest_version()          assert _VersionManager._get_production_versions() == [production_ver_1, production_ver_2]          assert len(_VersionManager._get_all()) == 3            # All entities from previous production version should be saved          scenario = _ScenarioManager._create(scenario_config)          _ScenarioManager._submit(scenario)            assert len(_DataManager._get_all()) == 4          assert len(_TaskManager._get_all()) == 2          assert len(_SequenceManager._get_all()) == 2          assert len(_ScenarioManager._get_all()) == 2          assert len(_CycleManager._get_all()) == 1          assert len(_JobManager._get_all()) == 2          core.stop()      def test_force_override_experiment_version(init_sql_repo):      scenario_config = config_scenario()      init_managers()        with patch(\"sys.argv\", [\"prog\", \"--experiment\", \"1.0\"]):          core = Core()          core.run()          ver_1 = _VersionManager._get_latest_version()          assert ver_1 == \"1.0\"          # When create new experiment version, a development version entity is also created as a placeholder          assert len(_VersionManager._get_all()) == 2  # 2 version include 1 experiment 1 development            scenario = _ScenarioManager._create(scenario_config)          _ScenarioManager._submit(scenario)            assert len(_DataManager._get_all()) == 2          assert len(_TaskManager._get_all()) == 1          assert len(_SequenceManager._get_all()) == 1          assert len(_ScenarioManager._get_all()) == 1          assert len(_CycleManager._get_all()) == 1          assert len(_JobManager._get_all()) == 1          core.stop()        Config.configure_global_app(foo=\"bar\")        # Without --taipy-force parameter, a SystemExit will be raised      with pytest.raises(SystemExit):          with patch(\"sys.argv\", [\"prog\", \"--experiment\", \"1.0\"]):              core = Core()              core.run()      core.stop()        # With --taipy-force parameter      with patch(\"sys.argv\", [\"prog\", \"--experiment\", \"1.0\", \"--taipy-force\"]):          core = Core()          core.run()          core.stop()      ver_2 = _VersionManager._get_latest_version()      assert ver_2 == \"1.0\"      assert len(_VersionManager._get_all()) == 2  # 2 version include 1 experiment 1 development        # All entities from previous submit should be saved      scenario = _ScenarioManager._create(scenario_config)      _ScenarioManager._submit(scenario)        assert len(_DataManager._get_all()) == 4      assert len(_TaskManager._get_all()) == 2      assert len(_SequenceManager._get_all()) == 2      assert len(_ScenarioManager._get_all()) == 2      assert len(_CycleManager._get_all()) == 1      assert len(_JobManager._get_all()) == 2      def test_force_override_production_version(init_sql_repo):      scenario_config = config_scenario()      init_managers()        with patch(\"sys.argv\", [\"prog\", \"--production\", \"1.0\"]):          core = Core()          core.run()          ver_1 = _VersionManager._get_latest_version()          production_versions = _VersionManager._get_production_versions()          assert ver_1 == \"1.0\"          assert production_versions == [\"1.0\"]          # When create new production version, a development version entity is also created as a placeholder          assert len(_VersionManager._get_all()) == 2  # 2 version include 1 production 1 development            scenario = _ScenarioManager._create(scenario_config)          _ScenarioManager._submit(scenario)            assert len(_DataManager._get_all()) == 2          assert len(_TaskManager._get_all()) == 1          assert len(_SequenceManager._get_all()) == 1          assert len(_ScenarioManager._get_all()) == 1          assert len(_CycleManager._get_all()) == 1          assert len(_JobManager._get_all()) == 1          core.stop()        Config.configure_global_app(foo=\"bar\")        # Without --taipy-force parameter, a SystemExit will be raised      with pytest.raises(SystemExit):          with patch(\"sys.argv\", [\"prog\", \"--production\", \"1.0\"]):              core = Core()              core.run()      core.stop()        # With --taipy-force parameter      with patch(\"sys.argv\", [\"prog\", \"--production\", \"1.0\", \"--taipy-force\"]):          core = Core()          core.run()          ver_2 = _VersionManager._get_latest_version()          assert ver_2 == \"1.0\"          assert len(_VersionManager._get_all()) == 2  # 2 version include 1 production 1 development            # All entities from previous submit should be saved          scenario = _ScenarioManager._create(scenario_config)          _ScenarioManager._submit(scenario)            assert len(_DataManager._get_all()) == 4          assert len(_TaskManager._get_all()) == 2          assert len(_SequenceManager._get_all()) == 2          assert len(_ScenarioManager._get_all()) == 2          assert len(_CycleManager._get_all()) == 1          assert len(_JobManager._get_all()) == 2          core.stop()      def test_modify_config_properties_without_force(caplog, init_sql_repo):      scenario_config = config_scenario()      init_managers()        with patch(\"sys.argv\", [\"prog\", \"--experiment\", \"1.0\"]):          core = Core()          core.run()          scenario = _ScenarioManager._create(scenario_config)          _ScenarioManager._submit(scenario)          core.stop()        init_config()      Config.configure_core(repository_type=\"sql\", repository_properties={\"db_location\": init_sql_repo})        scenario_config_2 = config_scenario_2()        with pytest.raises(SystemExit):          with patch(\"sys.argv\", [\"prog\", \"--experiment\", \"1.0\"]):              core = Core()              core.run()              scenario = _ScenarioManager._create(scenario_config_2)              _ScenarioManager._submit(scenario)      core.stop()        error_message = str(caplog.text)        assert 'DATA_NODE \"d3\" was added' in error_message        assert 'DATA_NODE \"d0\" was removed' in error_message        assert 'DATA_NODE \"d2\" has attribute \"default_path\" modified' in error_message      assert 'CORE \"root_folder\" was modified' in error_message      assert 'JOB \"mode\" was modified' in error_message      assert 'JOB \"max_nb_of_workers\" was modified' in error_message      assert 'SCENARIO \"my_scenario\" has attribute \"frequency\" modified' in error_message      assert 'SCENARIO \"my_scenario\" has attribute \"tasks\" modified' in error_message      assert 'TASK \"my_task\" has attribute \"inputs\" modified' in error_message      assert 'TASK \"my_task\" has attribute \"function\" modified' in error_message      assert 'TASK \"my_task\" has attribute \"outputs\" modified' in error_message      assert 'DATA_NODE \"d2\" has attribute \"has_header\" modified' in error_message      assert 'DATA_NODE \"d2\" has attribute \"exposed_type\" modified' in error_message      def test_modify_job_configuration_dont_stop_application(caplog, init_sql_repo):      scenario_config = config_scenario()      init_managers()        with patch(\"sys.argv\", [\"prog\", \"--experiment\", \"1.0\"]):          Config.configure_job_executions(mode=\"development\")          core = Core()          core.run(force_restart=True)          scenario = _ScenarioManager._create(scenario_config)          jobs = _ScenarioManager._submit(scenario)          assert all([job.is_finished() for job in jobs])          core.stop()        init_config()      Config.configure_core(repository_type=\"sql\", repository_properties={\"db_location\": init_sql_repo})        scenario_config = config_scenario()        with patch(\"sys.argv\", [\"prog\", \"--experiment\", \"1.0\"]):          Config.configure_job_executions(mode=\"standalone\", max_nb_of_workers=2)          core = Core()          core.run(force_restart=True)          scenario = _ScenarioManager._create(scenario_config)            jobs = _ScenarioManager._submit(scenario)          assert_true_after_time(lambda: all(job.is_finished() for job in jobs))          error_message = str(caplog.text)          assert 'JOB \"mode\" was modified' in error_message          assert 'JOB \"max_nb_of_workers\" was modified' in error_message          core.stop()          assert_true_after_time(lambda: core._dispatcher is None)      def twice(a):      return a * 2      def config_scenario():      Config.configure_data_node(id=\"d0\")      data_node_1_config = Config.configure_data_node(          id=\"d1\", storage_type=\"pickle\", default_data=\"abc\", scope=Scope.SCENARIO      )      data_node_2_config = Config.configure_data_node(id=\"d2\", storage_type=\"csv\", default_path=\"foo.csv\")      task_config = Config.configure_task(\"my_task\", twice, data_node_1_config, data_node_2_config)      scenario_config = Config.configure_scenario(\"my_scenario\", [task_config], frequency=Frequency.DAILY)      scenario_config.add_sequences({\"my_sequence\": [task_config]})        return scenario_config      def double_twice(a):      return a * 2, a * 2      def config_scenario_2():      Config.configure_core(          root_folder=\"foo_root\",          # Changing the \"storage_folder\" will fail since older versions are stored in older folder          # storage_folder=\"foo_storage\",      )      Config.configure_job_executions(mode=\"standalone\", max_nb_of_workers=5)      data_node_1_config = Config.configure_data_node(          id=\"d1\", storage_type=\"pickle\", default_data=\"abc\", scope=Scope.SCENARIO      )      # Modify properties of \"d2\"      data_node_2_config = Config.configure_data_node(          id=\"d2\", storage_type=\"csv\", default_path=\"bar.csv\", has_header=False, exposed_type=\"numpy\"      )      # Add new data node \"d3\"      data_node_3_config = Config.configure_data_node(          id=\"d3\", storage_type=\"csv\", default_path=\"baz.csv\", has_header=False, exposed_type=\"numpy\"      )      # Modify properties of \"my_task\", including the function and outputs list      Config.configure_task(\"my_task\", double_twice, data_node_3_config, [data_node_1_config, data_node_2_config])      task_config_1 = Config.configure_task(\"my_task_1\", double_twice, data_node_3_config, [data_node_2_config])      # Modify properties of \"my_scenario\", where tasks is now my_task_1      scenario_config = Config.configure_scenario(\"my_scenario\", [task_config_1], frequency=Frequency.MONTHLY)      scenario_config.add_sequences({\"my_sequence\": [task_config_1]})        return scenario_config "}
{"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": "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._version._version_manager_factory import _VersionManagerFactory  from src.taipy.core.common._utils import _load_fct  from src.taipy.core.cycle._cycle_manager import _CycleManager  from src.taipy.core.data._data_manager import _DataManager  from src.taipy.core.exceptions.exceptions import NonExistingVersion  from src.taipy.core.job._job_manager import _JobManager  from src.taipy.core.scenario._scenario_manager import _ScenarioManager  from src.taipy.core.sequence._sequence_manager import _SequenceManager  from src.taipy.core.task._task_manager import _TaskManager  from taipy.config.common.frequency import Frequency  from taipy.config.common.scope import Scope  from taipy.config.config import Config  from tests.conftest import init_config  from tests.core.utils import assert_true_after_time      def test_core_cli_no_arguments():      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()      def test_core_cli_development_mode():      with patch(\"sys.argv\", [\"prog\", \"--development\"]):          core = Core()          core.run()          assert Config.core.mode == \"development\"          assert Config.core.version_number == _VersionManagerFactory._build_manager()._get_development_version()          core.stop()      def test_core_cli_dev_mode():      with patch(\"sys.argv\", [\"prog\", \"-dev\"]):          core = Core()          core.run()          assert Config.core.mode == \"development\"          assert Config.core.version_number == _VersionManagerFactory._build_manager()._get_development_version()          core.stop()      def test_core_cli_experiment_mode():      with patch(\"sys.argv\", [\"prog\", \"--experiment\"]):          core = Core()          core.run()          assert Config.core.mode == \"experiment\"          assert Config.core.version_number == _VersionManagerFactory._build_manager()._get_latest_version()          assert not Config.core.force          core.stop()      def test_core_cli_experiment_mode_with_version():      with patch(\"sys.argv\", [\"prog\", \"--experiment\", \"2.1\"]):          core = Core()          core.run()          assert Config.core.mode == \"experiment\"          assert Config.core.version_number == \"2.1\"          assert not Config.core.force          core.stop()      def test_core_cli_experiment_mode_with_force_version():      with patch(\"sys.argv\", [\"prog\", \"--experiment\", \"2.1\", \"--taipy-force\"]):          init_config()          core = Core()          core.run()          assert Config.core.mode == \"experiment\"          assert Config.core.version_number == \"2.1\"          assert Config.core.force          core.stop()      def test_core_cli_production_mode():      with patch(\"sys.argv\", [\"prog\", \"--production\"]):          core = Core()          core.run()          assert Config.core.mode == \"production\"          assert Config.core.version_number == _VersionManagerFactory._build_manager()._get_latest_version()          assert not Config.core.force          core.stop()      def test_dev_mode_clean_all_entities_of_the_latest_version():      scenario_config = config_scenario()        # Create a scenario in development mode      with patch(\"sys.argv\", [\"prog\"]):          core = Core()          core.run()          scenario = _ScenarioManager._create(scenario_config)          _ScenarioManager._submit(scenario)          core.stop()        # Initial assertion      assert len(_DataManager._get_all(version_number=\"all\")) == 2      assert len(_TaskManager._get_all(version_number=\"all\")) == 1      assert len(_SequenceManager._get_all(version_number=\"all\")) == 1      assert len(_ScenarioManager._get_all(version_number=\"all\")) == 1      assert len(_CycleManager._get_all(version_number=\"all\")) == 1      assert len(_JobManager._get_all(version_number=\"all\")) == 1        # Create a new scenario in experiment mode      with patch(\"sys.argv\", [\"prog\", \"--experiment\"]):          core = Core()          core.run()          scenario = _ScenarioManager._create(scenario_config)          _ScenarioManager._submit(scenario)          core.stop()        # Assert number of entities in 2nd version      assert len(_DataManager._get_all(version_number=\"all\")) == 4      assert len(_TaskManager._get_all(version_number=\"all\")) == 2      assert len(_SequenceManager._get_all(version_number=\"all\")) == 2      assert len(_ScenarioManager._get_all(version_number=\"all\")) == 2      assert (          len(_CycleManager._get_all(version_number=\"all\")) == 1      )  # No new cycle is created since old dev version use the same cycle      assert len(_JobManager._get_all(version_number=\"all\")) == 2        # Run development mode again      with patch(\"sys.argv\", [\"prog\", \"--development\"]):          core = Core()          core.run()            # The 1st dev version should be deleted run with development mode          assert len(_DataManager._get_all(version_number=\"all\")) == 2          assert len(_TaskManager._get_all(version_number=\"all\")) == 1          assert len(_SequenceManager._get_all(version_number=\"all\")) == 1          assert len(_ScenarioManager._get_all(version_number=\"all\")) == 1          assert len(_CycleManager._get_all(version_number=\"all\")) == 1          assert len(_JobManager._get_all(version_number=\"all\")) == 1            # Submit new dev version          scenario = _ScenarioManager._create(scenario_config)          _ScenarioManager._submit(scenario)          core.stop()            # Assert number of entities with 1 dev version and 1 exp version          assert len(_DataManager._get_all(version_number=\"all\")) == 4          assert len(_TaskManager._get_all(version_number=\"all\")) == 2          assert len(_SequenceManager._get_all(version_number=\"all\")) == 2          assert len(_ScenarioManager._get_all(version_number=\"all\")) == 2          assert len(_CycleManager._get_all(version_number=\"all\")) == 1          assert len(_JobManager._get_all(version_number=\"all\")) == 2            # Assert number of entities of the latest version only          assert len(_DataManager._get_all(version_number=\"latest\")) == 2          assert len(_TaskManager._get_all(version_number=\"latest\")) == 1          assert len(_SequenceManager._get_all(version_number=\"latest\")) == 1          assert len(_ScenarioManager._get_all(version_number=\"latest\")) == 1          assert len(_JobManager._get_all(version_number=\"latest\")) == 1            # Assert number of entities of the development version only          assert len(_DataManager._get_all(version_number=\"development\")) == 2          assert len(_TaskManager._get_all(version_number=\"development\")) == 1          assert len(_SequenceManager._get_all(version_number=\"development\")) == 1          assert len(_ScenarioManager._get_all(version_number=\"development\")) == 1          assert len(_JobManager._get_all(version_number=\"development\")) == 1            # Assert number of entities of an unknown version          with pytest.raises(NonExistingVersion):              assert _DataManager._get_all(version_number=\"foo\")          with pytest.raises(NonExistingVersion):              assert _TaskManager._get_all(version_number=\"foo\")          with pytest.raises(NonExistingVersion):              assert _SequenceManager._get_all(version_number=\"foo\")          with pytest.raises(NonExistingVersion):              assert _ScenarioManager._get_all(version_number=\"foo\")          with pytest.raises(NonExistingVersion):              assert _JobManager._get_all(version_number=\"foo\")      def twice_doppelganger(a):      return a * 2      def test_dev_mode_clean_all_entities_when_config_is_alternated():      data_node_1_config = Config.configure_data_node(          id=\"d1\", storage_type=\"pickle\", default_data=\"abc\", scope=Scope.SCENARIO      )      data_node_2_config = Config.configure_data_node(id=\"d2\", storage_type=\"csv\", default_path=\"foo.csv\")      task_config = Config.configure_task(\"my_task\", twice_doppelganger, data_node_1_config, data_node_2_config)      scenario_config = Config.configure_scenario(\"my_scenario\", [task_config], frequency=Frequency.DAILY)        # Create a scenario in development mode with the doppelganger function      with patch(\"sys.argv\", [\"prog\"]):          core = Core()          core.run()          scenario = _ScenarioManager._create(scenario_config)          _ScenarioManager._submit(scenario)          core.stop()        # Delete the twice_doppelganger function      # and clear cache of _load_fct() to simulate a new run      del globals()[\"twice_doppelganger\"]      _load_fct.cache_clear()        # Create a scenario in development mode with another function      scenario_config = config_scenario()      with patch(\"sys.argv\", [\"prog\"]):          core = Core()          core.run()          scenario = _ScenarioManager._create(scenario_config)          _ScenarioManager._submit(scenario)          core.stop()      def test_version_number_when_switching_mode():      with patch(\"sys.argv\", [\"prog\", \"--development\"]):          core = Core()          core.run()          ver_1 = _VersionManager._get_latest_version()          ver_dev = _VersionManager._get_development_version()          assert ver_1 == ver_dev          assert len(_VersionManager._get_all()) == 1          core.stop()        # Run with dev mode, the version number is the same      with patch(\"sys.argv\", [\"prog\", \"--development\"]):          core = Core()          core.run()          ver_2 = _VersionManager._get_latest_version()          assert ver_2 == ver_dev          assert len(_VersionManager._get_all()) == 1          core.stop()        # When run with experiment mode, a new version is created      with patch(\"sys.argv\", [\"prog\", \"--experiment\"]):          core = Core()          core.run()          ver_3 = _VersionManager._get_latest_version()          assert ver_3 != ver_dev          assert len(_VersionManager._get_all()) == 2          core.stop()        with patch(\"sys.argv\", [\"prog\", \"--experiment\", \"2.1\"]):          core = Core()          core.run()          ver_4 = _VersionManager._get_latest_version()          assert ver_4 == \"2.1\"          assert len(_VersionManager._get_all()) == 3          core.stop()        with patch(\"sys.argv\", [\"prog\", \"--experiment\"]):          core = Core()          core.run()          ver_5 = _VersionManager._get_latest_version()          assert ver_5 != ver_3          assert ver_5 != ver_4          assert ver_5 != ver_dev          assert len(_VersionManager._get_all()) == 4          core.stop()        # When run with production mode, the latest version is used as production      with patch(\"sys.argv\", [\"prog\", \"--production\"]):          core = Core()          core.run()          ver_6 = _VersionManager._get_latest_version()          production_versions = _VersionManager._get_production_versions()          assert ver_6 == ver_5          assert production_versions == [ver_6]          assert len(_VersionManager._get_all()) == 4          core.stop()        # When run with production mode, the \"2.1\" version is used as production      with patch(\"sys.argv\", [\"prog\", \"--production\", \"2.1\"]):          core = Core()          core.run()          ver_7 = _VersionManager._get_latest_version()          production_versions = _VersionManager._get_production_versions()          assert ver_7 == \"2.1\"          assert production_versions == [ver_6, ver_7]          assert len(_VersionManager._get_all()) == 4          core.stop()        # Run with dev mode, the version number is the same as the first dev version to overide it      with patch(\"sys.argv\", [\"prog\", \"--development\"]):          core = Core()          core.run()          ver_7 = _VersionManager._get_latest_version()          assert ver_1 == ver_7          assert len(_VersionManager._get_all()) == 4          core.stop()      def test_production_mode_load_all_entities_from_previous_production_version():      scenario_config = config_scenario()        with patch(\"sys.argv\", [\"prog\", \"--development\"]):          core = Core()          core.run()          scenario = _ScenarioManager._create(scenario_config)          _ScenarioManager._submit(scenario)          core.stop()        with patch(\"sys.argv\", [\"prog\", \"--production\", \"1.0\"]):          core = Core()          core.run()          production_ver_1 = _VersionManager._get_latest_version()          assert _VersionManager._get_production_versions() == [production_ver_1]          # When run production mode on a new app, a dev version is created alongside          assert _VersionManager._get_development_version() not in _VersionManager._get_production_versions()          assert len(_VersionManager._get_all()) == 2            scenario = _ScenarioManager._create(scenario_config)          _ScenarioManager._submit(scenario)            assert len(_DataManager._get_all()) == 2          assert len(_TaskManager._get_all()) == 1          assert len(_SequenceManager._get_all()) == 1          assert len(_ScenarioManager._get_all()) == 1          assert len(_CycleManager._get_all()) == 1          assert len(_JobManager._get_all()) == 1          core.stop()        with patch(\"sys.argv\", [\"prog\", \"--production\", \"2.0\"]):          core = Core()          core.run()          production_ver_2 = _VersionManager._get_latest_version()          assert _VersionManager._get_production_versions() == [production_ver_1, production_ver_2]          assert len(_VersionManager._get_all()) == 3            # All entities from previous production version should be saved          scenario = _ScenarioManager._create(scenario_config)          _ScenarioManager._submit(scenario)            assert len(_DataManager._get_all()) == 4          assert len(_TaskManager._get_all()) == 2          assert len(_SequenceManager._get_all()) == 2          assert len(_ScenarioManager._get_all()) == 2          assert len(_CycleManager._get_all()) == 1          assert len(_JobManager._get_all()) == 2          core.stop()      def test_force_override_experiment_version():      scenario_config = config_scenario()        with patch(\"sys.argv\", [\"prog\", \"--experiment\", \"1.0\"]):          core = Core()          core.run()          ver_1 = _VersionManager._get_latest_version()          assert ver_1 == \"1.0\"          # When create new experiment version, a development version entity is also created as a placeholder          assert len(_VersionManager._get_all()) == 2  # 2 version include 1 experiment 1 development            scenario = _ScenarioManager._create(scenario_config)          _ScenarioManager._submit(scenario)            assert len(_DataManager._get_all()) == 2          assert len(_TaskManager._get_all()) == 1          assert len(_SequenceManager._get_all()) == 1          assert len(_ScenarioManager._get_all()) == 1          assert len(_CycleManager._get_all()) == 1          assert len(_JobManager._get_all()) == 1          core.stop()        Config.configure_global_app(foo=\"bar\")        # Without --taipy-force parameter, a SystemExit will be raised      with pytest.raises(SystemExit):          with patch(\"sys.argv\", [\"prog\", \"--experiment\", \"1.0\"]):              core = Core()              core.run()      core.stop()        # With --taipy-force parameter      with patch(\"sys.argv\", [\"prog\", \"--experiment\", \"1.0\", \"--taipy-force\"]):          core = Core()          core.run()          ver_2 = _VersionManager._get_latest_version()          assert ver_2 == \"1.0\"          assert len(_VersionManager._get_all()) == 2  # 2 version include 1 experiment 1 development            # All entities from previous submit should be saved          scenario = _ScenarioManager._create(scenario_config)          _ScenarioManager._submit(scenario)            assert len(_DataManager._get_all()) == 4          assert len(_TaskManager._get_all()) == 2          assert len(_SequenceManager._get_all()) == 2          assert len(_ScenarioManager._get_all()) == 2          assert len(_CycleManager._get_all()) == 1          assert len(_JobManager._get_all()) == 2          core.stop()      def test_force_override_production_version():      scenario_config = config_scenario()        with patch(\"sys.argv\", [\"prog\", \"--production\", \"1.0\"]):          core = Core()          core.run()          ver_1 = _VersionManager._get_latest_version()          production_versions = _VersionManager._get_production_versions()          assert ver_1 == \"1.0\"          assert production_versions == [\"1.0\"]          # When create new production version, a development version entity is also created as a placeholder          assert len(_VersionManager._get_all()) == 2  # 2 version include 1 production 1 development            scenario = _ScenarioManager._create(scenario_config)          _ScenarioManager._submit(scenario)            assert len(_DataManager._get_all()) == 2          assert len(_TaskManager._get_all()) == 1          assert len(_SequenceManager._get_all()) == 1          assert len(_ScenarioManager._get_all()) == 1          assert len(_CycleManager._get_all()) == 1          assert len(_JobManager._get_all()) == 1          core.stop()        Config.configure_global_app(foo=\"bar\")        # Without --taipy-force parameter, a SystemExit will be raised      with pytest.raises(SystemExit):          with patch(\"sys.argv\", [\"prog\", \"--production\", \"1.0\"]):              core = Core()              core.run()      core.stop()        # With --taipy-force parameter      with patch(\"sys.argv\", [\"prog\", \"--production\", \"1.0\", \"--taipy-force\"]):          core = Core()          core.run()          ver_2 = _VersionManager._get_latest_version()          assert ver_2 == \"1.0\"          assert len(_VersionManager._get_all()) == 2  # 2 version include 1 production 1 development            # All entities from previous submit should be saved          scenario = _ScenarioManager._create(scenario_config)          _ScenarioManager._submit(scenario)            assert len(_DataManager._get_all()) == 4          assert len(_TaskManager._get_all()) == 2          assert len(_SequenceManager._get_all()) == 2          assert len(_ScenarioManager._get_all()) == 2          assert len(_CycleManager._get_all()) == 1          assert len(_JobManager._get_all()) == 2          core.stop()      def test_modify_job_configuration_dont_stop_application(caplog):      scenario_config = config_scenario()        with patch(\"sys.argv\", [\"prog\", \"--experiment\", \"1.0\"]):          core = Core()          Config.configure_job_executions(mode=\"development\")          core.run(force_restart=True)          scenario = _ScenarioManager._create(scenario_config)          jobs = _ScenarioManager._submit(scenario)          assert all([job.is_finished() for job in jobs])          core.stop()        init_config()      scenario_config = config_scenario()        with patch(\"sys.argv\", [\"prog\", \"--experiment\", \"1.0\"]):          core = Core()          Config.configure_job_executions(mode=\"standalone\", max_nb_of_workers=5)          core.run(force_restart=True)          scenario = _ScenarioManager._create(scenario_config)            jobs = _ScenarioManager._submit(scenario)          assert_true_after_time(lambda: all(job.is_finished() for job in jobs))          error_message = str(caplog.text)          assert 'JOB \"mode\" was modified' in error_message          assert 'JOB \"max_nb_of_workers\" was modified' in error_message          core.stop()      def test_modify_config_properties_without_force(caplog):      scenario_config = config_scenario()        with patch(\"sys.argv\", [\"prog\", \"--experiment\", \"1.0\"]):          core = Core()          core.run()          scenario = _ScenarioManager._create(scenario_config)          _ScenarioManager._submit(scenario)          core.stop()        init_config()        scenario_config_2 = config_scenario_2()        with pytest.raises(SystemExit):          with patch(\"sys.argv\", [\"prog\", \"--experiment\", \"1.0\"]):              core = Core()              core.run()              scenario = _ScenarioManager._create(scenario_config_2)              _ScenarioManager._submit(scenario)      core.stop()      error_message = str(caplog.text)        assert 'DATA_NODE \"d3\" was added' in error_message        assert 'DATA_NODE \"d0\" was removed' in error_message        assert 'DATA_NODE \"d2\" has attribute \"default_path\" modified' in error_message      assert 'CORE \"root_folder\" was modified' in error_message      assert 'CORE \"repository_type\" was modified' in error_message      assert 'JOB \"mode\" was modified' in error_message      assert 'JOB \"max_nb_of_workers\" was modified' in error_message      assert 'SCENARIO \"my_scenario\" has attribute \"frequency\" modified' in error_message      assert 'SCENARIO \"my_scenario\" has attribute \"tasks\" modified' in error_message      assert 'TASK \"my_task\" has attribute \"inputs\" modified' in error_message      assert 'TASK \"my_task\" has attribute \"function\" modified' in error_message      assert 'TASK \"my_task\" has attribute \"outputs\" modified' in error_message      assert 'DATA_NODE \"d2\" has attribute \"has_header\" modified' in error_message      assert 'DATA_NODE \"d2\" has attribute \"exposed_type\" modified' in error_message        assert 'CORE \"repository_properties\" was added' in error_message      def twice(a):      return a * 2      def config_scenario():      Config.configure_data_node(id=\"d0\")      data_node_1_config = Config.configure_data_node(          id=\"d1\", storage_type=\"pickle\", default_data=\"abc\", scope=Scope.SCENARIO      )      data_node_2_config = Config.configure_data_node(id=\"d2\", storage_type=\"csv\", default_path=\"foo.csv\")      task_config = Config.configure_task(\"my_task\", twice, data_node_1_config, data_node_2_config)      scenario_config = Config.configure_scenario(\"my_scenario\", [task_config], frequency=Frequency.DAILY)      scenario_config.add_sequences({\"my_sequence\": [task_config]})        return scenario_config      def double_twice(a):      return a * 2, a * 2      def config_scenario_2():      Config.configure_core(          root_folder=\"foo_root\",          # Changing the \"storage_folder\" will fail since older versions are stored in older folder          # storage_folder=\"foo_storage\",          repository_type=\"bar\",          repository_properties={\"foo\": \"bar\"},      )      Config.configure_job_executions(mode=\"standalone\", max_nb_of_workers=5)      data_node_1_config = Config.configure_data_node(          id=\"d1\", storage_type=\"pickle\", default_data=\"abc\", scope=Scope.SCENARIO      )      # Modify properties of \"d2\"      data_node_2_config = Config.configure_data_node(          id=\"d2\", storage_type=\"csv\", default_path=\"bar.csv\", has_header=False, exposed_type=\"numpy\"      )      # Add new data node \"d3\"      data_node_3_config = Config.configure_data_node(          id=\"d3\", storage_type=\"csv\", default_path=\"baz.csv\", has_header=False, exposed_type=\"numpy\"      )      # Modify properties of \"my_task\", including the function and outputs list      Config.configure_task(\"my_task\", double_twice, data_node_3_config, [data_node_1_config, data_node_2_config])      task_config_1 = Config.configure_task(\"my_task_1\", double_twice, data_node_3_config, [data_node_2_config])      # Modify properties of \"my_scenario\", where tasks is now my_task_1      scenario_config = Config.configure_scenario(\"my_scenario\", [task_config_1], frequency=Frequency.MONTHLY)      scenario_config.add_sequences({\"my_sequence\": [task_config_1]})        return scenario_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": "import os    import pytest    from src.taipy.core import Core  from src.taipy.core.data._data_manager import _DataManager  from src.taipy.core.data.csv import CSVDataNode  from src.taipy.core.data.excel import ExcelDataNode  from src.taipy.core.data.json import JSONDataNode  from src.taipy.core.data.parquet import ParquetDataNode  from src.taipy.core.data.pickle import PickleDataNode  from taipy.config.config import Config      def read_backup_file(path):      with open(path, \"r\") as f:          lines = f.readlines()      return lines      @pytest.fixture(scope=\"function\", autouse=True)  def init_backup_file():      os.environ[\"TAIPY_BACKUP_FILE_PATH\"] = \".taipy_backups\"      if os.path.exists(os.environ[\"TAIPY_BACKUP_FILE_PATH\"]):          os.remove(os.environ[\"TAIPY_BACKUP_FILE_PATH\"])        yield        if os.path.exists(\".taipy_backups\"):          os.remove(\".taipy_backups\")      del os.environ[\"TAIPY_BACKUP_FILE_PATH\"]      backup_file_path = \".taipy_backups\"      def test_backup_storage_folder_when_core_run():      core = Core()      core.run()      backup_files = read_backup_file(backup_file_path)      assert backup_files == [f\"{Config.core.storage_folder}\\n\"]      core.stop()      def test_no_new_entry_when_file_is_in_storage_folder():      dn_cfg_1 = Config.configure_data_node(\"dn_cfg_1\", path=\"dn_1.pickle\")      dn_cfg_2 = Config.configure_data_node(\"dn_cfg_2\")  # stored in .data folder        dn_1 = _DataManager._create_and_set(dn_cfg_1, None, None)      dn_2 = _DataManager._create_and_set(dn_cfg_2, None, None)        dn_1.write(\"DN1_CONTENT\")      dn_2.write(\"DN2_CONTENT\")        backup_files = read_backup_file(backup_file_path)      assert backup_files == [f\"{dn_1.path}\\n\"]      os.remove(dn_1.path)      def test_backup_csv_files():      dn_cfg_1 = Config.configure_data_node(\"dn_cfg_1\", \"csv\", path=\"example_1.csv\")      dn_cfg_2 = Config.configure_data_node(\"dn_cfg_2\", \"csv\", path=\"example_2.csv\")        csv_dn_1 = _DataManager._create_and_set(dn_cfg_1, None, None)      assert isinstance(csv_dn_1, CSVDataNode)        backup_files = read_backup_file(backup_file_path)      assert backup_files == [f\"{csv_dn_1.path}\\n\"]        csv_dn_2 = _DataManager._create_and_set(dn_cfg_2, None, None)      assert isinstance(csv_dn_2, CSVDataNode)        backup_files = read_backup_file(backup_file_path)      assert backup_files == [f\"{csv_dn_1.path}\\n\", f\"{csv_dn_2.path}\\n\"]        csv_dn_1.path = \"example_3.csv\"      backup_files = read_backup_file(backup_file_path)      assert backup_files == [f\"{csv_dn_2.path}\\n\", f\"{csv_dn_1.path}\\n\"]        csv_dn_2.path = \"example_4.csv\"      backup_files = read_backup_file(backup_file_path)      assert backup_files == [f\"{csv_dn_1.path}\\n\", f\"{csv_dn_2.path}\\n\"]        _DataManager._delete(csv_dn_1.id)        backup_files = read_backup_file(backup_file_path)      assert backup_files == [f\"{csv_dn_2.path}\\n\"]        csv_dn_3 = _DataManager._create_and_set(dn_cfg_1, None, None)      csv_dn_4 = _DataManager._create_and_set(dn_cfg_1, None, None)      assert isinstance(csv_dn_3, CSVDataNode)      assert isinstance(csv_dn_4, CSVDataNode)        backup_files = read_backup_file(backup_file_path)      assert backup_files == [f\"{csv_dn_2.path}\\n\", f\"{csv_dn_3.path}\\n\", f\"{csv_dn_4.path}\\n\"]        csv_dn_4.path = \"example_5.csv\"      backup_files = read_backup_file(backup_file_path)      assert backup_files == [f\"{csv_dn_2.path}\\n\", f\"{csv_dn_3.path}\\n\", f\"{csv_dn_4.path}\\n\"]        _DataManager._delete_all()        backup_files = read_backup_file(backup_file_path)      assert backup_files == []      def test_backup_excel_files():      dn_cfg_1 = Config.configure_data_node(\"dn_cfg_1\", \"excel\", path=\"example_1.xlsx\")      dn_cfg_2 = Config.configure_data_node(\"dn_cfg_2\", \"excel\", path=\"example_2.xlsx\")        excel_dn_1 = _DataManager._create_and_set(dn_cfg_1, None, None)      assert isinstance(excel_dn_1, ExcelDataNode)        backup_files = read_backup_file(backup_file_path)      assert backup_files == [f\"{excel_dn_1.path}\\n\"]        excel_dn_2 = _DataManager._create_and_set(dn_cfg_2, None, None)      assert isinstance(excel_dn_2, ExcelDataNode)        backup_files = read_backup_file(backup_file_path)      assert backup_files == [f\"{excel_dn_1.path}\\n\", f\"{excel_dn_2.path}\\n\"]        excel_dn_1.path = \"example_3.excel\"      backup_files = read_backup_file(backup_file_path)      assert backup_files == [f\"{excel_dn_2.path}\\n\", f\"{excel_dn_1.path}\\n\"]        excel_dn_2.path = \"example_4.excel\"      backup_files = read_backup_file(backup_file_path)      assert backup_files == [f\"{excel_dn_1.path}\\n\", f\"{excel_dn_2.path}\\n\"]        _DataManager._delete(excel_dn_1.id)        backup_files = read_backup_file(backup_file_path)      assert backup_files == [f\"{excel_dn_2.path}\\n\"]        excel_dn_3 = _DataManager._create_and_set(dn_cfg_1, None, None)      excel_dn_4 = _DataManager._create_and_set(dn_cfg_1, None, None)      assert isinstance(excel_dn_3, ExcelDataNode)      assert isinstance(excel_dn_4, ExcelDataNode)        backup_files = read_backup_file(backup_file_path)      assert backup_files == [f\"{excel_dn_2.path}\\n\", f\"{excel_dn_3.path}\\n\", f\"{excel_dn_4.path}\\n\"]        excel_dn_4.path = \"example_5.excel\"      backup_files = read_backup_file(backup_file_path)      assert backup_files == [f\"{excel_dn_2.path}\\n\", f\"{excel_dn_3.path}\\n\", f\"{excel_dn_4.path}\\n\"]        _DataManager._delete_all()        backup_files = read_backup_file(backup_file_path)      assert backup_files == []      def test_backup_pickle_files():      dn_cfg_1 = Config.configure_data_node(\"dn_cfg_1\", \"pickle\", path=\"example_1.p\")      dn_cfg_2 = Config.configure_data_node(\"dn_cfg_2\", \"pickle\", path=\"example_2.p\")        pickle_dn_1 = _DataManager._create_and_set(dn_cfg_1, None, None)      assert isinstance(pickle_dn_1, PickleDataNode)        backup_files = read_backup_file(backup_file_path)      assert backup_files == [f\"{pickle_dn_1.path}\\n\"]        pickle_dn_2 = _DataManager._create_and_set(dn_cfg_2, None, None)      assert isinstance(pickle_dn_2, PickleDataNode)        backup_files = read_backup_file(backup_file_path)      assert backup_files == [f\"{pickle_dn_1.path}\\n\", f\"{pickle_dn_2.path}\\n\"]        pickle_dn_1.path = \"example_3.pickle\"      backup_files = read_backup_file(backup_file_path)      assert backup_files == [f\"{pickle_dn_2.path}\\n\", f\"{pickle_dn_1.path}\\n\"]        pickle_dn_2.path = \"example_4.pickle\"      backup_files = read_backup_file(backup_file_path)      assert backup_files == [f\"{pickle_dn_1.path}\\n\", f\"{pickle_dn_2.path}\\n\"]        _DataManager._delete(pickle_dn_1.id)        backup_files = read_backup_file(backup_file_path)      assert backup_files == [f\"{pickle_dn_2.path}\\n\"]        pickle_dn_3 = _DataManager._create_and_set(dn_cfg_1, None, None)      pickle_dn_4 = _DataManager._create_and_set(dn_cfg_1, None, None)      assert isinstance(pickle_dn_3, PickleDataNode)      assert isinstance(pickle_dn_4, PickleDataNode)        backup_files = read_backup_file(backup_file_path)      assert backup_files == [f\"{pickle_dn_2.path}\\n\", f\"{pickle_dn_3.path}\\n\", f\"{pickle_dn_4.path}\\n\"]        pickle_dn_4.path = \"example_5.pickle\"      backup_files = read_backup_file(backup_file_path)      assert backup_files == [f\"{pickle_dn_2.path}\\n\", f\"{pickle_dn_3.path}\\n\", f\"{pickle_dn_4.path}\\n\"]        _DataManager._delete_all()        backup_files = read_backup_file(backup_file_path)      assert backup_files == []      def test_backup_json_files():      dn_cfg_1 = Config.configure_data_node(\"dn_cfg_1\", \"json\", path=\"example_1.json\")      dn_cfg_2 = Config.configure_data_node(\"dn_cfg_2\", \"json\", path=\"example_2.json\")        json_dn_1 = _DataManager._create_and_set(dn_cfg_1, None, None)      assert isinstance(json_dn_1, JSONDataNode)        backup_files = read_backup_file(backup_file_path)      assert backup_files == [f\"{json_dn_1.path}\\n\"]        json_dn_2 = _DataManager._create_and_set(dn_cfg_2, None, None)      assert isinstance(json_dn_2, JSONDataNode)        backup_files = read_backup_file(backup_file_path)      assert backup_files == [f\"{json_dn_1.path}\\n\", f\"{json_dn_2.path}\\n\"]        json_dn_1.path = \"example_3.json\"      backup_files = read_backup_file(backup_file_path)      assert backup_files == [f\"{json_dn_2.path}\\n\", f\"{json_dn_1.path}\\n\"]        json_dn_2.path = \"example_4.json\"      backup_files = read_backup_file(backup_file_path)      assert backup_files == [f\"{json_dn_1.path}\\n\", f\"{json_dn_2.path}\\n\"]        _DataManager._delete(json_dn_1.id)        backup_files = read_backup_file(backup_file_path)      assert backup_files == [f\"{json_dn_2.path}\\n\"]        json_dn_3 = _DataManager._create_and_set(dn_cfg_1, None, None)      json_dn_4 = _DataManager._create_and_set(dn_cfg_1, None, None)      assert isinstance(json_dn_3, JSONDataNode)      assert isinstance(json_dn_4, JSONDataNode)        backup_files = read_backup_file(backup_file_path)      assert backup_files == [f\"{json_dn_2.path}\\n\", f\"{json_dn_3.path}\\n\", f\"{json_dn_4.path}\\n\"]        json_dn_4.path = \"example_5.json\"      backup_files = read_backup_file(backup_file_path)      assert backup_files == [f\"{json_dn_2.path}\\n\", f\"{json_dn_3.path}\\n\", f\"{json_dn_4.path}\\n\"]        _DataManager._delete_all()        backup_files = read_backup_file(backup_file_path)      assert backup_files == []      def test_backup_parquet_files():      dn_cfg_1 = Config.configure_data_node(\"dn_cfg_1\", \"parquet\", path=\"example_1.parquet\")      dn_cfg_2 = Config.configure_data_node(\"dn_cfg_2\", \"parquet\", path=\"example_2.parquet\")        parquet_dn_1 = _DataManager._create_and_set(dn_cfg_1, None, None)      assert isinstance(parquet_dn_1, ParquetDataNode)        backup_files = read_backup_file(backup_file_path)      assert backup_files == [f\"{parquet_dn_1.path}\\n\"]        parquet_dn_2 = _DataManager._create_and_set(dn_cfg_2, None, None)      assert isinstance(parquet_dn_2, ParquetDataNode)        backup_files = read_backup_file(backup_file_path)      assert backup_files == [f\"{parquet_dn_1.path}\\n\", f\"{parquet_dn_2.path}\\n\"]        parquet_dn_1.path = \"example_3.parquet\"      backup_files = read_backup_file(backup_file_path)      assert backup_files == [f\"{parquet_dn_2.path}\\n\", f\"{parquet_dn_1.path}\\n\"]        parquet_dn_2.path = \"example_4.parquet\"      backup_files = read_backup_file(backup_file_path)      assert backup_files == [f\"{parquet_dn_1.path}\\n\", f\"{parquet_dn_2.path}\\n\"]        _DataManager._delete(parquet_dn_1.id)        backup_files = read_backup_file(backup_file_path)      assert backup_files == [f\"{parquet_dn_2.path}\\n\"]        parquet_dn_3 = _DataManager._create_and_set(dn_cfg_1, None, None)      parquet_dn_4 = _DataManager._create_and_set(dn_cfg_1, None, None)      assert isinstance(parquet_dn_3, ParquetDataNode)      assert isinstance(parquet_dn_4, ParquetDataNode)        backup_files = read_backup_file(backup_file_path)      assert backup_files == [f\"{parquet_dn_2.path}\\n\", f\"{parquet_dn_3.path}\\n\", f\"{parquet_dn_4.path}\\n\"]        parquet_dn_4.path = \"example_5.parquet\"      backup_files = read_backup_file(backup_file_path)      assert backup_files == [f\"{parquet_dn_2.path}\\n\", f\"{parquet_dn_3.path}\\n\", f\"{parquet_dn_4.path}\\n\"]        _DataManager._delete_all()        backup_files = read_backup_file(backup_file_path)      assert backup_files == []      def test_no_backup_if_no_env_var():      dn_cfg_1 = Config.configure_data_node(\"dn_cfg_1\", \"csv\", path=\"example_1.csv\")      _DataManager._create_and_set(dn_cfg_1, None, None) "}
{"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 json  from datetime import timedelta    from src.taipy.core.common.mongo_default_document import MongoDefaultDocument  from taipy.config.common.scope import Scope  from taipy.config.config import Config      def test_set_default_data_node_configuration():      data_node1 = Config.configure_data_node(id=\"input_data1\")      assert data_node1.storage_type == \"pickle\"      assert data_node1.scope == Scope.SCENARIO      assert data_node1.validity_period is None        Config.set_default_data_node_configuration(\"in_memory\", scope=Scope.GLOBAL)      data_node2 = Config.configure_data_node(id=\"input_data2\")      assert data_node2.storage_type == \"in_memory\"      assert data_node2.scope == Scope.GLOBAL      assert data_node2.validity_period is None        Config.set_default_data_node_configuration(\"csv\")      data_node3 = Config.configure_data_node(id=\"input_data3\")      assert data_node3.storage_type == \"csv\"      assert data_node3.scope == Scope.SCENARIO      assert data_node3.validity_period is None        Config.set_default_data_node_configuration(\"json\", validity_period=timedelta(1))      data_node4 = Config.configure_data_node(id=\"input_data4\")      assert data_node4.storage_type == \"json\"      assert data_node4.scope == Scope.SCENARIO      assert data_node4.validity_period == timedelta(1)      def test_set_default_data_node_configuration_replace_old_default_config():      Config.set_default_data_node_configuration(          \"in_memory\",          prop1=\"1\",          prop2=\"2\",          prop3=\"3\",      )      dn1 = Config.configure_data_node(id=\"dn1\")      assert len(dn1.properties) == 3        Config.set_default_data_node_configuration(          \"csv\",          prop4=\"4\",          prop5=\"5\",          prop6=\"6\",      )      dn2 = Config.configure_data_node(id=\"dn2\")      assert dn2.storage_type == \"csv\"      assert len(dn2.properties) == 6  # encoding, exposed_type, and has_header too      assert dn2.prop4 == \"4\"      assert dn2.prop5 == \"5\"      assert dn2.prop6 == \"6\"      assert dn2.prop1 is None      assert dn2.prop2 is None      assert dn2.prop3 is None      def test_config_storage_type_different_from_default_data_node():      Config.set_default_data_node_configuration(          storage_type=\"pickle\",          custom_property={\"foo\": \"bar\"},          scope=Scope.GLOBAL,      )        # Config a datanode with specific \"storage_type\" different than \"pickle\"      # should ignore the default datanode      csv_dn = Config.configure_data_node(id=\"csv_dn\", storage_type=\"csv\")      assert len(csv_dn.properties) == 3  # encoding, exposed_type, and has_header      assert csv_dn.properties.get(\"custom_property\") is None      assert csv_dn.scope == Scope.SCENARIO      def test_set_default_csv_data_node_configuration():      Config.set_default_data_node_configuration(          storage_type=\"csv\",          default_path=\"default.csv\",          has_header=False,          exposed_type=\"numpy\",          scope=Scope.GLOBAL,          validity_period=timedelta(2),      )        # Config with generic config_data_node without storage_type      # should return the default DataNode      dn1 = Config.configure_data_node(id=\"dn1\")      assert dn1.storage_type == \"csv\"      assert dn1.scope == Scope.GLOBAL      assert dn1.default_path == \"default.csv\"      assert dn1.has_header is False      assert dn1.exposed_type == \"numpy\"      assert dn1.validity_period == timedelta(2)        # Config with generic config_data_node without storage_type      # with custom properties      dn2 = Config.configure_data_node(id=\"dn2\", default_path=\"dn2.csv\")      assert dn2.storage_type == \"csv\"      assert dn2.default_path == \"dn2.csv\"      assert dn2.has_header is False      assert dn2.exposed_type == \"numpy\"      assert dn2.scope == Scope.GLOBAL      assert dn2.validity_period == timedelta(2)        # Config a datanode with specific \"storage_type\" = \"csv\"      # should use properties from the default datanode      dn3 = Config.configure_data_node(          id=\"dn3\",          storage_type=\"csv\",          default_path=\"dn3.csv\",          scope=Scope.SCENARIO,          validity_period=timedelta(1),      )      assert dn3.storage_type == \"csv\"      assert dn3.default_path == \"dn3.csv\"      assert dn3.has_header is False      assert dn3.exposed_type == \"numpy\"      assert dn3.scope == Scope.SCENARIO      assert dn3.validity_period == timedelta(1)      def test_set_default_json_data_node_configuration():      class MyCustomEncoder(json.JSONEncoder):          ...        class MyCustomDecoder(json.JSONDecoder):          ...        Config.set_default_data_node_configuration(          storage_type=\"json\",          default_path=\"default.json\",          encoder=MyCustomEncoder,          scope=Scope.GLOBAL,          validity_period=timedelta(2),      )        # Config with generic config_data_node without storage_type      # should return the default DataNode      dn1 = Config.configure_data_node(id=\"dn1\")      assert dn1.storage_type == \"json\"      assert dn1.default_path == \"default.json\"      assert dn1.encoder == MyCustomEncoder      assert dn1.decoder is None      assert dn1.scope == Scope.GLOBAL      assert dn1.validity_period == timedelta(2)        # Config with generic config_data_node without storage_type      # with custom properties      dn2 = Config.configure_data_node(id=\"dn2\", default_path=\"dn2.json\")      assert dn2.storage_type == \"json\"      assert dn2.default_path == \"dn2.json\"      assert dn2.encoder == MyCustomEncoder      assert dn2.decoder is None      assert dn2.scope == Scope.GLOBAL      assert dn2.validity_period == timedelta(2)        # Config a datanode with specific \"storage_type\" = \"json\"      # should use properties from the default datanode      dn3 = Config.configure_data_node(          id=\"dn3\",          storage_type=\"json\",          default_path=\"dn3.json\",          decoder=MyCustomDecoder,          validity_period=timedelta(1),      )      assert dn3.storage_type == \"json\"      assert dn3.default_path == \"dn3.json\"      assert dn3.encoder == MyCustomEncoder      assert dn3.decoder == MyCustomDecoder      assert dn3.scope == Scope.GLOBAL      assert dn3.validity_period == timedelta(1)      def test_set_default_parquet_data_node_configuration():      Config.set_default_data_node_configuration(          storage_type=\"parquet\",          default_path=\"default.parquet\",          compression=\"gzip\",          exposed_type=\"numpy\",          scope=Scope.GLOBAL,          validity_period=timedelta(2),      )        # Config with generic config_data_node without storage_type      # should return the default DataNode      dn1 = Config.configure_data_node(id=\"dn1\")      assert dn1.storage_type == \"parquet\"      assert dn1.default_path == \"default.parquet\"      assert dn1.engine == \"pyarrow\"      assert dn1.compression == \"gzip\"      assert dn1.read_kwargs is None      assert dn1.write_kwargs is None      assert dn1.exposed_type == \"numpy\"      assert dn1.scope == Scope.GLOBAL      assert dn1.validity_period == timedelta(2)        # Config with generic config_data_node without storage_type      # with custom properties      dn2 = Config.configure_data_node(          id=\"dn2\",          default_path=\"dn2.parquet\",          engine=\"fastparquet\",      )      assert dn2.storage_type == \"parquet\"      assert dn2.default_path == \"dn2.parquet\"      assert dn2.engine == \"fastparquet\"      assert dn2.compression == \"gzip\"      assert dn2.read_kwargs is None      assert dn2.write_kwargs is None      assert dn2.exposed_type == \"numpy\"      assert dn2.scope == Scope.GLOBAL      assert dn2.validity_period == timedelta(2)        # Config a datanode with specific \"storage_type\" = \"parquet\"      # should use properties from the default datanode      dn3 = Config.configure_data_node(          id=\"dn3\",          storage_type=\"parquet\",          default_path=\"dn3.parquet\",          read_kwargs={\"filter\": \"foo\"},          scope=Scope.SCENARIO,          validity_period=timedelta(1),      )      assert dn3.storage_type == \"parquet\"      assert dn3.default_path == \"dn3.parquet\"      assert dn3.engine == \"pyarrow\"      assert dn3.compression == \"gzip\"      assert dn3.read_kwargs == {\"filter\": \"foo\"}      assert dn3.write_kwargs is None      assert dn3.exposed_type == \"numpy\"      assert dn3.scope == Scope.SCENARIO      assert dn3.validity_period == timedelta(1)      def test_set_default_excel_data_node_configuration():      Config.set_default_data_node_configuration(          storage_type=\"excel\",          default_path=\"default.xlsx\",          has_header=False,          exposed_type=\"numpy\",          scope=Scope.GLOBAL,          validity_period=timedelta(2),      )        # Config with generic config_data_node without storage_type      # should return the default DataNode      dn1 = Config.configure_data_node(id=\"dn1\")      assert dn1.storage_type == \"excel\"      assert dn1.scope == Scope.GLOBAL      assert dn1.default_path == \"default.xlsx\"      assert dn1.has_header is False      assert dn1.sheet_name is None      assert dn1.exposed_type == \"numpy\"      assert dn1.validity_period == timedelta(2)        # Config with generic config_data_node without storage_type      # with custom properties      dn2 = Config.configure_data_node(id=\"dn2\", default_path=\"dn2.xlsx\", sheet_name=\"sheet_1\")      assert dn2.storage_type == \"excel\"      assert dn2.default_path == \"dn2.xlsx\"      assert dn2.has_header is False      assert dn2.sheet_name == \"sheet_1\"      assert dn2.exposed_type == \"numpy\"      assert dn2.scope == Scope.GLOBAL      assert dn2.validity_period == timedelta(2)        # Config a datanode with specific \"storage_type\" = \"excel\"      # should use properties from the default datanode      dn3 = Config.configure_data_node(          id=\"dn3\",          storage_type=\"excel\",          default_path=\"dn3.xlsx\",          scope=Scope.SCENARIO,          validity_period=timedelta(1),      )      assert dn3.storage_type == \"excel\"      assert dn3.default_path == \"dn3.xlsx\"      assert dn3.has_header is False      assert dn3.sheet_name is None      assert dn3.exposed_type == \"numpy\"      assert dn3.scope == Scope.SCENARIO      assert dn3.validity_period == timedelta(1)      def test_set_default_pickle_data_node_configuration():      Config.set_default_data_node_configuration(          storage_type=\"pickle\",          default_data=1,          exposed_type=\"numpy\",          scope=Scope.GLOBAL,          validity_period=timedelta(2),      )        # Config with generic config_data_node without storage_type      # should return the default DataNode      dn1 = Config.configure_data_node(id=\"dn1\")      assert dn1.storage_type == \"pickle\"      assert dn1.scope == Scope.GLOBAL      assert dn1.default_path is None      assert dn1.default_data == 1      assert dn1.exposed_type == \"numpy\"      assert dn1.validity_period == timedelta(2)        # Config with generic config_data_node without storage_type      # with custom properties      dn2 = Config.configure_data_node(id=\"dn2\", default_path=\"dn2.pkl\", default_data=2)      assert dn2.storage_type == \"pickle\"      assert dn2.default_path == \"dn2.pkl\"      assert dn2.default_data == 2      assert dn2.exposed_type == \"numpy\"      assert dn2.scope == Scope.GLOBAL      assert dn2.validity_period == timedelta(2)        # Config a datanode with specific \"storage_type\" = \"pickle\"      # should use properties from the default datanode      dn3 = Config.configure_data_node(          id=\"dn3\",          storage_type=\"pickle\",          default_path=\"dn3.pkl\",          scope=Scope.SCENARIO,          validity_period=timedelta(1),      )      assert dn3.storage_type == \"pickle\"      assert dn3.default_path == \"dn3.pkl\"      assert dn3.default_data == 1      assert dn3.exposed_type == \"numpy\"      assert dn3.scope == Scope.SCENARIO      assert dn3.validity_period == timedelta(1)      def test_set_default_sql_table_data_node_configuration():      Config.set_default_data_node_configuration(          storage_type=\"sql_table\",          db_username=\"default_user\",          db_password=\"default_pwd\",          db_name=\"default_db_name\",          db_engine=\"mssql\",          table_name=\"default_table\",          db_port=1010,          db_host=\"default_host\",          db_driver=\"default server\",          db_extra_args={\"default\": \"default\"},          scope=Scope.GLOBAL,          validity_period=timedelta(2),      )        # Config with generic config_data_node without storage_type      # should return the default DataNode      dn1 = Config.configure_data_node(id=\"dn1\")      assert dn1.storage_type == \"sql_table\"      assert dn1.db_username == \"default_user\"      assert dn1.db_password == \"default_pwd\"      assert dn1.db_name == \"default_db_name\"      assert dn1.db_engine == \"mssql\"      assert dn1.table_name == \"default_table\"      assert dn1.db_port == 1010      assert dn1.db_host == \"default_host\"      assert dn1.db_driver == \"default server\"      assert dn1.db_extra_args == {\"default\": \"default\"}      assert dn1.scope == Scope.GLOBAL      assert dn1.validity_period == timedelta(2)        # Config with generic config_data_node without storage_type      # with custom properties      dn2 = Config.configure_data_node(          id=\"dn2\",          table_name=\"table_2\",          db_port=2020,          db_host=\"host_2\",      )      assert dn2.storage_type == \"sql_table\"      assert dn2.db_username == \"default_user\"      assert dn2.db_password == \"default_pwd\"      assert dn2.db_name == \"default_db_name\"      assert dn2.db_engine == \"mssql\"      assert dn2.table_name == \"table_2\"      assert dn2.db_port == 2020      assert dn2.db_host == \"host_2\"      assert dn2.db_driver == \"default server\"      assert dn2.db_extra_args == {\"default\": \"default\"}      assert dn2.scope == Scope.GLOBAL      assert dn2.validity_period == timedelta(2)        # Config a datanode with specific \"storage_type\" = \"sql_table\"      # should use properties from the default datanode      dn3 = Config.configure_data_node(          id=\"dn3\",          storage_type=\"sql_table\",          db_username=\"user_3\",          db_password=\"pwd_3\",          db_name=\"db_3\",          db_engine=\"postgresql\",          table_name=\"table_3\",          validity_period=timedelta(1),      )      assert dn3.storage_type == \"sql_table\"      assert dn3.db_username == \"user_3\"      assert dn3.db_password == \"pwd_3\"      assert dn3.db_name == \"db_3\"      assert dn3.db_engine == \"postgresql\"      assert dn3.table_name == \"table_3\"      assert dn3.db_port == 1010      assert dn3.db_host == \"default_host\"      assert dn3.db_driver == \"default server\"      assert dn3.db_extra_args == {\"default\": \"default\"}      assert dn3.scope == Scope.GLOBAL      assert dn3.validity_period == timedelta(1)      def test_set_default_sql_data_node_configuration():      def query_builder():          ...        Config.set_default_data_node_configuration(          storage_type=\"sql\",          db_username=\"default_user\",          db_password=\"default_pwd\",          db_name=\"default_db_name\",          db_engine=\"mssql\",          read_query=\"SELECT * FROM default_table\",          write_query_builder=query_builder,          append_query_builder=query_builder,          db_port=1010,          db_host=\"default_host\",          db_driver=\"default server\",          db_extra_args={\"default\": \"default\"},          scope=Scope.GLOBAL,          validity_period=timedelta(2),      )        # Config with generic config_data_node without storage_type      # should return the default DataNode      dn1 = Config.configure_data_node(id=\"dn1\")      assert dn1.storage_type == \"sql\"      assert dn1.db_username == \"default_user\"      assert dn1.db_password == \"default_pwd\"      assert dn1.db_name == \"default_db_name\"      assert dn1.db_engine == \"mssql\"      assert dn1.read_query == \"SELECT * FROM default_table\"      assert dn1.write_query_builder == query_builder      assert dn1.append_query_builder == query_builder      assert dn1.db_port == 1010      assert dn1.db_host == \"default_host\"      assert dn1.db_driver == \"default server\"      assert dn1.db_extra_args == {\"default\": \"default\"}      assert dn1.scope == Scope.GLOBAL      assert dn1.validity_period == timedelta(2)        # Config with generic config_data_node without storage_type      # with custom properties      dn2 = Config.configure_data_node(          id=\"dn2\", table_name=\"table_2\", db_port=2020, db_host=\"host_2\", read_query=\"SELECT * FROM table_2\"      )      assert dn2.storage_type == \"sql\"      assert dn2.db_username == \"default_user\"      assert dn2.db_password == \"default_pwd\"      assert dn2.db_name == \"default_db_name\"      assert dn2.db_engine == \"mssql\"      assert dn2.read_query == \"SELECT * FROM table_2\"      assert dn2.write_query_builder == query_builder      assert dn2.append_query_builder == query_builder      assert dn2.db_port == 2020      assert dn2.db_host == \"host_2\"      assert dn2.db_driver == \"default server\"      assert dn2.db_extra_args == {\"default\": \"default\"}      assert dn2.scope == Scope.GLOBAL      assert dn2.validity_period == timedelta(2)        # Config a datanode with specific \"storage_type\" = \"sql\"      # should use properties from the default datanode      dn3 = Config.configure_data_node(          id=\"dn3\",          storage_type=\"sql\",          db_username=\"user_3\",          db_password=\"pwd_3\",          db_name=\"db_3\",          db_engine=\"postgresql\",          read_query=\"SELECT * FROM table_3\",          write_query_builder=query_builder,          validity_period=timedelta(1),      )      assert dn3.storage_type == \"sql\"      assert dn3.db_username == \"user_3\"      assert dn3.db_password == \"pwd_3\"      assert dn3.db_name == \"db_3\"      assert dn3.db_engine == \"postgresql\"      assert dn3.read_query == \"SELECT * FROM table_3\"      assert dn3.write_query_builder == query_builder      assert dn3.append_query_builder == query_builder      assert dn3.db_port == 1010      assert dn3.db_host == \"default_host\"      assert dn3.db_driver == \"default server\"      assert dn3.db_extra_args == {\"default\": \"default\"}      assert dn3.scope == Scope.GLOBAL      assert dn3.validity_period == timedelta(1)      def test_set_default_mongo_collection_data_node_configuration():      Config.set_default_data_node_configuration(          storage_type=\"mongo_collection\",          db_name=\"default_db_name\",          collection_name=\"default_collection\",          db_port=1010,          db_host=\"default_host\",          db_driver=\"default server\",          db_extra_args={\"default\": \"default\"},          scope=Scope.GLOBAL,          validity_period=timedelta(2),      )        # Config with generic config_data_node without storage_type      # should return the default DataNode      dn1 = Config.configure_data_node(id=\"dn1\")      assert dn1.storage_type == \"mongo_collection\"      assert dn1.db_username == \"\"      assert dn1.db_password == \"\"      assert dn1.db_name == \"default_db_name\"      assert dn1.collection_name == \"default_collection\"      assert dn1.custom_document == MongoDefaultDocument      assert dn1.db_host == \"default_host\"      assert dn1.db_port == 1010      assert dn1.db_driver == \"default server\"      assert dn1.db_extra_args == {\"default\": \"default\"}      assert dn1.scope == Scope.GLOBAL      assert dn1.validity_period == timedelta(2)        # Config with generic config_data_node without storage_type      # with custom properties      dn2 = Config.configure_data_node(          id=\"dn2\",          collection_name=\"collection_2\",          db_port=2020,          db_host=\"host_2\",      )      assert dn2.storage_type == \"mongo_collection\"      assert dn2.db_username == \"\"      assert dn2.db_password == \"\"      assert dn2.db_name == \"default_db_name\"      assert dn2.collection_name == \"collection_2\"      assert dn2.custom_document == MongoDefaultDocument      assert dn2.db_host == \"host_2\"      assert dn2.db_port == 2020      assert dn2.db_driver == \"default server\"      assert dn2.db_extra_args == {\"default\": \"default\"}      assert dn2.scope == Scope.GLOBAL      assert dn2.validity_period == timedelta(2)        # Config a datanode with specific \"storage_type\" = \"mongo_collection\"      # should use properties from the default datanode      dn3 = Config.configure_data_node(          id=\"dn3\",          storage_type=\"mongo_collection\",          db_name=\"db_3\",          collection_name=\"collection_3\",          db_username=\"user_3\",          db_password=\"pwd_3\",          validity_period=timedelta(1),      )      assert dn3.storage_type == \"mongo_collection\"      assert dn3.db_username == \"user_3\"      assert dn3.db_password == \"pwd_3\"      assert dn3.db_name == \"db_3\"      assert dn3.collection_name == \"collection_3\"      assert dn3.custom_document == MongoDefaultDocument      assert dn3.db_port == 1010      assert dn3.db_host == \"default_host\"      assert dn3.db_driver == \"default server\"      assert dn3.db_extra_args == {\"default\": \"default\"}      assert dn3.scope == Scope.GLOBAL      assert dn3.validity_period == timedelta(1) "}
{"text": "import os  from unittest import mock    from src.taipy.core.config import DataNodeConfig  from taipy.config.common.scope import Scope  from taipy.config.config import Config  from tests.core.utils.named_temporary_file import NamedTemporaryFile      def _configure_task_in_toml():      return NamedTemporaryFile(          content=\"\"\"  [TAIPY]    [DATA_NODE.input]    [DATA_NODE.output]    [TASK.tasks1]  function = \"builtins.print:function\"  inputs = [ \"input:SECTION\",]  outputs = [ \"output:SECTION\",]      \"\"\"      )      def _check_data_nodes_instance(dn_id, task_id):      \"\"\"Check if the data node instance in the task config correctly points to the Config._applied_config,      not the Config._python_config or the Config._file_config      \"\"\"      dn_config_applied_instance = Config.data_nodes[dn_id]      for dn in Config.tasks[task_id].inputs:          if dn.id == dn_id:              dn_config_instance_via_task = dn      for dn in Config.tasks[task_id].outputs:          if dn.id == dn_id:              dn_config_instance_via_task = dn        dn_config_python_instance = None      if Config._python_config._sections.get(\"DATA_NODE\", None):          dn_config_python_instance = Config._python_config._sections[\"DATA_NODE\"][dn_id]        dn_config_file_instance = None      if Config._file_config._sections.get(\"DATA_NODE\", None):          dn_config_file_instance = Config._file_config._sections[\"DATA_NODE\"][dn_id]        if dn_config_python_instance:          assert dn_config_python_instance.scope is None      assert dn_config_python_instance is not dn_config_applied_instance      assert dn_config_python_instance is not dn_config_instance_via_task        if dn_config_file_instance:          assert dn_config_file_instance.scope is None      assert dn_config_file_instance is not dn_config_applied_instance      assert dn_config_file_instance is not dn_config_instance_via_task        assert dn_config_applied_instance.scope == DataNodeConfig._DEFAULT_SCOPE      assert dn_config_instance_via_task is dn_config_applied_instance      def test_data_node_instance_when_configure_task_in_python():      input_config = Config.configure_data_node(\"input\")      output_config = Config.configure_data_node(\"output\")      Config.configure_task(\"tasks1\", print, input_config, output_config)        _check_data_nodes_instance(\"input\", \"tasks1\")      _check_data_nodes_instance(\"output\", \"tasks1\")      def test_data_node_instance_when_configure_task_by_loading_toml():      toml_config = _configure_task_in_toml()      Config.load(toml_config.filename)        _check_data_nodes_instance(\"input\", \"tasks1\")      _check_data_nodes_instance(\"output\", \"tasks1\")      def test_data_node_instance_when_configure_task_by_overriding_toml():      toml_config = _configure_task_in_toml()      Config.override(toml_config.filename)        _check_data_nodes_instance(\"input\", \"tasks1\")      _check_data_nodes_instance(\"output\", \"tasks1\")      def test_task_config_creation():      input_config = Config.configure_data_node(\"input\")      output_config = Config.configure_data_node(\"output\")      task_config = Config.configure_task(\"tasks1\", print, input_config, output_config)        assert not task_config.skippable      assert list(Config.tasks) == [\"default\", task_config.id]        task2 = Config.configure_task(\"tasks2\", print, input_config, output_config, skippable=True)      assert task2.skippable      assert list(Config.tasks) == [\"default\", task_config.id, task2.id]      def test_task_count():      input_config = Config.configure_data_node(\"input\")      output_config = Config.configure_data_node(\"output\")      Config.configure_task(\"tasks1\", print, input_config, output_config)      assert len(Config.tasks) == 2        Config.configure_task(\"tasks2\", print, input_config, output_config)      assert len(Config.tasks) == 3        Config.configure_task(\"tasks3\", print, input_config, output_config)      assert len(Config.tasks) == 4      def test_task_getitem():      input_config = Config.configure_data_node(\"input\")      output_config = Config.configure_data_node(\"output\")      task_id = \"tasks1\"      task_cfg = Config.configure_task(task_id, print, input_config, output_config)        assert Config.tasks[task_id].id == task_cfg.id      assert Config.tasks[task_id].properties == task_cfg.properties      assert Config.tasks[task_id].function == task_cfg.function      assert Config.tasks[task_id].input_configs == task_cfg.input_configs      assert Config.tasks[task_id].output_configs == task_cfg.output_configs      assert Config.tasks[task_id].skippable == task_cfg.skippable      def test_task_creation_no_duplication():      input_config = Config.configure_data_node(\"input\")      output_config = Config.configure_data_node(\"output\")      Config.configure_task(\"tasks1\", print, input_config, output_config)        assert len(Config.tasks) == 2        Config.configure_task(\"tasks1\", print, input_config, output_config)      assert len(Config.tasks) == 2      def test_task_config_with_env_variable_value():      input_config = Config.configure_data_node(\"input\")      output_config = Config.configure_data_node(\"output\")        with mock.patch.dict(os.environ, {\"FOO\": \"plop\", \"BAR\": \"baz\"}):          Config.configure_task(\"task_name\", print, input_config, output_config, prop=\"ENV[BAR]\")          assert Config.tasks[\"task_name\"].prop == \"baz\"          assert Config.tasks[\"task_name\"].properties[\"prop\"] == \"baz\"          assert Config.tasks[\"task_name\"]._properties[\"prop\"] == \"ENV[BAR]\"      def test_clean_config():      dn1 = Config.configure_data_node(\"dn1\")      dn2 = Config.configure_data_node(\"dn2\")      task1_config = Config.configure_task(\"id1\", print, dn1, dn2)      task2_config = Config.configure_task(\"id2\", print, dn2, dn1)        assert Config.tasks[\"id1\"] is task1_config      assert Config.tasks[\"id2\"] is task2_config        task1_config._clean()      task2_config._clean()        # Check if the instance before and after _clean() is the same      assert Config.tasks[\"id1\"] is task1_config      assert Config.tasks[\"id2\"] is task2_config        assert task1_config.id == \"id1\"      assert task2_config.id == \"id2\"      assert task1_config.function is task1_config.function is None      assert task1_config.inputs == task1_config.inputs == []      assert task1_config.input_configs == task1_config.input_configs == []      assert task1_config.outputs == task1_config.outputs == []      assert task1_config.output_configs == task1_config.output_configs == []      assert task1_config.skippable is task1_config.skippable is False      assert task1_config.properties == task1_config.properties == {}      def test_deprecated_cacheable_attribute_remains_compatible():      dn_1_id = \"dn_1_id\"      dn_1_config = Config.configure_data_node(          id=dn_1_id,          storage_type=\"pickle\",          cacheable=False,          scope=Scope.SCENARIO,      )      assert Config.data_nodes[dn_1_id].id == dn_1_id      assert Config.data_nodes[dn_1_id].storage_type == \"pickle\"      assert Config.data_nodes[dn_1_id].scope == Scope.SCENARIO      assert Config.data_nodes[dn_1_id].properties == {\"cacheable\": False}      assert not Config.data_nodes[dn_1_id].cacheable      dn_1_config.cacheable = True      assert Config.data_nodes[dn_1_id].properties == {\"cacheable\": True}      assert Config.data_nodes[dn_1_id].cacheable        dn_2_id = \"dn_2_id\"      dn_2_config = Config.configure_data_node(          id=dn_2_id,          storage_type=\"pickle\",          cacheable=True,          scope=Scope.SCENARIO,      )      assert Config.data_nodes[dn_2_id].id == dn_2_id      assert Config.data_nodes[dn_2_id].storage_type == \"pickle\"      assert Config.data_nodes[dn_2_id].scope == Scope.SCENARIO      assert Config.data_nodes[dn_2_id].properties == {\"cacheable\": True}      assert Config.data_nodes[dn_2_id].cacheable      dn_2_config.cacheable = False      assert Config.data_nodes[dn_1_id].properties == {\"cacheable\": False}      assert not Config.data_nodes[dn_1_id].cacheable        dn_3_id = \"dn_3_id\"      dn_3_config = Config.configure_data_node(          id=dn_3_id,          storage_type=\"pickle\",          scope=Scope.SCENARIO,      )      assert Config.data_nodes[dn_3_id].id == dn_3_id      assert Config.data_nodes[dn_3_id].storage_type == \"pickle\"      assert Config.data_nodes[dn_3_id].scope == Scope.SCENARIO      assert Config.data_nodes[dn_3_id].properties == {}      assert not Config.data_nodes[dn_3_id].cacheable      dn_3_config.cacheable = True      assert Config.data_nodes[dn_3_id].properties == {\"cacheable\": True}      assert Config.data_nodes[dn_3_id].cacheable "}
{"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": "import datetime  import json    from src.taipy.core.config import CoreSection, DataNodeConfig, JobConfig, MigrationConfig, ScenarioConfig, TaskConfig  from taipy.config import Config  from taipy.config._serializer._json_serializer import _JsonSerializer  from taipy.config.common.frequency import Frequency  from taipy.config.common.scope import Scope  from tests.core.utils.named_temporary_file import NamedTemporaryFile      def multiply(a):      return a * 2      def migrate_csv_path(dn):      dn.path = \"foo.csv\"      def compare_function(*data_node_results):      comparison_result = {}      current_result_index = 0      for current_result in data_node_results:          comparison_result[current_result_index] = {}          next_result_index = 0          for next_result in data_node_results:              print(f\"comparing result {current_result_index} with result {next_result_index}\")              comparison_result[current_result_index][next_result_index] = next_result - current_result              next_result_index += 1          current_result_index += 1      return comparison_result      class CustomClass:      a = None      b = None      class CustomEncoder(json.JSONEncoder):      def default(self, o):          if isinstance(o, datetime):              result = {\"__type__\": \"Datetime\", \"__value__\": o.isoformat()}          else:              result = json.JSONEncoder.default(self, o)          return result      class CustomDecoder(json.JSONDecoder):      def __init__(self, *args, **kwargs):          json.JSONDecoder.__init__(self, object_hook=self.object_hook, *args, **kwargs)        def object_hook(self, source):          if source.get(\"__type__\") == \"Datetime\":              return datetime.fromisoformat(source.get(\"__value__\"))          else:              return source      def config_test_scenario():      test_csv_dn_cfg = Config.configure_csv_data_node(          id=\"test_csv_dn\",          path=\"./test.csv\",          exposed_type=CustomClass,          scope=Scope.GLOBAL,          validity_period=datetime.timedelta(1),      )        test_json_dn_cfg = Config.configure_json_data_node(          id=\"test_json_dn\",          default_path=\"./test.json\",          encoder=CustomEncoder,          decoder=CustomDecoder,      )        test_pickle_dn_cfg = Config.configure_pickle_data_node(          id=\"test_pickle_dn\",          path=\"./test.p\",          scope=Scope.SCENARIO,          validity_period=datetime.timedelta(1),      )        test_task_cfg = Config.configure_task(          id=\"test_task\", input=test_csv_dn_cfg, function=multiply, output=test_json_dn_cfg      )        test_scenario_cfg = Config.configure_scenario(          id=\"test_scenario\",          task_configs=[test_task_cfg],          additional_data_node_configs=[test_pickle_dn_cfg],          comparators={test_json_dn_cfg.id: compare_function},          frequency=Frequency.DAILY,      )      test_scenario_cfg.add_sequences({\"sequence1\": [test_task_cfg]})        Config.add_migration_function(\"1.0\", test_csv_dn_cfg, migrate_csv_path)        return test_scenario_cfg      def test_read_write_toml_configuration_file():      expected_toml_config = f\"\"\"  [TAIPY]    [JOB]  mode = \"development\"  max_nb_of_workers = \"1: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 = \"{CoreSection._CURRENT_CORE_VERSION}\"    [DATA_NODE.default]  storage_type = \"pickle\"  scope = \"SCENARIO:SCOPE\"    [DATA_NODE.test_csv_dn]  storage_type = \"csv\"  scope = \"GLOBAL:SCOPE\"  validity_period = \"1d0h0m0s:timedelta\"  path = \"./test.csv\"  exposed_type = \"tests.core.config.test_config_serialization.CustomClass:class\"  encoding = \"utf-8\"  has_header = \"True:bool\"    [DATA_NODE.test_json_dn]  storage_type = \"json\"  scope = \"SCENARIO:SCOPE\"  default_path = \"./test.json\"  encoder = \"tests.core.config.test_config_serialization.CustomEncoder:class\"  decoder = \"tests.core.config.test_config_serialization.CustomDecoder:class\"  encoding = \"utf-8\"    [DATA_NODE.test_pickle_dn]  storage_type = \"pickle\"  scope = \"SCENARIO:SCOPE\"  validity_period = \"1d0h0m0s:timedelta\"  path = \"./test.p\"    [TASK.default]  inputs = []  outputs = []  skippable = \"False:bool\"    [TASK.test_task]  function = \"tests.core.config.test_config_serialization.multiply:function\"  inputs = [ \"test_csv_dn:SECTION\",]  outputs = [ \"test_json_dn:SECTION\",]  skippable = \"False:bool\"    [SCENARIO.default]  tasks = []  additional_data_nodes = []    [SCENARIO.test_scenario]  tasks = [ \"test_task:SECTION\",]  additional_data_nodes = [ \"test_pickle_dn:SECTION\",]  frequency = \"DAILY:FREQUENCY\"    [VERSION_MIGRATION.migration_fcts.\"1.0\"]  test_csv_dn = \"tests.core.config.test_config_serialization.migrate_csv_path:function\"    [SCENARIO.default.comparators]    [SCENARIO.default.sequences]    [SCENARIO.test_scenario.comparators]  test_json_dn = [ \"tests.core.config.test_config_serialization.compare_function:function\",]    [SCENARIO.test_scenario.sequences]  sequence1 = [ \"test_task:SECTION\",]  \"\"\".strip()        config_test_scenario()        tf = NamedTemporaryFile()      Config.backup(tf.filename)      actual_config = tf.read().strip()      assert actual_config == expected_toml_config        Config.load(tf.filename)      tf2 = NamedTemporaryFile()      Config.backup(tf2.filename)        actual_config_2 = tf2.read().strip()      assert actual_config_2 == expected_toml_config        assert Config.unique_sections is not None      assert len(Config.unique_sections) == 3        assert Config.unique_sections[JobConfig.name].mode == \"development\"      assert Config.unique_sections[JobConfig.name].max_nb_of_workers == 1        assert Config.unique_sections[MigrationConfig.name].migration_fcts[\"1.0\"] == {\"test_csv_dn\": migrate_csv_path}        assert Config.sections is not None      assert len(Config.sections) == 3        assert Config.sections[DataNodeConfig.name] is not None      assert len(Config.sections[DataNodeConfig.name]) == 4      assert Config.sections[DataNodeConfig.name][\"default\"] is not None      assert Config.sections[DataNodeConfig.name][\"default\"].storage_type == \"pickle\"      assert Config.sections[DataNodeConfig.name][\"default\"].scope == Scope.SCENARIO      assert Config.sections[DataNodeConfig.name][\"test_csv_dn\"].storage_type == \"csv\"      assert Config.sections[DataNodeConfig.name][\"test_csv_dn\"].scope == Scope.GLOBAL      assert Config.sections[DataNodeConfig.name][\"test_csv_dn\"].validity_period == datetime.timedelta(1)      assert Config.sections[DataNodeConfig.name][\"test_csv_dn\"].has_header is True      assert Config.sections[DataNodeConfig.name][\"test_csv_dn\"].path == \"./test.csv\"      assert Config.sections[DataNodeConfig.name][\"test_csv_dn\"].encoding == \"utf-8\"      assert Config.sections[DataNodeConfig.name][\"test_csv_dn\"].exposed_type == CustomClass      assert Config.sections[DataNodeConfig.name][\"test_json_dn\"].storage_type == \"json\"      assert Config.sections[DataNodeConfig.name][\"test_json_dn\"].scope == Scope.SCENARIO      assert Config.sections[DataNodeConfig.name][\"test_json_dn\"].default_path == \"./test.json\"      assert Config.sections[DataNodeConfig.name][\"test_json_dn\"].encoding == \"utf-8\"      assert Config.sections[DataNodeConfig.name][\"test_json_dn\"].encoder == CustomEncoder      assert Config.sections[DataNodeConfig.name][\"test_json_dn\"].decoder == CustomDecoder      assert Config.sections[DataNodeConfig.name][\"test_pickle_dn\"].storage_type == \"pickle\"      assert Config.sections[DataNodeConfig.name][\"test_pickle_dn\"].scope == Scope.SCENARIO      assert Config.sections[DataNodeConfig.name][\"test_pickle_dn\"].validity_period == datetime.timedelta(1)      assert Config.sections[DataNodeConfig.name][\"test_pickle_dn\"].path == \"./test.p\"        assert Config.sections[TaskConfig.name] is not None      assert len(Config.sections[TaskConfig.name]) == 2      assert Config.sections[TaskConfig.name][\"default\"] is not None      assert Config.sections[TaskConfig.name][\"default\"].inputs == []      assert Config.sections[TaskConfig.name][\"default\"].outputs == []      assert Config.sections[TaskConfig.name][\"default\"].function is None      assert not Config.sections[TaskConfig.name][\"default\"].skippable      assert [inp.id for inp in Config.sections[TaskConfig.name][\"test_task\"].inputs] == [          Config.sections[DataNodeConfig.name][\"test_csv_dn\"].id      ]      assert [outp.id for outp in Config.sections[TaskConfig.name][\"test_task\"].outputs] == [          Config.sections[DataNodeConfig.name][\"test_json_dn\"].id      ]      assert Config.sections[TaskConfig.name][\"test_task\"].function == multiply      assert Config.sections[TaskConfig.name][\"test_task\"].function == multiply        assert Config.sections[ScenarioConfig.name] is not None      assert len(Config.sections[ScenarioConfig.name]) == 2      assert Config.sections[ScenarioConfig.name][\"default\"] is not None      assert Config.sections[ScenarioConfig.name][\"default\"].tasks == []      assert Config.sections[ScenarioConfig.name][\"default\"].additional_data_nodes == []      assert Config.sections[ScenarioConfig.name][\"default\"].data_nodes == []      assert len(Config.sections[ScenarioConfig.name][\"default\"].comparators) == 0      assert [task.id for task in Config.sections[ScenarioConfig.name][\"test_scenario\"].tasks] == [          Config.sections[TaskConfig.name][\"test_task\"].id      ]      assert [          additional_data_node.id          for additional_data_node in Config.sections[ScenarioConfig.name][\"test_scenario\"].additional_data_nodes      ] == [Config.sections[DataNodeConfig.name][\"test_pickle_dn\"].id]      assert sorted([data_node.id for data_node in Config.sections[ScenarioConfig.name][\"test_scenario\"].data_nodes]) == [          Config.sections[DataNodeConfig.name][\"test_csv_dn\"].id,          Config.sections[DataNodeConfig.name][\"test_json_dn\"].id,          Config.sections[DataNodeConfig.name][\"test_pickle_dn\"].id,      ]      sequences = {}      for sequence_name, sequence_tasks in Config.sections[ScenarioConfig.name][\"test_scenario\"].sequences.items():          sequences[sequence_name] = [task.id for task in sequence_tasks]      assert sequences == {\"sequence1\": [Config.sections[TaskConfig.name][\"test_task\"].id]}        assert dict(Config.sections[ScenarioConfig.name][\"test_scenario\"].comparators) == {          \"test_json_dn\": [compare_function]      }      def test_read_write_json_configuration_file():      expected_json_config = (          \"\"\"{  \"TAIPY\": {},  \"JOB\": {  \"mode\": \"development\",  \"max_nb_of_workers\": \"1:int\"  },  \"CORE\": {  \"root_folder\": \"./taipy/\",  \"storage_folder\": \".data/\",  \"repository_type\": \"filesystem\",  \"read_entity_retry\": \"0:int\",  \"mode\": \"development\",  \"version_number\": \"\",  \"force\": \"False:bool\",\"\"\"          + f\"\"\"  \"core_version\": \"{CoreSection._CURRENT_CORE_VERSION}\"  \"\"\"          + \"\"\"  },  \"VERSION_MIGRATION\": {  \"migration_fcts\": {  \"1.0\": {  \"test_csv_dn\": \"tests.core.config.test_config_serialization.migrate_csv_path:function\"  }  }  },  \"DATA_NODE\": {  \"default\": {  \"storage_type\": \"pickle\",  \"scope\": \"SCENARIO:SCOPE\"  },  \"test_csv_dn\": {  \"storage_type\": \"csv\",  \"scope\": \"GLOBAL:SCOPE\",  \"validity_period\": \"1d0h0m0s:timedelta\",  \"path\": \"./test.csv\",  \"exposed_type\": \"tests.core.config.test_config_serialization.CustomClass:class\",  \"encoding\": \"utf-8\",  \"has_header\": \"True:bool\"  },  \"test_json_dn\": {  \"storage_type\": \"json\",  \"scope\": \"SCENARIO:SCOPE\",  \"default_path\": \"./test.json\",  \"encoder\": \"tests.core.config.test_config_serialization.CustomEncoder:class\",  \"decoder\": \"tests.core.config.test_config_serialization.CustomDecoder:class\",  \"encoding\": \"utf-8\"  },  \"test_pickle_dn\": {  \"storage_type\": \"pickle\",  \"scope\": \"SCENARIO:SCOPE\",  \"validity_period\": \"1d0h0m0s:timedelta\",  \"path\": \"./test.p\"  }  },  \"TASK\": {  \"default\": {  \"function\": null,  \"inputs\": [],  \"outputs\": [],  \"skippable\": \"False:bool\"  },  \"test_task\": {  \"function\": \"tests.core.config.test_config_serialization.multiply:function\",  \"inputs\": [  \"test_csv_dn:SECTION\"  ],  \"outputs\": [  \"test_json_dn:SECTION\"  ],  \"skippable\": \"False:bool\"  }  },  \"SCENARIO\": {  \"default\": {  \"comparators\": {},  \"tasks\": [],  \"additional_data_nodes\": [],  \"frequency\": null,  \"sequences\": {}  },  \"test_scenario\": {  \"comparators\": {  \"test_json_dn\": [  \"tests.core.config.test_config_serialization.compare_function:function\"  ]  },  \"tasks\": [  \"test_task:SECTION\"  ],  \"additional_data_nodes\": [  \"test_pickle_dn:SECTION\"  ],  \"frequency\": \"DAILY:FREQUENCY\",  \"sequences\": {  \"sequence1\": [  \"test_task:SECTION\"  ]  }  }  }  }      \"\"\".strip()      )        Config._serializer = _JsonSerializer()      config_test_scenario()        tf = NamedTemporaryFile()      Config.backup(tf.filename)      actual_config = tf.read().strip()      assert actual_config == expected_json_config        Config.load(tf.filename)      tf2 = NamedTemporaryFile()      Config.backup(tf2.filename)        actual_config_2 = tf2.read().strip()      assert actual_config_2 == expected_json_config        assert Config.unique_sections is not None      assert len(Config.unique_sections) == 3        assert Config.unique_sections[JobConfig.name].mode == \"development\"      assert Config.unique_sections[JobConfig.name].max_nb_of_workers == 1        assert Config.unique_sections[MigrationConfig.name].migration_fcts[\"1.0\"] == {\"test_csv_dn\": migrate_csv_path}        assert Config.sections is not None      assert len(Config.sections) == 3        assert Config.sections[DataNodeConfig.name] is not None      assert len(Config.sections[DataNodeConfig.name]) == 4      assert Config.sections[DataNodeConfig.name][\"default\"] is not None      assert Config.sections[DataNodeConfig.name][\"default\"].storage_type == \"pickle\"      assert Config.sections[DataNodeConfig.name][\"default\"].scope == Scope.SCENARIO      assert Config.sections[DataNodeConfig.name][\"test_csv_dn\"].storage_type == \"csv\"      assert Config.sections[DataNodeConfig.name][\"test_csv_dn\"].scope == Scope.GLOBAL      assert Config.sections[DataNodeConfig.name][\"test_csv_dn\"].validity_period == datetime.timedelta(1)      assert Config.sections[DataNodeConfig.name][\"test_csv_dn\"].has_header is True      assert Config.sections[DataNodeConfig.name][\"test_csv_dn\"].path == \"./test.csv\"      assert Config.sections[DataNodeConfig.name][\"test_csv_dn\"].encoding == \"utf-8\"      assert Config.sections[DataNodeConfig.name][\"test_csv_dn\"].exposed_type == CustomClass      assert Config.sections[DataNodeConfig.name][\"test_json_dn\"].storage_type == \"json\"      assert Config.sections[DataNodeConfig.name][\"test_json_dn\"].scope == Scope.SCENARIO      assert Config.sections[DataNodeConfig.name][\"test_json_dn\"].default_path == \"./test.json\"      assert Config.sections[DataNodeConfig.name][\"test_json_dn\"].encoding == \"utf-8\"      assert Config.sections[DataNodeConfig.name][\"test_json_dn\"].encoder == CustomEncoder      assert Config.sections[DataNodeConfig.name][\"test_json_dn\"].decoder == CustomDecoder      assert Config.sections[DataNodeConfig.name][\"test_pickle_dn\"].storage_type == \"pickle\"      assert Config.sections[DataNodeConfig.name][\"test_pickle_dn\"].scope == Scope.SCENARIO      assert Config.sections[DataNodeConfig.name][\"test_pickle_dn\"].validity_period == datetime.timedelta(1)      assert Config.sections[DataNodeConfig.name][\"test_pickle_dn\"].path == \"./test.p\"        assert Config.sections[TaskConfig.name] is not None      assert len(Config.sections[TaskConfig.name]) == 2      assert Config.sections[TaskConfig.name][\"default\"] is not None      assert Config.sections[TaskConfig.name][\"default\"].inputs == []      assert Config.sections[TaskConfig.name][\"default\"].outputs == []      assert Config.sections[TaskConfig.name][\"default\"].function is None      assert [inp.id for inp in Config.sections[TaskConfig.name][\"test_task\"].inputs] == [          Config.sections[DataNodeConfig.name][\"test_csv_dn\"].id      ]      assert [outp.id for outp in Config.sections[TaskConfig.name][\"test_task\"].outputs] == [          Config.sections[DataNodeConfig.name][\"test_json_dn\"].id      ]      assert Config.sections[TaskConfig.name][\"test_task\"].function == multiply        assert Config.sections[ScenarioConfig.name] is not None      assert len(Config.sections[ScenarioConfig.name]) == 2      assert Config.sections[ScenarioConfig.name][\"default\"] is not None      assert Config.sections[ScenarioConfig.name][\"default\"].tasks == []      assert Config.sections[ScenarioConfig.name][\"default\"].additional_data_nodes == []      assert Config.sections[ScenarioConfig.name][\"default\"].data_nodes == []      assert len(Config.sections[ScenarioConfig.name][\"default\"].comparators) == 0      assert [task.id for task in Config.sections[ScenarioConfig.name][\"test_scenario\"].tasks] == [          Config.sections[TaskConfig.name][\"test_task\"].id      ]      assert [          additional_data_node.id          for additional_data_node in Config.sections[ScenarioConfig.name][\"test_scenario\"].additional_data_nodes      ] == [Config.sections[DataNodeConfig.name][\"test_pickle_dn\"].id]      assert sorted([data_node.id for data_node in Config.sections[ScenarioConfig.name][\"test_scenario\"].data_nodes]) == [          Config.sections[DataNodeConfig.name][\"test_csv_dn\"].id,          Config.sections[DataNodeConfig.name][\"test_json_dn\"].id,          Config.sections[DataNodeConfig.name][\"test_pickle_dn\"].id,      ]      sequences = {}      for sequence_name, sequence_tasks in Config.sections[ScenarioConfig.name][\"test_scenario\"].sequences.items():          sequences[sequence_name] = [task.id for task in sequence_tasks]      assert sequences == {\"sequence1\": [Config.sections[TaskConfig.name][\"test_task\"].id]}        assert dict(Config.sections[ScenarioConfig.name][\"test_scenario\"].comparators) == {          \"test_json_dn\": [compare_function]      }      def test_read_write_toml_configuration_file_migrate_sequence_in_scenario():      old_toml_config = \"\"\"  [TAIPY]    [JOB]  mode = \"development\"  max_nb_of_workers = \"1:int\"    [CORE]  root_folder = \"./taipy/\"  storage_folder = \".data/\"  repository_type = \"filesystem\"  mode = \"development\"  version_number = \"\"  force = \"False:bool\"    [DATA_NODE.default]  storage_type = \"pickle\"  scope = \"SCENARIO:SCOPE\"    [DATA_NODE.test_csv_dn]  storage_type = \"csv\"  scope = \"GLOBAL:SCOPE\"  validity_period = \"1d0h0m0s:timedelta\"  path = \"./test.csv\"  exposed_type = \"tests.core.config.test_config_serialization.CustomClass:class\"  has_header = \"True:bool\"    [DATA_NODE.test_json_dn]  storage_type = \"json\"  scope = \"SCENARIO:SCOPE\"  default_path = \"./test.json\"  encoder = \"tests.core.config.test_config_serialization.CustomEncoder:class\"  decoder = \"tests.core.config.test_config_serialization.CustomDecoder:class\"    [TASK.default]  inputs = []  outputs = []  skippable = \"False:bool\"    [TASK.test_task]  function = \"tests.core.config.test_config_serialization.multiply:function\"  inputs = [ \"test_csv_dn:SECTION\",]  outputs = [ \"test_json_dn:SECTION\",]  skippable = \"False:bool\"    [SCENARIO.default]    [SCENARIO.test_scenario]  tasks = [ \"test_task:SECTION\",]  sequences.test_sequence = [ \"test_task:SECTION\",]  frequency = \"DAILY:FREQUENCY\"    [VERSION_MIGRATION.migration_fcts.\"1.0\"]  test_csv_dn = \"tests.core.config.test_config_serialization.migrate_csv_path:function\"    [SCENARIO.default.comparators]    [SCENARIO.test_scenario.comparators]  test_json_dn = [ \"tests.core.config.test_config_serialization.compare_function:function\",]      \"\"\".strip()        config_test_scenario()        tf = NamedTemporaryFile()      with open(tf.filename, \"w\") as fd:          fd.writelines(old_toml_config)      Config.restore(tf.filename)        assert Config.unique_sections is not None      assert len(Config.unique_sections) == 3        assert Config.unique_sections[CoreSection.name].root_folder == \"./taipy/\"      assert Config.unique_sections[CoreSection.name].storage_folder == \".data/\"      assert Config.unique_sections[CoreSection.name].repository_type == \"filesystem\"      assert Config.unique_sections[CoreSection.name].repository_properties == {}      assert Config.unique_sections[CoreSection.name].mode == \"development\"      assert Config.unique_sections[CoreSection.name].version_number == \"\"      assert Config.unique_sections[CoreSection.name].force is False        assert Config.unique_sections[JobConfig.name].mode == \"development\"      assert Config.unique_sections[JobConfig.name].max_nb_of_workers == 1        assert Config.unique_sections[MigrationConfig.name].migration_fcts[\"1.0\"] == {\"test_csv_dn\": migrate_csv_path}        assert Config.sections is not None      assert len(Config.sections) == 3        assert Config.sections[DataNodeConfig.name] is not None      assert len(Config.sections[DataNodeConfig.name]) == 3      assert Config.sections[DataNodeConfig.name][\"default\"] is not None      assert Config.sections[DataNodeConfig.name][\"default\"].storage_type == \"pickle\"      assert Config.sections[DataNodeConfig.name][\"default\"].scope == Scope.SCENARIO      assert Config.sections[DataNodeConfig.name][\"test_csv_dn\"].storage_type == \"csv\"      assert Config.sections[DataNodeConfig.name][\"test_csv_dn\"].scope == Scope.GLOBAL      assert Config.sections[DataNodeConfig.name][\"test_csv_dn\"].validity_period == datetime.timedelta(1)      assert Config.sections[DataNodeConfig.name][\"test_csv_dn\"].has_header is True      assert Config.sections[DataNodeConfig.name][\"test_csv_dn\"].path == \"./test.csv\"      assert Config.sections[DataNodeConfig.name][\"test_csv_dn\"].exposed_type == CustomClass      assert Config.sections[DataNodeConfig.name][\"test_json_dn\"].storage_type == \"json\"      assert Config.sections[DataNodeConfig.name][\"test_json_dn\"].scope == Scope.SCENARIO      assert Config.sections[DataNodeConfig.name][\"test_json_dn\"].default_path == \"./test.json\"      assert Config.sections[DataNodeConfig.name][\"test_json_dn\"].encoder == CustomEncoder      assert Config.sections[DataNodeConfig.name][\"test_json_dn\"].decoder == CustomDecoder        assert Config.sections[TaskConfig.name] is not None      assert len(Config.sections[TaskConfig.name]) == 2      assert Config.sections[TaskConfig.name][\"default\"] is not None      assert Config.sections[TaskConfig.name][\"default\"].inputs == []      assert Config.sections[TaskConfig.name][\"default\"].outputs == []      assert Config.sections[TaskConfig.name][\"default\"].function is None      assert not Config.sections[TaskConfig.name][\"default\"].skippable      assert [inp.id for inp in Config.sections[TaskConfig.name][\"test_task\"].inputs] == [          Config.sections[DataNodeConfig.name][\"test_csv_dn\"].id      ]      assert [outp.id for outp in Config.sections[TaskConfig.name][\"test_task\"].outputs] == [          Config.sections[DataNodeConfig.name][\"test_json_dn\"].id      ]      assert Config.sections[TaskConfig.name][\"test_task\"].function == multiply      assert Config.sections[TaskConfig.name][\"test_task\"].function == multiply        assert Config.sections[ScenarioConfig.name] is not None      assert len(Config.sections[ScenarioConfig.name]) == 2      assert Config.sections[ScenarioConfig.name][\"default\"] is not None      assert Config.sections[ScenarioConfig.name][\"default\"].tasks == []      assert Config.sections[ScenarioConfig.name][\"default\"].additional_data_nodes == []      assert Config.sections[ScenarioConfig.name][\"default\"].data_nodes == []      assert len(Config.sections[ScenarioConfig.name][\"default\"].comparators) == 0      assert [task.id for task in Config.sections[ScenarioConfig.name][\"test_scenario\"].tasks] == [          Config.sections[TaskConfig.name][\"test_task\"].id      ]      assert [          additional_data_node.id          for additional_data_node in Config.sections[ScenarioConfig.name][\"test_scenario\"].additional_data_nodes      ] == []      assert sorted([data_node.id for data_node in Config.sections[ScenarioConfig.name][\"test_scenario\"].data_nodes]) == [          Config.sections[DataNodeConfig.name][\"test_csv_dn\"].id,          Config.sections[DataNodeConfig.name][\"test_json_dn\"].id,      ]      assert Config.sections[ScenarioConfig.name][\"test_scenario\"].sequences == {          \"test_sequence\": [Config.sections[TaskConfig.name][\"test_task\"]]      }        assert dict(Config.sections[ScenarioConfig.name][\"test_scenario\"].comparators) == {          \"test_json_dn\": [compare_function]      }      def test_read_write_json_configuration_file_migrate_sequence_in_scenario():      old_json_config = \"\"\"  {  \"TAIPY\": {},  \"JOB\": {  \"mode\": \"development\",  \"max_nb_of_workers\": \"1: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\": {  \"1.0\": {  \"test_csv_dn\": \"tests.core.config.test_config_serialization.migrate_csv_path:function\"  }  }  },  \"DATA_NODE\": {  \"default\": {  \"storage_type\": \"pickle\",  \"scope\": \"SCENARIO:SCOPE\"  },  \"test_csv_dn\": {  \"storage_type\": \"csv\",  \"scope\": \"GLOBAL:SCOPE\",  \"validity_period\": \"1d0h0m0s:timedelta\",  \"path\": \"./test.csv\",  \"exposed_type\": \"tests.core.config.test_config_serialization.CustomClass:class\",  \"has_header\": \"True:bool\"  },  \"test_json_dn\": {  \"storage_type\": \"json\",  \"scope\": \"SCENARIO:SCOPE\",  \"default_path\": \"./test.json\",  \"encoder\": \"tests.core.config.test_config_serialization.CustomEncoder:class\",  \"decoder\": \"tests.core.config.test_config_serialization.CustomDecoder:class\"  }  },  \"TASK\": {  \"default\": {  \"function\": null,  \"inputs\": [],  \"outputs\": [],  \"skippable\": \"False:bool\"  },  \"test_task\": {  \"function\": \"tests.core.config.test_config_serialization.multiply:function\",  \"inputs\": [  \"test_csv_dn:SECTION\"  ],  \"outputs\": [  \"test_json_dn:SECTION\"  ],  \"skippable\": \"False:bool\"  }  },  \"SCENARIO\": {  \"default\": {  \"comparators\": {},  \"sequences\": {},  \"frequency\": null  },  \"test_scenario\": {  \"comparators\": {  \"test_json_dn\": [  \"tests.core.config.test_config_serialization.compare_function:function\"  ]  },  \"tasks\": [  \"test_task:SECTION\"  ],  \"sequences\": {  \"test_sequence\": [  \"test_task:SECTION\"  ]  },  \"frequency\": \"DAILY:FREQUENCY\"  }  }  }      \"\"\".strip()        Config._serializer = _JsonSerializer()      config_test_scenario()        tf = NamedTemporaryFile()      with open(tf.filename, \"w\") as fd:          fd.writelines(old_json_config)      Config.restore(tf.filename)        assert Config.unique_sections is not None      assert len(Config.unique_sections) == 3        assert Config.unique_sections[CoreSection.name].root_folder == \"./taipy/\"      assert Config.unique_sections[CoreSection.name].storage_folder == \".data/\"      assert Config.unique_sections[CoreSection.name].repository_type == \"filesystem\"      assert Config.unique_sections[CoreSection.name].repository_properties == {}      assert Config.unique_sections[CoreSection.name].mode == \"development\"      assert Config.unique_sections[CoreSection.name].version_number == \"\"      assert Config.unique_sections[CoreSection.name].force is False        assert Config.unique_sections[JobConfig.name].mode == \"development\"      assert Config.unique_sections[JobConfig.name].max_nb_of_workers == 1        assert Config.unique_sections[MigrationConfig.name].migration_fcts[\"1.0\"] == {\"test_csv_dn\": migrate_csv_path}        assert Config.sections is not None      assert len(Config.sections) == 3        assert Config.sections[DataNodeConfig.name] is not None      assert len(Config.sections[DataNodeConfig.name]) == 3      assert Config.sections[DataNodeConfig.name][\"default\"] is not None      assert Config.sections[DataNodeConfig.name][\"default\"].storage_type == \"pickle\"      assert Config.sections[DataNodeConfig.name][\"default\"].scope == Scope.SCENARIO      assert Config.sections[DataNodeConfig.name][\"test_csv_dn\"].storage_type == \"csv\"      assert Config.sections[DataNodeConfig.name][\"test_csv_dn\"].scope == Scope.GLOBAL      assert Config.sections[DataNodeConfig.name][\"test_csv_dn\"].validity_period == datetime.timedelta(1)      assert Config.sections[DataNodeConfig.name][\"test_csv_dn\"].has_header is True      assert Config.sections[DataNodeConfig.name][\"test_csv_dn\"].path == \"./test.csv\"      assert Config.sections[DataNodeConfig.name][\"test_csv_dn\"].exposed_type == CustomClass      assert Config.sections[DataNodeConfig.name][\"test_json_dn\"].storage_type == \"json\"      assert Config.sections[DataNodeConfig.name][\"test_json_dn\"].scope == Scope.SCENARIO      assert Config.sections[DataNodeConfig.name][\"test_json_dn\"].default_path == \"./test.json\"      assert Config.sections[DataNodeConfig.name][\"test_json_dn\"].encoder == CustomEncoder      assert Config.sections[DataNodeConfig.name][\"test_json_dn\"].decoder == CustomDecoder        assert Config.sections[TaskConfig.name] is not None      assert len(Config.sections[TaskConfig.name]) == 2      assert Config.sections[TaskConfig.name][\"default\"] is not None      assert Config.sections[TaskConfig.name][\"default\"].inputs == []      assert Config.sections[TaskConfig.name][\"default\"].outputs == []      assert Config.sections[TaskConfig.name][\"default\"].function is None      assert [inp.id for inp in Config.sections[TaskConfig.name][\"test_task\"].inputs] == [          Config.sections[DataNodeConfig.name][\"test_csv_dn\"].id      ]      assert [outp.id for outp in Config.sections[TaskConfig.name][\"test_task\"].outputs] == [          Config.sections[DataNodeConfig.name][\"test_json_dn\"].id      ]      assert Config.sections[TaskConfig.name][\"test_task\"].function == multiply        assert Config.sections[ScenarioConfig.name] is not None      assert len(Config.sections[ScenarioConfig.name]) == 2      assert Config.sections[ScenarioConfig.name][\"default\"] is not None      assert Config.sections[ScenarioConfig.name][\"default\"].tasks == []      assert Config.sections[ScenarioConfig.name][\"default\"].additional_data_nodes == []      assert Config.sections[ScenarioConfig.name][\"default\"].data_nodes == []      assert len(Config.sections[ScenarioConfig.name][\"default\"].comparators) == 0      assert [task.id for task in Config.sections[ScenarioConfig.name][\"test_scenario\"].tasks] == [          Config.sections[TaskConfig.name][\"test_task\"].id      ]      assert [          additional_data_node.id          for additional_data_node in Config.sections[ScenarioConfig.name][\"test_scenario\"].additional_data_nodes      ] == []      assert sorted([data_node.id for data_node in Config.sections[ScenarioConfig.name][\"test_scenario\"].data_nodes]) == [          Config.sections[DataNodeConfig.name][\"test_csv_dn\"].id,          Config.sections[DataNodeConfig.name][\"test_json_dn\"].id,      ]      assert Config.sections[ScenarioConfig.name][\"test_scenario\"].sequences == {          \"test_sequence\": [Config.sections[TaskConfig.name][\"test_task\"]]      }        assert dict(Config.sections[ScenarioConfig.name][\"test_scenario\"].comparators) == {          \"test_json_dn\": [compare_function]      } "}
{"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": "import os  from unittest import mock    from taipy.config.common.frequency import Frequency  from taipy.config.config import Config  from tests.core.utils.named_temporary_file import NamedTemporaryFile      def my_func():      pass      def _configure_scenario_in_toml():      return NamedTemporaryFile(          content=\"\"\"  [TAIPY]    [TASK.task1]  inputs = []  outputs = []    [TASK.task2]  inputs = []  outputs = []    [SCENARIO.scenarios1]  tasks = [ \"task1:SECTION\", \"task2:SECTION\"]      \"\"\"      )      def _check_tasks_instance(task_id, scenario_id):      \"\"\"Check if the task instance in the task config correctly points to the Config._applied_config,      not the Config._python_config or the Config._file_config      \"\"\"      task_config_applied_instance = Config.tasks[task_id]      task_config_instance_via_scenario = None      for task in Config.scenarios[scenario_id].tasks:          if task.id == task_id:              task_config_instance_via_scenario = task        task_config_python_instance = None      if Config._python_config._sections.get(\"TASK\", None):          task_config_python_instance = Config._python_config._sections[\"TASK\"][task_id]        task_config_file_instance = None      if Config._file_config._sections.get(\"TASK\", None):          task_config_file_instance = Config._file_config._sections[\"TASK\"][task_id]        assert task_config_python_instance is not task_config_applied_instance      assert task_config_python_instance is not task_config_instance_via_scenario      assert task_config_file_instance is not task_config_applied_instance      assert task_config_file_instance is not task_config_instance_via_scenario      assert task_config_instance_via_scenario is task_config_applied_instance      def test_task_instance_when_configure_scenario_in_python():      task1_config = Config.configure_task(\"task1\", [])      task2_config = Config.configure_task(\"task2\", print)      Config.configure_scenario(\"scenarios1\", [task1_config, task2_config])        _check_tasks_instance(\"task1\", \"scenarios1\")      _check_tasks_instance(\"task2\", \"scenarios1\")      def test_task_instance_when_configure_scenario_by_loading_toml():      toml_config = _configure_scenario_in_toml()      Config.load(toml_config.filename)        _check_tasks_instance(\"task1\", \"scenarios1\")      _check_tasks_instance(\"task2\", \"scenarios1\")      def test_task_instance_when_configure_scenario_by_overriding_toml():      toml_config = _configure_scenario_in_toml()      Config.override(toml_config.filename)        _check_tasks_instance(\"task1\", \"scenarios1\")      _check_tasks_instance(\"task2\", \"scenarios1\")      def test_scenario_creation():      dn_config_1 = Config.configure_data_node(\"dn1\")      dn_config_2 = Config.configure_data_node(\"dn2\")      dn_config_3 = Config.configure_data_node(\"dn3\")      dn_config_4 = Config.configure_data_node(\"dn4\")      task_config_1 = Config.configure_task(\"task1\", sum, [dn_config_1, dn_config_2], dn_config_3)      task_config_2 = Config.configure_task(\"task2\", print, dn_config_3)      scenario = Config.configure_scenario(          \"scenarios1\",          [task_config_1, task_config_2],          [dn_config_4],          comparators={\"dn_cfg\": [my_func]},          sequences={\"sequence\": []},      )        assert list(Config.scenarios) == [\"default\", scenario.id]        scenario2 = Config.configure_scenario(\"scenarios2\", [task_config_1], frequency=Frequency.MONTHLY)      assert list(Config.scenarios) == [\"default\", scenario.id, scenario2.id]      def test_scenario_count():      task_config_1 = Config.configure_task(\"task1\", my_func)      task_config_2 = Config.configure_task(\"task2\", print)      Config.configure_scenario(\"scenarios1\", [task_config_1, task_config_2])      assert len(Config.scenarios) == 2        Config.configure_scenario(\"scenarios2\", [task_config_1])      assert len(Config.scenarios) == 3        Config.configure_scenario(\"scenarios3\", [task_config_2])      assert len(Config.scenarios) == 4      def test_scenario_getitem():      dn_config_1 = Config.configure_data_node(\"dn1\")      dn_config_2 = Config.configure_data_node(\"dn2\")      dn_config_3 = Config.configure_data_node(\"dn3\")      dn_config_4 = Config.configure_data_node(\"dn4\")      task_config_1 = Config.configure_task(\"task1\", sum, [dn_config_1, dn_config_2], dn_config_3)      task_config_2 = Config.configure_task(\"task2\", print, dn_config_3)      scenario_id = \"scenarios1\"      scenario = Config.configure_scenario(scenario_id, [task_config_1, task_config_2], [dn_config_4])        assert Config.scenarios[scenario_id].id == scenario.id        assert Config.scenarios[scenario_id].task_configs == scenario.task_configs      assert Config.scenarios[scenario_id].tasks == scenario.tasks      assert Config.scenarios[scenario_id].task_configs == scenario.tasks        assert Config.scenarios[scenario_id].additional_data_node_configs == scenario.additional_data_node_configs      assert Config.scenarios[scenario_id].additional_data_nodes == scenario.additional_data_nodes      assert Config.scenarios[scenario_id].additional_data_node_configs == scenario.additional_data_nodes        assert Config.scenarios[scenario_id].data_node_configs == scenario.data_node_configs      assert Config.scenarios[scenario_id].data_nodes == scenario.data_nodes      assert Config.scenarios[scenario_id].data_node_configs == scenario.data_nodes        assert scenario.tasks == [task_config_1, task_config_2]      assert scenario.additional_data_node_configs == [dn_config_4]      assert set(scenario.data_nodes) == set([dn_config_4, dn_config_1, dn_config_2, dn_config_3])        assert Config.scenarios[scenario_id].properties == scenario.properties      def test_scenario_creation_no_duplication():      task_config_1 = Config.configure_task(\"task1\", my_func)      task_config_2 = Config.configure_task(\"task2\", print)      dn_config = Config.configure_data_node(\"dn\")      Config.configure_scenario(\"scenarios1\", [task_config_1, task_config_2], [dn_config])        assert len(Config.scenarios) == 2        Config.configure_scenario(\"scenarios1\", [task_config_1, task_config_2], [dn_config])      assert len(Config.scenarios) == 2      def test_scenario_get_set_and_remove_comparators():      task_config_1 = Config.configure_task(\"task1\", my_func)      task_config_2 = Config.configure_task(\"task2\", print)      dn_config_1 = \"dn_config_1\"      scenario_config_1 = Config.configure_scenario(          \"scenarios1\", [task_config_1, task_config_2], comparators={dn_config_1: my_func}      )        assert scenario_config_1.comparators is not None      assert scenario_config_1.comparators[dn_config_1] == [my_func]      assert len(scenario_config_1.comparators.keys()) == 1        dn_config_2 = \"dn_config_2\"      scenario_config_1.add_comparator(dn_config_2, my_func)      assert len(scenario_config_1.comparators.keys()) == 2        scenario_config_1.delete_comparator(dn_config_1)      assert len(scenario_config_1.comparators.keys()) == 1        scenario_config_1.delete_comparator(dn_config_2)      assert len(scenario_config_1.comparators.keys()) == 0        scenario_config_2 = Config.configure_scenario(\"scenarios2\", [task_config_1, task_config_2])        assert scenario_config_2.comparators is not None        scenario_config_2.add_comparator(dn_config_1, my_func)      assert len(scenario_config_2.comparators.keys()) == 1        scenario_config_2.delete_comparator(\"dn_config_3\")      def test_scenario_config_with_env_variable_value():      task_config_1 = Config.configure_task(\"task1\", my_func)      task_config_2 = Config.configure_task(\"task2\", print)      with mock.patch.dict(os.environ, {\"FOO\": \"bar\"}):          Config.configure_scenario(\"scenario_name\", [task_config_1, task_config_2], prop=\"ENV[FOO]\")          assert Config.scenarios[\"scenario_name\"].prop == \"bar\"          assert Config.scenarios[\"scenario_name\"].properties[\"prop\"] == \"bar\"          assert Config.scenarios[\"scenario_name\"]._properties[\"prop\"] == \"ENV[FOO]\"      def test_clean_config():      task1_config = Config.configure_task(\"task1\", print, [], [])      task2_config = Config.configure_task(\"task2\", print, [], [])      scenario1_config = Config.configure_scenario(          \"id1\",          [task1_config, task2_config],          [],          Frequency.YEARLY,          {\"foo\": \"bar\"},          prop=\"foo\",          sequences={\"sequence_1\": []},      )      scenario2_config = Config.configure_scenario(          \"id2\",          [task2_config, task1_config],          [],          Frequency.MONTHLY,          {\"foz\": \"baz\"},          prop=\"bar\",          sequences={\"sequence_2\": []},      )        assert Config.scenarios[\"id1\"] is scenario1_config      assert Config.scenarios[\"id2\"] is scenario2_config        scenario1_config._clean()      scenario2_config._clean()        # Check if the instance before and after _clean() is the same      assert Config.scenarios[\"id1\"] is scenario1_config      assert Config.scenarios[\"id2\"] is scenario2_config        assert scenario1_config.id == \"id1\"      assert scenario2_config.id == \"id2\"      assert scenario1_config.tasks == scenario1_config.task_configs == []      assert scenario1_config.additional_data_nodes == scenario1_config.additional_data_node_configs == []      assert scenario1_config.data_nodes == scenario1_config.data_node_configs == []      assert scenario1_config.sequences == scenario1_config.sequences == {}      assert scenario1_config.frequency is scenario1_config.frequency is None      assert scenario1_config.comparators == scenario1_config.comparators == {}      assert scenario1_config.properties == scenario1_config.properties == {}        assert scenario2_config.tasks == scenario2_config.task_configs == []      assert scenario2_config.additional_data_nodes == scenario2_config.additional_data_node_configs == []      assert scenario2_config.data_nodes == scenario2_config.data_node_configs == []      assert scenario2_config.sequences == scenario1_config.sequences == {}      assert scenario2_config.frequency is scenario2_config.frequency is None      assert scenario2_config.comparators == scenario2_config.comparators == {}      assert scenario2_config.properties == scenario2_config.properties == {}      def test_add_sequence():      task1_config = Config.configure_task(\"task1\", print, [], [])      task2_config = Config.configure_task(\"task2\", print, [], [])      task3_config = Config.configure_task(\"task3\", print, [], [])      task4_config = Config.configure_task(\"task4\", print, [], [])      scenario_config = Config.configure_scenario(          \"id\", [task1_config, task2_config, task3_config, task4_config], [], Frequency.YEARLY, prop=\"foo\"      )        assert Config.scenarios[\"id\"] is scenario_config        assert scenario_config.id == \"id\"      assert (          scenario_config.tasks          == scenario_config.task_configs          == [task1_config, task2_config, task3_config, task4_config]      )      assert scenario_config.additional_data_nodes == scenario_config.additional_data_node_configs == []      assert scenario_config.data_nodes == scenario_config.data_node_configs == []      assert scenario_config.frequency is scenario_config.frequency == Frequency.YEARLY      assert scenario_config.comparators == scenario_config.comparators == {}      assert scenario_config.properties == {\"prop\": \"foo\"}        scenario_config.add_sequences(          {              \"sequence1\": [task1_config],              \"sequence2\": [task2_config, task3_config],              \"sequence3\": [task1_config, task2_config, task4_config],          }      )      assert len(scenario_config.sequences) == 3      assert scenario_config.sequences[\"sequence1\"] == [task1_config]      assert scenario_config.sequences[\"sequence2\"] == [task2_config, task3_config]      assert scenario_config.sequences[\"sequence3\"] == [task1_config, task2_config, task4_config]        scenario_config.remove_sequences(\"sequence1\")      assert len(scenario_config.sequences) == 2      scenario_config.remove_sequences([\"sequence2\", \"sequence3\"])      assert len(scenario_config.sequences) == 0 "}
{"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": "import os  from datetime import timedelta  from unittest import mock    from src.taipy.core.config import DataNodeConfig, ScenarioConfig, TaskConfig  from src.taipy.core.config.core_section import CoreSection  from taipy.config.common.frequency import Frequency  from taipy.config.common.scope import Scope  from taipy.config.config import Config  from tests.core.utils.named_temporary_file import NamedTemporaryFile      def test_write_configuration_file():      expected_config = 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 = \"{CoreSection._CURRENT_CORE_VERSION}\"    [VERSION_MIGRATION.migration_fcts]    [DATA_NODE.default]  storage_type = \"in_memory\"  scope = \"SCENARIO:SCOPE\"  validity_period = \"1d0h0m0s:timedelta\"  custom = \"default_custom_prop\"    [DATA_NODE.dn1]  storage_type = \"pickle\"  scope = \"SCENARIO:SCOPE\"  validity_period = \"1d0h0m0s:timedelta\"  custom = \"custom property\"  default_data = \"dn1\"    [DATA_NODE.dn2]  storage_type = \"ENV[FOO]\"  scope = \"SCENARIO:SCOPE\"  validity_period = \"2d0h0m0s:timedelta\"  foo = \"bar\"  default_data = \"dn2\"  baz = \"ENV[QUX]\"  quux = \"ENV[QUUZ]:bool\"  corge = [ \"grault\", \"ENV[GARPLY]\", \"ENV[WALDO]:int\", \"3.0:float\",]    [DATA_NODE.dn3]  storage_type = \"ENV[FOO]\"  scope = \"SCENARIO:SCOPE\"  validity_period = \"1d0h0m0s:timedelta\"  foo = \"bar\"  default_data = \"dn3\"  quux = \"ENV[QUUZ]:bool\"    [TASK.default]  inputs = []  outputs = []  skippable = \"False:bool\"    [TASK.t1]  function = \"builtins.print:function\"  inputs = [ \"dn1:SECTION\",]  outputs = [ \"dn2:SECTION\",]  skippable = \"False:bool\"  description = \"t1 description\"    [SCENARIO.default]  tasks = []  additional_data_nodes = []  frequency = \"QUARTERLY:FREQUENCY\"  owner = \"Michel Platini\"    [SCENARIO.s1]  tasks = [ \"t1:SECTION\",]  additional_data_nodes = [ \"dn3:SECTION\",]  frequency = \"QUARTERLY:FREQUENCY\"  owner = \"Raymond Kopa\"    [SCENARIO.default.comparators]    [SCENARIO.default.sequences]    [SCENARIO.s1.comparators]    [SCENARIO.s1.sequences]  sequence = [ \"t1:SECTION\",]      \"\"\".strip()      tf = NamedTemporaryFile()      with mock.patch.dict(          os.environ, {\"FOO\": \"in_memory\", \"QUX\": \"qux\", \"QUUZ\": \"true\", \"GARPLY\": \"garply\", \"WALDO\": \"17\"}      ):          Config.configure_job_executions(mode=\"standalone\", max_nb_of_workers=2)          Config.set_default_data_node_configuration(              storage_type=\"in_memory\",              custom=\"default_custom_prop\",              validity_period=timedelta(1),          )          dn1_cfg_v2 = Config.configure_data_node(              \"dn1\", storage_type=\"pickle\", scope=Scope.SCENARIO, default_data=\"dn1\", custom=\"custom property\"          )          dn2_cfg_v2 = Config.configure_data_node(              \"dn2\",              storage_type=\"ENV[FOO]\",              validity_period=timedelta(2),              foo=\"bar\",              default_data=\"dn2\",              baz=\"ENV[QUX]\",              quux=\"ENV[QUUZ]:bool\",              corge=(\"grault\", \"ENV[GARPLY]\", \"ENV[WALDO]:int\", 3.0),          )          dn3_cfg_v2 = Config.configure_data_node(              \"dn3\",              storage_type=\"ENV[FOO]\",              foo=\"bar\",              default_data=\"dn3\",              quux=\"ENV[QUUZ]:bool\",          )          assert dn2_cfg_v2.scope == Scope.SCENARIO          t1_cfg_v2 = Config.configure_task(\"t1\", print, dn1_cfg_v2, dn2_cfg_v2, description=\"t1 description\")          Config.set_default_scenario_configuration([], [], Frequency.QUARTERLY, owner=\"Michel Platini\")          Config.configure_scenario(              \"s1\",              task_configs=[t1_cfg_v2],              additional_data_node_configs=[dn3_cfg_v2],              frequency=Frequency.QUARTERLY,              owner=\"Raymond Kopa\",              sequences={\"sequence\": [t1_cfg_v2]},          )          Config.backup(tf.filename)          actual_config = tf.read().strip()  # problem here            assert actual_config == expected_config          Config.override(tf.filename)          tf2 = NamedTemporaryFile()          Config.backup(tf2.filename)          actual_config_2 = tf2.read().strip()          assert actual_config_2 == expected_config      def test_read_configuration_file():      file_config = NamedTemporaryFile(          \"\"\"          [DATA_NODE.default]          has_header = true            [DATA_NODE.my_datanode]          path = \"/data/csv\"          validity_period = \"1d0h0m0s:timedelta\"            [DATA_NODE.my_datanode2]          path = \"/data2/csv\"            [DATA_NODE.my_datanode3]          path = \"/data3/csv\"          source = \"local\"            [TASK.my_task]          inputs = [\"my_datanode:SECTION\"]          outputs = [\"my_datanode2:SECTION\"]          description = \"task description\"            [SCENARIO.my_scenario]          tasks = [ \"my_task:SECTION\"]          additional_data_nodes = [\"my_datanode3:SECTION\"]          owner = \"John Doe\"            [SCENARIO.my_scenario.sequences]          sequence = [ \"my_task:SECTION\",]          \"\"\"      )      Config.configure_task(\"my_task\", print)      Config.override(file_config.filename)        assert len(Config.data_nodes) == 4      assert type(Config.data_nodes[\"my_datanode\"]) == DataNodeConfig      assert type(Config.data_nodes[\"my_datanode2\"]) == DataNodeConfig      assert type(Config.data_nodes[\"my_datanode3\"]) == DataNodeConfig      assert Config.data_nodes[\"my_datanode\"].path == \"/data/csv\"      assert Config.data_nodes[\"my_datanode2\"].path == \"/data2/csv\"      assert Config.data_nodes[\"my_datanode3\"].path == \"/data3/csv\"      assert Config.data_nodes[\"my_datanode\"].id == \"my_datanode\"      assert Config.data_nodes[\"my_datanode2\"].id == \"my_datanode2\"      assert Config.data_nodes[\"my_datanode3\"].id == \"my_datanode3\"      assert Config.data_nodes[\"my_datanode\"].validity_period == timedelta(1)      assert Config.data_nodes[\"my_datanode3\"].source == \"local\"        assert len(Config.tasks) == 2      assert type(Config.tasks[\"my_task\"]) == TaskConfig      assert Config.tasks[\"my_task\"].id == \"my_task\"      assert Config.tasks[\"my_task\"].description == \"task description\"      assert Config.tasks[\"my_task\"].function == print      assert len(Config.tasks[\"my_task\"].inputs) == 1      assert type(Config.tasks[\"my_task\"].inputs[0]) == DataNodeConfig      assert Config.tasks[\"my_task\"].inputs[0].path == \"/data/csv\"      assert Config.tasks[\"my_task\"].inputs[0].id == \"my_datanode\"      assert len(Config.tasks[\"my_task\"].outputs) == 1      assert type(Config.tasks[\"my_task\"].outputs[0]) == DataNodeConfig      assert Config.tasks[\"my_task\"].outputs[0].path == \"/data2/csv\"      assert Config.tasks[\"my_task\"].outputs[0].id == \"my_datanode2\"        assert len(Config.scenarios) == 2      assert type(Config.scenarios[\"my_scenario\"]) == ScenarioConfig      assert Config.scenarios[\"my_scenario\"].id == \"my_scenario\"      assert Config.scenarios[\"my_scenario\"].owner == \"John Doe\"      assert len(Config.scenarios[\"my_scenario\"].tasks) == 1      assert type(Config.scenarios[\"my_scenario\"].tasks[0]) == TaskConfig      assert len(Config.scenarios[\"my_scenario\"].additional_data_nodes) == 1      assert type(Config.scenarios[\"my_scenario\"].additional_data_nodes[0]) == DataNodeConfig      assert Config.scenarios[\"my_scenario\"].tasks[0].id == \"my_task\"      assert Config.scenarios[\"my_scenario\"].tasks[0].description == \"task description\"      assert Config.scenarios[\"my_scenario\"].additional_data_nodes[0].id == \"my_datanode3\"      assert Config.scenarios[\"my_scenario\"].additional_data_nodes[0].source == \"local\"      assert [task.id for task in Config.scenarios[\"my_scenario\"].sequences[\"sequence\"]] == [          Config.scenarios[\"my_scenario\"].tasks[0].id      ] "}
{"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": "import os  from unittest import mock    import pytest    from taipy.config.config import Config  from taipy.config.exceptions.exceptions import InconsistentEnvVariableError, MissingEnvVariableError  from tests.core.utils.named_temporary_file import NamedTemporaryFile      def test_override_default_configuration_with_code_configuration():      assert not Config.core.root_folder == \"foo\"      assert len(Config.data_nodes) == 1      assert len(Config.tasks) == 1      assert len(Config.scenarios) == 1        Config.configure_job_executions(max_nb_of_workers=-1)      Config.configure_core(root_folder=\"foo\")      foo_config = Config.configure_data_node(\"foo\", \"in_memory\")      xyz_config = Config.configure_data_node(\"xyz\")      bar_config = Config.configure_task(\"bar\", print, [foo_config], [])      qux_config = Config.configure_scenario(\"qux\", [bar_config], [xyz_config])        assert Config.job_config.max_nb_of_workers == -1      assert Config.core.root_folder == \"foo\"      assert len(Config.data_nodes) == 3      assert \"default\" in Config.data_nodes      assert foo_config.id in Config.data_nodes      assert xyz_config.id in Config.data_nodes      assert Config.data_nodes[foo_config.id].storage_type == \"in_memory\"      assert Config.data_nodes[xyz_config.id].storage_type == \"pickle\"      assert len(Config.tasks) == 2      assert \"default\" in Config.tasks      assert bar_config.id in Config.tasks      assert len(Config.tasks[bar_config.id].input_configs) == 1      assert Config.tasks[bar_config.id].input_configs[0].id == foo_config.id      assert len(Config.tasks[bar_config.id].output_configs) == 0      assert Config.tasks[bar_config.id].function == print        assert len(Config.scenarios) == 2      assert \"default\" in Config.scenarios      assert qux_config.id in Config.scenarios      assert len(Config.scenarios[qux_config.id].tasks) == 1      assert Config.scenarios[qux_config.id].tasks[0].id == bar_config.id      assert len(Config.scenarios[qux_config.id].additional_data_nodes) == 1      assert Config.scenarios[qux_config.id].additional_data_nodes[0].id == xyz_config.id      def test_override_default_config_with_code_config_including_env_variable_values():      Config.configure_core()      assert Config.core.repository_type == \"filesystem\"      Config.configure_core(repository_type=\"othertype\")      assert Config.core.repository_type == \"othertype\"        with mock.patch.dict(os.environ, {\"REPOSITORY_TYPE\": \"foo\"}):          Config.configure_core(repository_type=\"ENV[REPOSITORY_TYPE]\")          assert Config.core.repository_type == \"foo\"      def test_override_default_configuration_with_file_configuration():      tf = NamedTemporaryFile(          \"\"\"  [TAIPY]    [JOB]  max_nb_of_workers = -1    [DATA_NODE.foo]    [TASK.bar]    [SCENARIO.qux]  \"\"\"      )      assert Config.job_config.max_nb_of_workers == 1      assert len(Config.data_nodes) == 1      assert len(Config.tasks) == 1      assert len(Config.scenarios) == 1        Config.override(tf.filename)        assert Config.job_config.max_nb_of_workers == -1      assert len(Config.data_nodes) == 2      assert \"default\" in Config.data_nodes      assert \"foo\" in Config.data_nodes      assert len(Config.tasks) == 2      assert \"default\" in Config.tasks      assert \"bar\" in Config.tasks      assert \"default\" in Config.scenarios      assert len(Config.scenarios) == 2      assert \"qux\" in Config.scenarios      def test_override_default_config_with_file_config_including_env_variable_values():      tf = NamedTemporaryFile(          \"\"\"  [JOB]  max_nb_of_workers = \"ENV[FOO]:int\"  start_executor = \"ENV[BAR]\"  \"\"\"      )      assert Config.job_config.max_nb_of_workers == 1      assert not Config.job_config.start_executor        with mock.patch.dict(os.environ, {\"FOO\": \"6\", \"BAR\": \"TRUe\"}):          Config.override(tf.filename)          assert Config.job_config.max_nb_of_workers == 6          assert Config.job_config.start_executor        with mock.patch.dict(os.environ, {\"FOO\": \"foo\", \"BAR\": \"true\"}):          with pytest.raises(InconsistentEnvVariableError):              Config.override(tf.filename)        with mock.patch.dict(os.environ, {\"FOO\": \"5\"}):          with pytest.raises(MissingEnvVariableError):              Config.override(tf.filename)      def test_code_configuration_do_not_override_file_configuration():      config_from_filename = NamedTemporaryFile(          \"\"\"  [JOB]  max_nb_of_workers = 2      \"\"\"      )      Config.override(config_from_filename.filename)        Config.configure_job_executions(max_nb_of_workers=21)        assert Config.job_config.max_nb_of_workers == 2  # From file config      def test_code_configuration_do_not_override_file_configuration_including_env_variable_values():      config_from_filename = NamedTemporaryFile(          \"\"\"  [JOB]  max_nb_of_workers = 2      \"\"\"      )      Config.override(config_from_filename.filename)        with mock.patch.dict(os.environ, {\"FOO\": \"21\"}):          Config.configure_job_executions(max_nb_of_workers=\"ENV[FOO]\")          assert Config.job_config.max_nb_of_workers == 2  # From file config      def test_file_configuration_override_code_configuration():      config_from_filename = NamedTemporaryFile(          \"\"\"  [JOB]  max_nb_of_workers = 2      \"\"\"      )      Config.configure_job_executions(max_nb_of_workers=21)      Config.override(config_from_filename.filename)        assert Config.job_config.max_nb_of_workers == 2  # From file config      def test_file_configuration_override_code_configuration_including_env_variable_values():      config_from_filename = NamedTemporaryFile(          \"\"\"  [JOB]  max_nb_of_workers = \"ENV[FOO]:int\"      \"\"\"      )      Config.configure_job_executions(max_nb_of_workers=21)        with mock.patch.dict(os.environ, {\"FOO\": \"2\"}):          Config.override(config_from_filename.filename)          assert Config.job_config.max_nb_of_workers == 2  # From file config      def test_override_default_configuration_with_multiple_configurations():      file_config = NamedTemporaryFile(          \"\"\"  [DATA_NODE.default]  has_header = true  [DATA_NODE.my_datanode]  path = \"/data/csv\"    [JOB]  max_nb_of_workers = 10    [TAIPY]      \"\"\"      )        # Default config is applied      assert Config.job_config.max_nb_of_workers == 1        # Code config is applied      Config.configure_job_executions(max_nb_of_workers=-1)      assert Config.job_config.max_nb_of_workers == -1        # File config is applied      Config.override(file_config.filename)      assert Config.job_config.max_nb_of_workers == 10      assert Config.data_nodes[\"my_datanode\"].has_header      assert Config.data_nodes[\"my_datanode\"].path == \"/data/csv\"      assert Config.data_nodes[\"my_datanode\"].not_defined is None      def test_override_default_configuration_with_multiple_configurations_including_environment_variable_values():      file_config = NamedTemporaryFile(          \"\"\"  [DATA_NODE.default]  has_header = true  [DATA_NODE.my_datanode]  path = \"ENV[FOO]\"    [JOB]  max_nb_of_workers = 10    [TAIPY]      \"\"\"      )        with mock.patch.dict(os.environ, {\"FOO\": \"/data/csv\", \"BAR\": \"/baz/data/csv\"}):          # Default config is applied          assert Config.job_config.max_nb_of_workers == 1            # Code config is applied          Config.configure_job_executions(max_nb_of_workers=-1)          Config.configure_data_node(\"my_datanode\", path=\"ENV[BAR]\")          assert Config.job_config.max_nb_of_workers == -1          assert Config.data_nodes[\"my_datanode\"].path == \"/baz/data/csv\"            # File config is applied          Config.override(file_config.filename)          assert Config.job_config.max_nb_of_workers == 10          assert Config.data_nodes[\"my_datanode\"].has_header          assert Config.data_nodes[\"my_datanode\"].path == \"/data/csv\"          assert Config.data_nodes[\"my_datanode\"].not_defined is None "}
{"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": "import datetime  import os  from unittest import mock    import pytest    from src.taipy.core import MongoDefaultDocument  from src.taipy.core._orchestrator._orchestrator_factory import _OrchestratorFactory  from src.taipy.core.config import DataNodeConfig  from src.taipy.core.config.job_config import JobConfig  from taipy.config.common.scope import Scope  from taipy.config.config import Config  from taipy.config.exceptions.exceptions import ConfigurationUpdateBlocked      def test_data_node_config_default_parameter():      csv_dn_cfg = Config.configure_data_node(\"data_node_1\", \"csv\")      assert csv_dn_cfg.scope == Scope.SCENARIO      assert csv_dn_cfg.has_header is True      assert csv_dn_cfg.exposed_type == \"pandas\"      assert csv_dn_cfg.validity_period is None        json_dn_cfg = Config.configure_data_node(\"data_node_2\", \"json\")      assert json_dn_cfg.scope == Scope.SCENARIO      assert json_dn_cfg.validity_period is None        parquet_dn_cfg = Config.configure_data_node(\"data_node_3\", \"parquet\")      assert parquet_dn_cfg.scope == Scope.SCENARIO      assert parquet_dn_cfg.engine == \"pyarrow\"      assert parquet_dn_cfg.compression == \"snappy\"      assert parquet_dn_cfg.exposed_type == \"pandas\"      assert parquet_dn_cfg.validity_period is None        excel_dn_cfg = Config.configure_data_node(\"data_node_4\", \"excel\")      assert excel_dn_cfg.scope == Scope.SCENARIO      assert excel_dn_cfg.has_header is True      assert excel_dn_cfg.exposed_type == \"pandas\"      assert excel_dn_cfg.validity_period is None        generic_dn_cfg = Config.configure_data_node(\"data_node_5\", \"generic\")      assert generic_dn_cfg.scope == Scope.SCENARIO      assert generic_dn_cfg.validity_period is None        in_memory_dn_cfg = Config.configure_data_node(\"data_node_6\", \"in_memory\")      assert in_memory_dn_cfg.scope == Scope.SCENARIO      assert in_memory_dn_cfg.validity_period is None        pickle_dn_cfg = Config.configure_data_node(\"data_node_7\", \"pickle\")      assert pickle_dn_cfg.scope == Scope.SCENARIO      assert pickle_dn_cfg.validity_period is None        sql_table_dn_cfg = Config.configure_data_node(          \"data_node_8\", \"sql_table\", db_name=\"test\", db_engine=\"mssql\", table_name=\"test\"      )      assert sql_table_dn_cfg.scope == Scope.SCENARIO      assert sql_table_dn_cfg.db_host == \"localhost\"      assert sql_table_dn_cfg.db_port == 1433      assert sql_table_dn_cfg.db_driver == \"\"      assert sql_table_dn_cfg.sqlite_file_extension == \".db\"      assert sql_table_dn_cfg.exposed_type == \"pandas\"      assert sql_table_dn_cfg.validity_period is None        sql_dn_cfg = Config.configure_data_node(          \"data_node_9\", \"sql\", db_name=\"test\", db_engine=\"mssql\", read_query=\"test\", write_query_builder=print      )      assert sql_dn_cfg.scope == Scope.SCENARIO      assert sql_dn_cfg.db_host == \"localhost\"      assert sql_dn_cfg.db_port == 1433      assert sql_dn_cfg.db_driver == \"\"      assert sql_dn_cfg.sqlite_file_extension == \".db\"      assert sql_dn_cfg.exposed_type == \"pandas\"      assert sql_dn_cfg.validity_period is None        mongo_dn_cfg = Config.configure_data_node(          \"data_node_10\", \"mongo_collection\", db_name=\"test\", collection_name=\"test\"      )      assert mongo_dn_cfg.scope == Scope.SCENARIO      assert mongo_dn_cfg.db_host == \"localhost\"      assert mongo_dn_cfg.db_port == 27017      assert mongo_dn_cfg.custom_document == MongoDefaultDocument      assert mongo_dn_cfg.db_username == \"\"      assert mongo_dn_cfg.db_password == \"\"      assert mongo_dn_cfg.db_driver == \"\"      assert mongo_dn_cfg.validity_period is None      def test_data_node_config_check(caplog):      data_node_config = Config.configure_data_node(\"data_nodes1\", \"pickle\")      assert list(Config.data_nodes) == [DataNodeConfig._DEFAULT_KEY, data_node_config.id]        data_node2_config = Config.configure_data_node(\"data_nodes2\", \"pickle\")      assert list(Config.data_nodes) == [DataNodeConfig._DEFAULT_KEY, data_node_config.id, data_node2_config.id]        data_node3_config = Config.configure_data_node(\"data_nodes3\", \"csv\", has_header=True, default_path=\"\")      assert list(Config.data_nodes) == [          \"default\",          data_node_config.id,          data_node2_config.id,          data_node3_config.id,      ]        with pytest.raises(SystemExit):          Config.configure_data_node(\"data_nodes\", storage_type=\"bar\")          Config.check()      expected_error_message = (          \"`storage_type` field of DataNodeConfig `data_nodes` must be either csv, sql_table,\"          \" sql, mongo_collection, pickle, excel, generic, json, parquet, or in_memory. Current\"          ' value of property `storage_type` is \"bar\".'      )      assert expected_error_message in caplog.text        with pytest.raises(SystemExit):          Config.configure_data_node(\"data_nodes\", scope=\"bar\")          Config.check()      expected_error_message = (          \"`scope` field of DataNodeConfig `data_nodes` must be populated with a Scope value.\"          ' Current value of property `scope` is \"bar\".'      )      assert expected_error_message in caplog.text        with pytest.raises(TypeError):          Config.configure_data_node(\"data_nodes\", storage_type=\"sql\")        with pytest.raises(SystemExit):          Config.configure_data_node(\"data_nodes\", storage_type=\"generic\")          Config.check()      expected_error_message = (          \"`storage_type` field of DataNodeConfig `data_nodes` must be either csv, sql_table,\"          \" sql, mongo_collection, pickle, excel, generic, json, parquet, or in_memory.\"          ' Current value of property `storage_type` is \"bar\".'      )      assert expected_error_message in caplog.text      def test_configure_data_node_from_another_configuration():      d1_cfg = Config.configure_sql_table_data_node(          \"d1\",          db_username=\"foo\",          db_password=\"bar\",          db_name=\"db\",          db_engine=\"mssql\",          db_port=8080,          db_host=\"somewhere\",          table_name=\"foo\",          scope=Scope.GLOBAL,          foo=\"bar\",      )        d2_cfg = Config.configure_data_node_from(          source_configuration=d1_cfg,          id=\"d2\",          table_name=\"table_2\",      )        assert d2_cfg.id == \"d2\"      assert d2_cfg.storage_type == \"sql_table\"      assert d2_cfg.scope == Scope.GLOBAL      assert d2_cfg.validity_period is None      assert d2_cfg.db_username == \"foo\"      assert d2_cfg.db_password == \"bar\"      assert d2_cfg.db_name == \"db\"      assert d2_cfg.db_engine == \"mssql\"      assert d2_cfg.db_port == 8080      assert d2_cfg.db_host == \"somewhere\"      assert d2_cfg.table_name == \"table_2\"      assert d2_cfg.foo == \"bar\"        d3_cfg = Config.configure_data_node_from(          source_configuration=d1_cfg,          id=\"d3\",          scope=Scope.SCENARIO,          validity_period=datetime.timedelta(days=1),          table_name=\"table_3\",          foo=\"baz\",      )        assert d3_cfg.id == \"d3\"      assert d3_cfg.storage_type == \"sql_table\"      assert d3_cfg.scope == Scope.SCENARIO      assert d3_cfg.validity_period == datetime.timedelta(days=1)      assert d3_cfg.db_username == \"foo\"      assert d3_cfg.db_password == \"bar\"      assert d3_cfg.db_name == \"db\"      assert d3_cfg.db_engine == \"mssql\"      assert d3_cfg.db_port == 8080      assert d3_cfg.db_host == \"somewhere\"      assert d3_cfg.table_name == \"table_3\"      assert d3_cfg.foo == \"baz\"      def test_data_node_count():      Config.configure_data_node(\"data_nodes1\", \"pickle\")      assert len(Config.data_nodes) == 2        Config.configure_data_node(\"data_nodes2\", \"pickle\")      assert len(Config.data_nodes) == 3        Config.configure_data_node(\"data_nodes3\", \"pickle\")      assert len(Config.data_nodes) == 4      def test_data_node_getitem():      data_node_id = \"data_nodes1\"      data_node_config = Config.configure_data_node(data_node_id, \"pickle\", default_path=\"foo.p\")        assert Config.data_nodes[data_node_id].id == data_node_config.id      assert Config.data_nodes[data_node_id].default_path == \"foo.p\"      assert Config.data_nodes[data_node_id].storage_type == data_node_config.storage_type      assert Config.data_nodes[data_node_id].scope == data_node_config.scope      assert Config.data_nodes[data_node_id].properties == data_node_config.properties      assert Config.data_nodes[data_node_id].cacheable == data_node_config.cacheable      def test_data_node_creation_no_duplication():      Config.configure_data_node(\"data_nodes1\", \"pickle\")        assert len(Config.data_nodes) == 2        Config.configure_data_node(\"data_nodes1\", \"pickle\")      assert len(Config.data_nodes) == 2      def test_date_node_create_with_datetime():      data_node_config = Config.configure_data_node(          id=\"datetime_data\",          my_property=datetime.datetime(1991, 1, 1),          foo=\"hello\",          test=1,          test_dict={\"type\": \"Datetime\", 2: \"daw\"},      )      assert data_node_config.foo == \"hello\"      assert data_node_config.my_property == datetime.datetime(1991, 1, 1)      assert data_node_config.test == 1      assert data_node_config.test_dict.get(\"type\") == \"Datetime\"      def test_data_node_with_env_variable_value():      with mock.patch.dict(os.environ, {\"FOO\": \"pickle\", \"BAR\": \"baz\"}):          Config.configure_data_node(\"data_node\", storage_type=\"ENV[FOO]\", prop=\"ENV[BAR]\")          assert Config.data_nodes[\"data_node\"].prop == \"baz\"          assert Config.data_nodes[\"data_node\"].properties[\"prop\"] == \"baz\"          assert Config.data_nodes[\"data_node\"]._properties[\"prop\"] == \"ENV[BAR]\"          assert Config.data_nodes[\"data_node\"].storage_type == \"pickle\"          assert Config.data_nodes[\"data_node\"]._storage_type == \"ENV[FOO]\"      def test_data_node_with_env_variable_in_write_fct_args():      def read_fct():          ...        def write_fct():          ...        with mock.patch.dict(os.environ, {\"FOO\": \"bar\", \"BAZ\": \"qux\"}):          Config.configure_data_node(              \"data_node\",              storage_type=\"generic\",              read_fct=read_fct,              write_fct=write_fct,              write_fct_args=[\"ENV[FOO]\", \"my_param\", \"ENV[BAZ]\"],          )          assert Config.data_nodes[\"data_node\"].write_fct_args == [\"bar\", \"my_param\", \"qux\"]      def test_data_node_with_env_variable_in_read_fct_args():      def read_fct():          ...        def write_fct():          ...        with mock.patch.dict(os.environ, {\"FOO\": \"bar\", \"BAZ\": \"qux\"}):          Config.configure_data_node(              \"data_node\",              storage_type=\"generic\",              read_fct=read_fct,              write_fct=write_fct,              read_fct_args=[\"ENV[FOO]\", \"my_param\", \"ENV[BAZ]\"],          )          assert Config.data_nodes[\"data_node\"].read_fct_args == [\"bar\", \"my_param\", \"qux\"]      def test_block_datanode_config_update_in_development_mode():      data_node_id = \"data_node_id\"      Config.configure_job_executions(mode=JobConfig._DEVELOPMENT_MODE)      data_node_config = Config.configure_data_node(          id=data_node_id,          storage_type=\"pickle\",          default_path=\"foo.p\",          scope=Scope.SCENARIO,      )        assert Config.data_nodes[data_node_id].id == data_node_id      assert Config.data_nodes[data_node_id].default_path == \"foo.p\"      assert Config.data_nodes[data_node_id].storage_type == \"pickle\"      assert Config.data_nodes[data_node_id].scope == Scope.SCENARIO      assert Config.data_nodes[data_node_id].properties == {\"default_path\": \"foo.p\"}        _OrchestratorFactory._build_dispatcher()        with pytest.raises(ConfigurationUpdateBlocked):          data_node_config.storage_type = \"foo\"        with pytest.raises(ConfigurationUpdateBlocked):          data_node_config.scope = Scope.SCENARIO        with pytest.raises(ConfigurationUpdateBlocked):          data_node_config.cacheable = True        with pytest.raises(ConfigurationUpdateBlocked):          data_node_config.properties = {\"foo\": \"bar\"}        assert Config.data_nodes[data_node_id].id == data_node_id      assert Config.data_nodes[data_node_id].default_path == \"foo.p\"      assert Config.data_nodes[data_node_id].storage_type == \"pickle\"      assert Config.data_nodes[data_node_id].scope == Scope.SCENARIO      assert Config.data_nodes[data_node_id].properties == {\"default_path\": \"foo.p\"}      def test_block_datanode_config_update_in_standalone_mode():      data_node_id = \"data_node_id\"      Config.configure_job_executions(mode=JobConfig._STANDALONE_MODE)      data_node_config = Config.configure_data_node(          id=data_node_id,          storage_type=\"pickle\",          default_path=\"foo.p\",          scope=Scope.SCENARIO,      )        assert Config.data_nodes[data_node_id].id == data_node_id      assert Config.data_nodes[data_node_id].default_path == \"foo.p\"      assert Config.data_nodes[data_node_id].storage_type == \"pickle\"      assert Config.data_nodes[data_node_id].scope == Scope.SCENARIO      assert Config.data_nodes[data_node_id].properties == {\"default_path\": \"foo.p\"}        _OrchestratorFactory._build_dispatcher()        with pytest.raises(ConfigurationUpdateBlocked):          data_node_config.storage_type = \"foo\"        with pytest.raises(ConfigurationUpdateBlocked):          data_node_config.scope = Scope.SCENARIO        with pytest.raises(ConfigurationUpdateBlocked):          data_node_config.cacheable = True        with pytest.raises(ConfigurationUpdateBlocked):          data_node_config.properties = {\"foo\": \"bar\"}        assert Config.data_nodes[data_node_id].id == data_node_id      assert Config.data_nodes[data_node_id].default_path == \"foo.p\"      assert Config.data_nodes[data_node_id].storage_type == \"pickle\"      assert Config.data_nodes[data_node_id].scope == Scope.SCENARIO      assert Config.data_nodes[data_node_id].properties == {\"default_path\": \"foo.p\"}      def test_clean_config():      dn1_config = Config.configure_data_node(          id=\"id1\",          storage_type=\"csv\",          default_path=\"foo.p\",          scope=Scope.GLOBAL,          validity_period=datetime.timedelta(2),      )      dn2_config = Config.configure_data_node(          id=\"id2\",          storage_type=\"json\",          default_path=\"bar.json\",          scope=Scope.GLOBAL,          validity_period=datetime.timedelta(2),      )        assert Config.data_nodes[\"id1\"] is dn1_config      assert Config.data_nodes[\"id2\"] is dn2_config        dn1_config._clean()      dn2_config._clean()        # Check if the instance before and after _clean() is the same      assert Config.data_nodes[\"id1\"] is dn1_config      assert Config.data_nodes[\"id2\"] is dn2_config        # Check if the value is similar to the default_config, but with difference instances      assert dn1_config.id == \"id1\"      assert dn2_config.id == \"id2\"      assert dn1_config.storage_type == dn2_config.storage_type == \"pickle\"      assert dn1_config.scope == dn2_config.scope == Scope.SCENARIO      assert dn1_config.validity_period is dn2_config.validity_period is None      assert dn1_config.default_path is dn2_config.default_path is None      assert dn1_config.properties == dn2_config.properties == {}      def test_deprecated_cacheable_attribute_remains_compatible():      dn_1_id = \"dn_1_id\"      dn_1_config = Config.configure_data_node(          id=dn_1_id,          storage_type=\"pickle\",          cacheable=False,          scope=Scope.SCENARIO,      )      assert Config.data_nodes[dn_1_id].id == dn_1_id      assert Config.data_nodes[dn_1_id].storage_type == \"pickle\"      assert Config.data_nodes[dn_1_id].scope == Scope.SCENARIO      assert Config.data_nodes[dn_1_id].properties == {\"cacheable\": False}      assert not Config.data_nodes[dn_1_id].cacheable      dn_1_config.cacheable = True      assert Config.data_nodes[dn_1_id].properties == {\"cacheable\": True}      assert Config.data_nodes[dn_1_id].cacheable        dn_2_id = \"dn_2_id\"      dn_2_config = Config.configure_data_node(          id=dn_2_id,          storage_type=\"pickle\",          cacheable=True,          scope=Scope.SCENARIO,      )      assert Config.data_nodes[dn_2_id].id == dn_2_id      assert Config.data_nodes[dn_2_id].storage_type == \"pickle\"      assert Config.data_nodes[dn_2_id].scope == Scope.SCENARIO      assert Config.data_nodes[dn_2_id].properties == {\"cacheable\": True}      assert Config.data_nodes[dn_2_id].cacheable      dn_2_config.cacheable = False      assert Config.data_nodes[dn_1_id].properties == {\"cacheable\": False}      assert not Config.data_nodes[dn_1_id].cacheable        dn_3_id = \"dn_3_id\"      dn_3_config = Config.configure_data_node(          id=dn_3_id,          storage_type=\"pickle\",          scope=Scope.SCENARIO,      )      assert Config.data_nodes[dn_3_id].id == dn_3_id      assert Config.data_nodes[dn_3_id].storage_type == \"pickle\"      assert Config.data_nodes[dn_3_id].scope == Scope.SCENARIO      assert Config.data_nodes[dn_3_id].properties == {}      assert not Config.data_nodes[dn_3_id].cacheable      dn_3_config.cacheable = True      assert Config.data_nodes[dn_3_id].properties == {\"cacheable\": True}      assert Config.data_nodes[dn_3_id].cacheable "}
{"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 copy import copy    import pytest    from src.taipy.core.config import TaskConfig  from src.taipy.core.config.data_node_config import DataNodeConfig  from taipy.config.checker.issue_collector import IssueCollector  from taipy.config.config import Config      class TestTaskConfigChecker:      def test_check_config_id(self, caplog):          config = Config._applied_config          Config._compile_configs()          Config._collector = IssueCollector()          Config.check()          assert len(Config._collector.errors) == 0          assert len(Config._collector.warnings) == 0            config._sections[TaskConfig.name][\"new\"] = copy(config._sections[TaskConfig.name][\"default\"])          config._sections[TaskConfig.name][\"new\"].id = None          with pytest.raises(SystemExit):              Config._collector = IssueCollector()              Config.check()          assert len(Config._collector.errors) == 2          assert \"config_id of TaskConfig `None` is empty\" in caplog.text          assert \"function field of TaskConfig `new` is empty\" in caplog.text          assert len(Config._collector.warnings) == 2          assert \"inputs field of TaskConfig `new` is empty.\" in caplog.text          assert \"outputs field of TaskConfig `new` is empty.\" in caplog.text            caplog.clear()            config._sections[TaskConfig.name][\"new\"].id = \"new\"          with pytest.raises(SystemExit):              Config._collector = IssueCollector()              Config.check()          assert len(Config._collector.errors) == 1          assert len(Config._collector.warnings) == 2        def test_check_if_entity_property_key_used_is_predefined(self, caplog):          Config._collector = IssueCollector()          config = Config._applied_config          Config._compile_configs()          Config.check()          assert len(Config._collector.errors) == 0            config._sections[TaskConfig.name][\"new\"] = copy(config._sections[TaskConfig.name][\"default\"])          config._sections[TaskConfig.name][\"new\"]._properties[\"_entity_owner\"] = None          with pytest.raises(SystemExit):              Config._collector = IssueCollector()              Config.check()          assert len(Config._collector.errors) == 2          assert \"function field of TaskConfig `new` is empty\" in caplog.text          assert \"Properties of TaskConfig `default` cannot have `_entity_owner` as its property.\" in caplog.text            caplog.clear()            config._sections[TaskConfig.name][\"new\"] = copy(config._sections[TaskConfig.name][\"default\"])          config._sections[TaskConfig.name][\"new\"]._properties[\"_entity_owner\"] = \"entity_owner\"          with pytest.raises(SystemExit):              Config._collector = IssueCollector()              Config.check()          assert len(Config._collector.errors) == 2          assert \"function field of TaskConfig `new` is empty\" in caplog.text          expected_error_message = (              \"Properties of TaskConfig `default` 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_inputs(self, caplog):          config = Config._applied_config          Config._compile_configs()          Config._collector = IssueCollector()          Config.check()          assert len(Config._collector.errors) == 0          assert len(Config._collector.warnings) == 0            config._sections[TaskConfig.name][\"new\"] = config._sections[TaskConfig.name][\"default\"]          config._sections[TaskConfig.name][\"new\"].id, config._sections[TaskConfig.name][\"new\"].function = \"new\", print          Config._collector = IssueCollector()          Config.check()          assert len(Config._collector.errors) == 0          assert len(Config._collector.warnings) == 2          assert \"inputs field of TaskConfig `new` is empty.\" in caplog.text          assert \"outputs field of TaskConfig `new` is empty.\" in caplog.text            config._sections[TaskConfig.name][\"new\"]._inputs = \"bar\"          with pytest.raises(SystemExit):              Config._collector = IssueCollector()              Config.check()          assert len(Config._collector.errors) == 1          expected_error_message = (              \"inputs field of TaskConfig `new` must be populated with a list of DataNodeConfig\"              \" objects. Current value of property `inputs` is ['b', 'a', 'r'].\"          )          assert expected_error_message in caplog.text          assert len(Config._collector.warnings) == 1            config._sections[TaskConfig.name][\"new\"]._inputs = [\"bar\"]          with pytest.raises(SystemExit):              Config._collector = IssueCollector()              Config.check()          assert len(Config._collector.errors) == 1          expected_error_message = (              \"inputs field of TaskConfig `new` must be populated with a list of DataNodeConfig\"              \" objects. Current value of property `inputs` is ['bar'].\"          )          assert expected_error_message in caplog.text          assert len(Config._collector.warnings) == 1            config._sections[TaskConfig.name][\"new\"]._inputs = [DataNodeConfig(\"bar\")]          Config._collector = IssueCollector()          Config.check()          assert len(Config._collector.errors) == 0          assert len(Config._collector.warnings) == 1            config._sections[TaskConfig.name][\"new\"]._inputs = [\"bar\", DataNodeConfig(\"bar\")]          with pytest.raises(SystemExit):              Config._collector = IssueCollector()              Config.check()          assert len(Config._collector.errors) == 1          expected_error_message = (              \"inputs field of TaskConfig `new` must be populated with a list of\"              \" DataNodeConfig objects. Current value of property `inputs` is\"              \" ['bar', <src.taipy.core.config.data_node_config.DataNodeConfig object at\"          )          assert expected_error_message in caplog.text          assert len(Config._collector.warnings) == 1        def test_check_outputs(self, caplog):          config = Config._applied_config          Config._compile_configs()            config._sections[TaskConfig.name][\"default\"]._outputs = \"bar\"          Config._collector = IssueCollector()          Config.check()          assert len(Config._collector.errors) == 0          assert len(Config._collector.warnings) == 0            config._sections[TaskConfig.name][\"new\"] = config._sections[TaskConfig.name][\"default\"]          config._sections[TaskConfig.name][\"new\"].id, config._sections[TaskConfig.name][\"new\"].function = \"new\", print          with pytest.raises(SystemExit):              Config._collector = IssueCollector()              Config.check()          assert len(Config._collector.errors) == 1          expected_error_message = (              \"outputs field of TaskConfig `new` must be populated with a list of DataNodeConfig\"              \" objects. Current value of property `outputs` is ['b', 'a', 'r'].\"          )          assert expected_error_message in caplog.text          assert len(Config._collector.warnings) == 1            config._sections[TaskConfig.name][\"new\"]._outputs = [\"bar\"]          with pytest.raises(SystemExit):              Config._collector = IssueCollector()              Config.check()          assert len(Config._collector.errors) == 1          expected_error_message = (              \"outputs field of TaskConfig `new` must be populated with a list of DataNodeConfig\"              \" objects. Current value of property `outputs` is ['bar'].\"          )          assert expected_error_message in caplog.text          assert len(Config._collector.warnings) == 1            config._sections[TaskConfig.name][\"new\"]._outputs = [DataNodeConfig(\"bar\")]          Config._collector = IssueCollector()          Config.check()          assert len(Config._collector.errors) == 0          assert len(Config._collector.warnings) == 1            config._sections[TaskConfig.name][\"new\"]._outputs = [\"bar\", DataNodeConfig(\"bar\")]          with pytest.raises(SystemExit):              Config._collector = IssueCollector()              Config.check()          assert len(Config._collector.errors) == 1          expected_error_message = (              \"outputs field of TaskConfig `new` must be populated with a list of\"              \" DataNodeConfig objects. Current value of property `outputs` is\"              \" ['bar', <src.taipy.core.config.data_node_config.DataNodeConfig object at\"          )          assert expected_error_message in caplog.text          assert len(Config._collector.warnings) == 1        def test_check_function(self, caplog):          def mock_func():              pass            config = Config._applied_config          Config._compile_configs()            Config._collector = IssueCollector()          Config.check()          assert len(Config._collector.errors) == 0          assert len(Config._collector.warnings) == 0            config._sections[TaskConfig.name][\"new\"] = copy(config._sections[TaskConfig.name][\"default\"])          config._sections[TaskConfig.name][\"new\"].id = \"new\"          with pytest.raises(SystemExit):              Config._collector = IssueCollector()              Config.check()          assert len(Config._collector.errors) == 1          assert \"function field of TaskConfig `new` is empty.\" in caplog.text          assert len(Config._collector.warnings) == 2            config._sections[TaskConfig.name][\"new\"].function = None          with pytest.raises(SystemExit):              Config._collector = IssueCollector()              Config.check()          assert len(Config._collector.errors) == 1          assert \"function field of TaskConfig `new` is empty.\" in caplog.text          assert len(Config._collector.warnings) == 2            config._sections[TaskConfig.name][\"new\"].function = \"bar\"          with pytest.raises(SystemExit):              Config._collector = IssueCollector()              Config.check()          assert len(Config._collector.errors) == 1          expected_error_message = (              \"function field of TaskConfig `new` must be populated with Callable value.\"              ' Current value of property `function` is \"bar\".'          )          assert expected_error_message in caplog.text          assert len(Config._collector.warnings) == 2            config._sections[TaskConfig.name][\"new\"].function = mock_func          Config._collector = IssueCollector()          Config.check()          assert len(Config._collector.errors) == 0          assert len(Config._collector.warnings) == 2 "}
{"text": "from copy import copy  from datetime import timedelta    import pytest    from src.taipy.core.config.data_node_config import DataNodeConfig  from taipy.config import Config  from taipy.config.checker.issue_collector import IssueCollector  from taipy.config.common.scope import Scope      class MyCustomClass:      pass      class TestDataNodeConfigChecker:      def test_check_config_id(self, caplog):          Config._collector = IssueCollector()          config = Config._applied_config          Config._compile_configs()          Config.check()          assert len(Config._collector.errors) == 0            config._sections[DataNodeConfig.name][\"new\"] = copy(config._sections[DataNodeConfig.name][\"default\"])          config._sections[DataNodeConfig.name][\"new\"].id = None          with pytest.raises(SystemExit):              Config._collector = IssueCollector()              Config.check()          assert len(Config._collector.errors) == 1          assert \"config_id of DataNodeConfig `None` is empty.\" in caplog.text            config._sections[DataNodeConfig.name][\"new\"].id = \"new\"          Config._collector = IssueCollector()          Config.check()          assert len(Config._collector.errors) == 0        def test_check_if_entity_property_key_used_is_predefined(self, caplog):          Config._collector = IssueCollector()          config = Config._applied_config          Config._compile_configs()          Config.check()          assert len(Config._collector.errors) == 0            config._sections[DataNodeConfig.name][\"new\"] = copy(config._sections[DataNodeConfig.name][\"default\"])          config._sections[DataNodeConfig.name][\"new\"]._properties[\"_entity_owner\"] = None          with pytest.raises(SystemExit):              Config._collector = IssueCollector()              Config.check()          assert len(Config._collector.errors) == 1          assert \"Properties of DataNodeConfig `default` cannot have `_entity_owner` as its property.\" in caplog.text            config._sections[DataNodeConfig.name][\"new\"] = copy(config._sections[DataNodeConfig.name][\"default\"])          config._sections[DataNodeConfig.name][\"new\"]._properties[\"_entity_owner\"] = \"entity_owner\"          with pytest.raises(SystemExit):              Config._collector = IssueCollector()              Config.check()          assert len(Config._collector.errors) == 1          expected_error_message = (              \"Properties of DataNodeConfig `default` 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_storage_type(self, caplog):          Config._collector = IssueCollector()          config = Config._applied_config          Config._compile_configs()          Config.check()          assert len(Config._collector.errors) == 0            config._sections[DataNodeConfig.name][\"new\"] = copy(config._sections[DataNodeConfig.name][\"default\"])            config._sections[DataNodeConfig.name][\"new\"].storage_type = \"bar\"          with pytest.raises(SystemExit):              Config._collector = IssueCollector()              Config.check()          assert len(Config._collector.errors) == 1          expected_error_message = (              \"`storage_type` field of DataNodeConfig `new` must be either csv, sql_table,\"              \" sql, mongo_collection, pickle, excel, generic, json, parquet, or in_memory.\"              ' Current value of property `storage_type` is \"bar\".'          )          assert expected_error_message in caplog.text            config._sections[DataNodeConfig.name][\"new\"].storage_type = \"csv\"          Config._collector = IssueCollector()          Config.check()          assert len(Config._collector.errors) == 0            config._sections[DataNodeConfig.name][\"new\"].storage_type = \"excel\"          Config._collector = IssueCollector()          Config.check()          assert len(Config._collector.errors) == 0            config._sections[DataNodeConfig.name][\"new\"].storage_type = \"pickle\"          Config._collector = IssueCollector()          Config.check()          assert len(Config._collector.errors) == 0            config._sections[DataNodeConfig.name][\"new\"].storage_type = \"json\"          Config._collector = IssueCollector()          Config.check()          assert len(Config._collector.errors) == 0            config._sections[DataNodeConfig.name][\"new\"].storage_type = \"parquet\"          Config._collector = IssueCollector()          Config.check()          assert len(Config._collector.errors) == 0            config._sections[DataNodeConfig.name][\"new\"].storage_type = \"in_memory\"          Config._collector = IssueCollector()          Config.check()          assert len(Config._collector.errors) == 0            config._sections[DataNodeConfig.name][\"new\"].storage_type = \"generic\"          with pytest.raises(SystemExit):              Config._collector = IssueCollector()              Config.check()          assert len(Config._collector.errors) == 1          expected_error_messages = [              \"Either `read_fct` field or `write_fct` field of DataNodeConfig `new` \"              \"must be populated with a Callable function.\",          ]          assert all(message in caplog.text for message in expected_error_messages)            config._sections[DataNodeConfig.name][\"new\"].storage_type = \"sql_table\"          with pytest.raises(SystemExit):              Config._collector = IssueCollector()              Config.check()          assert len(Config._collector.errors) == 3          expected_error_messages = [              \"DataNodeConfig `new` is missing the required property `db_name` for type `sql_table`.\",              \"DataNodeConfig `new` is missing the required property `db_engine` for type `sql_table`.\",              \"DataNodeConfig `new` is missing the required property `table_name` for type `sql_table`.\",          ]          assert all(message in caplog.text for message in expected_error_messages)            config._sections[DataNodeConfig.name][\"new\"].storage_type = \"sql\"          with pytest.raises(SystemExit):              Config._collector = IssueCollector()              Config.check()          assert len(Config._collector.errors) == 4          expected_error_messages = [              \"DataNodeConfig `new` is missing the required property `db_name` for type `sql`.\",              \"DataNodeConfig `new` is missing the required property `db_engine` for type `sql`.\",              \"DataNodeConfig `new` is missing the required property `read_query` for type `sql`.\",              \"DataNodeConfig `new` is missing the required property `write_query_builder` for type `sql`.\",          ]          assert all(message in caplog.text for message in expected_error_messages)            config._sections[DataNodeConfig.name][\"new\"].storage_type = \"mongo_collection\"          with pytest.raises(SystemExit):              Config._collector = IssueCollector()              Config.check()          assert len(Config._collector.errors) == 2          expected_error_messages = [              \"DataNodeConfig `new` is missing the required property `db_name` for type `mongo_collection`.\",              \"DataNodeConfig `new` is missing the required property `collection_name` for type `mongo_collection`.\",          ]          assert all(message in caplog.text for message in expected_error_messages)        def test_check_properties_of_sqlite_engine(self, caplog):          config = Config._applied_config          Config._compile_configs()          config._sections[DataNodeConfig.name][\"new\"] = copy(config._sections[DataNodeConfig.name][\"default\"])            # Test SQLite engine          config._sections[DataNodeConfig.name][\"new\"].storage_type = \"sql_table\"          config._sections[DataNodeConfig.name][\"new\"].properties = {\"db_engine\": \"sqlite\"}          with pytest.raises(SystemExit):              Config._collector = IssueCollector()              Config.check()          assert len(Config._collector.errors) == 2          expected_error_messages = [              \"DataNodeConfig `new` is missing the required property `db_name` for type `sql_table`.\",              \"DataNodeConfig `new` is missing the required property `table_name` for type `sql_table`.\",          ]          assert all(message in caplog.text for message in expected_error_messages)        def test_check_properties_of_not_sqlite_engine(self, caplog):          config = Config._applied_config          Config._compile_configs()          config._sections[DataNodeConfig.name][\"new\"] = copy(config._sections[DataNodeConfig.name][\"default\"])            # Test other engines          config._sections[DataNodeConfig.name][\"new\"].storage_type = \"sql_table\"          config._sections[DataNodeConfig.name][\"new\"].properties = {\"db_engine\": \"mssql\"}          with pytest.raises(SystemExit):              Config._collector = IssueCollector()              Config.check()          assert len(Config._collector.errors) == 4            config._sections[DataNodeConfig.name][\"new\"].storage_type = \"sql_table\"          config._sections[DataNodeConfig.name][\"new\"].properties = {\"db_engine\": \"mysql\"}          with pytest.raises(SystemExit):              Config._collector = IssueCollector()              Config.check()          assert len(Config._collector.errors) == 4            config._sections[DataNodeConfig.name][\"new\"].storage_type = \"sql_table\"          config._sections[DataNodeConfig.name][\"new\"].properties = {\"db_engine\": \"postgresql\"}          with pytest.raises(SystemExit):              Config._collector = IssueCollector()              Config.check()          assert len(Config._collector.errors) == 4            expected_error_messages = [              \"DataNodeConfig `new` is missing the required property `db_username` for type `sql_table`.\",              \"DataNodeConfig `new` is missing the required property `db_password` for type `sql_table`.\",              \"DataNodeConfig `new` is missing the required property `db_name` for type `sql_table`.\",              \"DataNodeConfig `new` is missing the required property `table_name` for type `sql_table`.\",          ]          assert all(message in caplog.text for message in expected_error_messages)        def test_check_scope(self, caplog):          config = Config._applied_config          Config._compile_configs()            config._sections[DataNodeConfig.name][\"default\"].scope = \"bar\"          with pytest.raises(SystemExit):              Config._collector = IssueCollector()              Config.check()          assert len(Config._collector.errors) == 1          expected_error_message = (              \"`scope` field of DataNodeConfig `default` must be populated with a Scope\"              ' value. Current value of property `scope` is \"bar\".'          )          assert expected_error_message in caplog.text            config._sections[DataNodeConfig.name][\"default\"].scope = 1          with pytest.raises(SystemExit):              Config._collector = IssueCollector()              Config.check()          assert len(Config._collector.errors) == 1          expected_error_message = (              \"`scope` field of DataNodeConfig `default` must be populated with a Scope\"              \" value. Current value of property `scope` is 1.\"          )          assert expected_error_message in caplog.text            config._sections[DataNodeConfig.name][\"default\"].scope = Scope.GLOBAL          Config._collector = IssueCollector()          Config.check()          assert len(Config._collector.errors) == 0          assert len(Config._collector.warnings) == 0            config._sections[DataNodeConfig.name][\"default\"].scope = Scope.CYCLE          Config._collector = IssueCollector()          Config.check()          assert len(Config._collector.errors) == 0          assert len(Config._collector.warnings) == 0            config._sections[DataNodeConfig.name][\"default\"].scope = Scope.SCENARIO          Config._collector = IssueCollector()          Config.check()          assert len(Config._collector.errors) == 0          assert len(Config._collector.warnings) == 0        def test_check_validity_period(self, caplog):          config = Config._applied_config          Config._compile_configs()            config._sections[DataNodeConfig.name][\"default\"].validity_period = \"bar\"          with pytest.raises(SystemExit):              Config._collector = IssueCollector()              Config.check()          assert len(Config._collector.errors) == 1          expected_error_message = (              \"`validity_period` field of DataNodeConfig `default` must be None or populated with\"              ' a timedelta value. Current value of property `validity_period` is \"bar\".'          )          assert expected_error_message in caplog.text            config._sections[DataNodeConfig.name][\"default\"].validity_period = 1          with pytest.raises(SystemExit):              Config._collector = IssueCollector()              Config.check()          assert len(Config._collector.errors) == 1          expected_error_message = (              \"`validity_period` field of DataNodeConfig `default` must be None or populated with\"              \" a timedelta value. Current value of property `validity_period` is 1.\"          )          assert expected_error_message in caplog.text            config._sections[DataNodeConfig.name][\"default\"].validity_period = None          Config._collector = IssueCollector()          Config.check()          assert len(Config._collector.errors) == 0          assert len(Config._collector.warnings) == 0            config._sections[DataNodeConfig.name][\"default\"].validity_period = timedelta(1)          Config._collector = IssueCollector()          Config.check()          assert len(Config._collector.errors) == 0          assert len(Config._collector.warnings) == 0        def test_check_required_properties(self, caplog):          config = Config._applied_config          Config._compile_configs()          config._sections[DataNodeConfig.name][\"new\"] = copy(config._sections[DataNodeConfig.name][\"default\"])            config._sections[DataNodeConfig.name][\"new\"].storage_type = \"csv\"          Config._collector = IssueCollector()          Config.check()          assert len(Config._collector.errors) == 0            config._sections[DataNodeConfig.name][\"new\"].storage_type = \"csv\"          config._sections[DataNodeConfig.name][\"new\"].properties = {\"has_header\": True}          Config._collector = IssueCollector()          Config.check()          assert len(Config._collector.errors) == 0            config._sections[DataNodeConfig.name][\"new\"].storage_type = \"csv\"          config._sections[DataNodeConfig.name][\"new\"].properties = {\"path\": \"bar\"}          Config._collector = IssueCollector()          Config.check()          assert len(Config._collector.errors) == 0            required_properties = [\"db_username\", \"db_password\", \"db_name\", \"db_engine\", \"table_name\"]          config._sections[DataNodeConfig.name][\"new\"].storage_type = \"sql_table\"          config._sections[DataNodeConfig.name][\"new\"].properties = {key: f\"the_{key}\" for key in required_properties}          Config._collector = IssueCollector()          Config.check()          assert len(Config._collector.errors) == 0            config._sections[DataNodeConfig.name][\"new\"].storage_type = \"sql\"          config._sections[DataNodeConfig.name][\"new\"].properties = {              \"db_username\": \"foo\",              \"db_password\": \"foo\",              \"db_name\": \"foo\",              \"db_engine\": \"foo\",              \"read_query\": \"foo\",              \"write_query_builder\": print,          }          Config._collector = IssueCollector()          Config.check()          assert len(Config._collector.errors) == 0            config._sections[DataNodeConfig.name][\"new\"].storage_type = \"mongo_collection\"          config._sections[DataNodeConfig.name][\"new\"].properties = {\"db_name\": \"foo\", \"collection_name\": \"bar\"}          Config._collector = IssueCollector()          Config.check()          assert len(Config._collector.errors) == 0            config._sections[DataNodeConfig.name][\"new\"].storage_type = \"excel\"          Config._collector = IssueCollector()          Config.check()          assert len(Config._collector.errors) == 0            config._sections[DataNodeConfig.name][\"new\"].storage_type = \"excel\"          config._sections[DataNodeConfig.name][\"new\"].properties = {\"has_header\": True}          Config._collector = IssueCollector()          Config.check()          assert len(Config._collector.errors) == 0            config._sections[DataNodeConfig.name][\"new\"].storage_type = \"excel\"          config._sections[DataNodeConfig.name][\"new\"].properties = {\"path\": \"bar\"}          Config._collector = IssueCollector()          Config.check()          assert len(Config._collector.errors) == 0            config._sections[DataNodeConfig.name][\"new\"].storage_type = \"excel\"          config._sections[DataNodeConfig.name][\"new\"].properties = {              \"has_header\": True,              \"path\": \"bar\",              \"sheet_name\": [\"sheet_name_1\", \"sheet_name_2\"],          }          Config._collector = IssueCollector()          Config.check()          assert len(Config._collector.errors) == 0            config._sections[DataNodeConfig.name][\"new\"].storage_type = \"generic\"          with pytest.raises(SystemExit):              Config._collector = IssueCollector()              Config.check()          assert len(Config._collector.errors) == 1            config._sections[DataNodeConfig.name][\"new\"].storage_type = \"generic\"          config._sections[DataNodeConfig.name][\"new\"].properties = {\"read_fct\": print}          Config._collector = IssueCollector()          Config.check()          assert len(Config._collector.errors) == 0            config._sections[DataNodeConfig.name][\"new\"].storage_type = \"generic\"          config._sections[DataNodeConfig.name][\"new\"].properties = {\"write_fct\": print}          Config._collector = IssueCollector()          Config.check()          assert len(Config._collector.errors) == 0            config._sections[DataNodeConfig.name][\"new\"].storage_type = \"generic\"          config._sections[DataNodeConfig.name][\"new\"].properties = {\"write_fct\": print, \"read_fct\": print}          Config._collector = IssueCollector()          Config.check()          assert len(Config._collector.errors) == 0            config._sections[DataNodeConfig.name][\"new\"].storage_type = \"json\"          config._sections[DataNodeConfig.name][\"new\"].properties = {\"default_path\": \"bar\"}          Config._collector = IssueCollector()          Config.check()          assert len(Config._collector.errors) == 0        def test_required_properties_on_default_only_raise_warning(self):          config = Config._applied_config          Config._compile_configs()          config._sections[DataNodeConfig.name][\"new\"] = copy(config._sections[DataNodeConfig.name][\"default\"])            config._sections[DataNodeConfig.name][\"default\"].storage_type = \"generic\"          Config._collector = IssueCollector()          Config.check()          assert len(Config._collector.errors) == 0          assert len(Config._collector.warnings) == 0            config._sections[DataNodeConfig.name][\"new\"].storage_type = \"generic\"          with pytest.raises(SystemExit):              Config._collector = IssueCollector()              Config.check()          assert len(Config._collector.errors) == 1        def test_check_callable_properties(self, caplog):          config = Config._applied_config          Config._compile_configs()          config._sections[DataNodeConfig.name][\"new\"] = copy(config._sections[DataNodeConfig.name][\"default\"])            config._sections[DataNodeConfig.name][\"new\"].storage_type = \"sql\"          config._sections[DataNodeConfig.name][\"new\"].properties = {              \"db_username\": \"foo\",              \"db_password\": \"foo\",              \"db_name\": \"foo\",              \"db_engine\": \"foo\",              \"read_query\": \"foo\",              \"write_query_builder\": 1,              \"append_query_builder\": 2,          }          with pytest.raises(SystemExit):              Config._collector = IssueCollector()              Config.check()          assert len(Config._collector.errors) == 2          expected_error_message_1 = (              \"`write_query_builder` of DataNodeConfig `new` must be populated with a Callable function.\"              \" Current value of property `write_query_builder` is 1.\"          )          assert expected_error_message_1 in caplog.text          expected_error_message_2 = (              \"`append_query_builder` of DataNodeConfig `new` must be populated with a Callable function.\"              \" Current value of property `append_query_builder` is 2.\"          )          assert expected_error_message_2 in caplog.text            config._sections[DataNodeConfig.name][\"new\"].storage_type = \"generic\"          config._sections[DataNodeConfig.name][\"new\"].properties = {\"write_fct\": 12}          with pytest.raises(SystemExit):              Config._collector = IssueCollector()              Config.check()          assert len(Config._collector.errors) == 1          expected_error_messages = [              \"`write_fct` of DataNodeConfig `new` must be populated with a Callable function. Current value\"              \" of property `write_fct` is 12.\",          ]          assert all(message in caplog.text for message in expected_error_messages)            config._sections[DataNodeConfig.name][\"new\"].storage_type = \"generic\"          config._sections[DataNodeConfig.name][\"new\"].properties = {\"read_fct\": 5}          with pytest.raises(SystemExit):              Config._collector = IssueCollector()              Config.check()          assert len(Config._collector.errors) == 1          expected_error_messages = [              \"`read_fct` of DataNodeConfig `new` must be populated with a Callable function. Current value\"              \" of property `read_fct` is 5.\",          ]          assert all(message in caplog.text for message in expected_error_messages)            config._sections[DataNodeConfig.name][\"new\"].storage_type = \"generic\"          config._sections[DataNodeConfig.name][\"new\"].properties = {\"write_fct\": 9, \"read_fct\": 5}          with pytest.raises(SystemExit):              Config._collector = IssueCollector()              Config.check()          assert len(Config._collector.errors) == 2          expected_error_messages = [              \"`write_fct` of DataNodeConfig `new` must be populated with a Callable function. Current value\"              \" of property `write_fct` is 9.\",              \"`read_fct` of DataNodeConfig `new` must be populated with a Callable function. Current value\"              \" of property `read_fct` is 5.\",          ]          assert all(message in caplog.text for message in expected_error_messages)            config._sections[DataNodeConfig.name][\"new\"].storage_type = \"generic\"          config._sections[DataNodeConfig.name][\"new\"].properties = {\"write_fct\": print, \"read_fct\": 5}          with pytest.raises(SystemExit):              Config._collector = IssueCollector()              Config.check()          assert len(Config._collector.errors) == 1            config._sections[DataNodeConfig.name][\"new\"].storage_type = \"generic\"          config._sections[DataNodeConfig.name][\"new\"].properties = {\"write_fct\": 5, \"read_fct\": print}          with pytest.raises(SystemExit):              Config._collector = IssueCollector()              Config.check()          assert len(Config._collector.errors) == 1            config._sections[DataNodeConfig.name][\"new\"].storage_type = \"generic\"          config._sections[DataNodeConfig.name][\"new\"].properties = {\"write_fct\": print, \"read_fct\": print}          Config._collector = IssueCollector()          Config.check()          assert len(Config._collector.errors) == 0        def test_check_read_write_fct_args(self, caplog):          config = Config._applied_config          Config._compile_configs()            config._sections[DataNodeConfig.name][\"default\"].storage_type = \"generic\"          config._sections[DataNodeConfig.name][\"default\"].properties = {\"write_fct\": print, \"read_fct\": print}          Config._collector = IssueCollector()          Config.check()          assert len(Config._collector.errors) == 0            config._sections[DataNodeConfig.name][\"default\"].storage_type = \"generic\"          config._sections[DataNodeConfig.name][\"default\"].properties = {              \"write_fct\": print,              \"read_fct\": print,              \"write_fct_args\": \"foo\",          }          with pytest.raises(SystemExit):              Config._collector = IssueCollector()              Config.check()          assert len(Config._collector.errors) == 1          expected_error_message = (              \"`write_fct_args` field of DataNodeConfig `default` must be populated with a List value.\"              ' Current value of property `write_fct_args` is \"foo\".'          )          assert expected_error_message in caplog.text          config._sections[DataNodeConfig.name][\"default\"].storage_type = \"generic\"          config._sections[DataNodeConfig.name][\"default\"].properties = {              \"write_fct\": print,              \"read_fct\": print,              \"write_fct_args\": list(\"foo\"),          }          Config._collector = IssueCollector()          Config.check()          assert len(Config._collector.errors) == 0            config._sections[DataNodeConfig.name][\"default\"].storage_type = \"generic\"          config._sections[DataNodeConfig.name][\"default\"].properties = {              \"write_fct\": print,              \"read_fct\": print,              \"read_fct_args\": 1,          }          with pytest.raises(SystemExit):              Config._collector = IssueCollector()              Config.check()          assert len(Config._collector.errors) == 1          expected_error_message = (              \"`read_fct_args` field of DataNodeConfig `default` must be populated with a List value.\"              \" Current value of property `read_fct_args` is 1.\"          )          assert expected_error_message in caplog.text            config._sections[DataNodeConfig.name][\"default\"].storage_type = \"generic\"          config._sections[DataNodeConfig.name][\"default\"].properties = {              \"write_fct\": print,              \"read_fct\": print,              \"read_fct_args\": list(\"foo\"),          }          Config._collector = IssueCollector()          Config.check()          assert len(Config._collector.errors) == 0            config._sections[DataNodeConfig.name][\"default\"].storage_type = \"generic\"          config._sections[DataNodeConfig.name][\"default\"].properties = {              \"write_fct\": print,              \"read_fct\": print,              \"write_fct_args\": [\"foo\"],              \"read_fct_args\": [\"foo\"],          }          Config._collector = IssueCollector()          Config.check()          assert len(Config._collector.errors) == 0        def test_check_exposed_types(self, caplog):          config = Config._applied_config          Config._compile_configs()            config._sections[DataNodeConfig.name][\"default\"].storage_type = \"csv\"          config._sections[DataNodeConfig.name][\"default\"].properties = {\"exposed_type\": \"foo\"}          with pytest.raises(SystemExit):              Config._collector = IssueCollector()              Config.check()          assert len(Config._collector.errors) == 1          expected_error_message = (              'The `exposed_type` of DataNodeConfig `default` must be either \"pandas\", \"modin\"'              ', \"numpy\", or a custom type. Current value of property `exposed_type` is \"foo\".'          )          assert expected_error_message in caplog.text            config._sections[DataNodeConfig.name][\"default\"].properties = {\"exposed_type\": \"pandas\"}          Config._collector = IssueCollector()          Config.check()          assert len(Config._collector.errors) == 0            config._sections[DataNodeConfig.name][\"default\"].properties = {\"exposed_type\": \"modin\"}          Config._collector = IssueCollector()          Config.check()          assert len(Config._collector.errors) == 0            config._sections[DataNodeConfig.name][\"default\"].properties = {\"exposed_type\": \"numpy\"}          Config._collector = IssueCollector()          Config.check()          assert len(Config._collector.errors) == 0            config._sections[DataNodeConfig.name][\"default\"].properties = {\"exposed_type\": MyCustomClass}          Config.check()          assert len(Config._collector.errors) == 0 "}
{"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": "from copy import copy    import pytest    from src.taipy.core.config import ScenarioConfig  from src.taipy.core.config.data_node_config import DataNodeConfig  from src.taipy.core.config.task_config import TaskConfig  from taipy.config.checker.issue_collector import IssueCollector  from taipy.config.common.frequency import Frequency  from taipy.config.config import Config      def subtraction(n1, n2):      return n1 - n2      class TestScenarioConfigChecker:      def test_check_config_id(self, caplog):          Config._collector = IssueCollector()          config = Config._applied_config          Config._compile_configs()          Config.check()          assert len(Config._collector.errors) == 0          assert len(Config._collector.warnings) == 0          assert len(Config._collector.infos) == 0            config._sections[ScenarioConfig.name][\"new\"] = copy(config._sections[ScenarioConfig.name][\"default\"])          config._sections[ScenarioConfig.name][\"new\"].id = None          with pytest.raises(SystemExit):              Config._collector = IssueCollector()              Config.check()          assert len(Config._collector.errors) == 1          assert \"config_id of ScenarioConfig `None` is empty\" in caplog.text          assert len(Config._collector.warnings) == 1          assert \"tasks field of ScenarioConfig `new` is empty.\" in caplog.text          assert len(Config._collector.infos) == 0            caplog.clear()            config._sections[ScenarioConfig.name][\"new\"].id = \"new\"          Config._collector = IssueCollector()          Config.check()          assert len(Config._collector.errors) == 0          assert len(Config._collector.warnings) == 1          assert \"tasks field of ScenarioConfig `new` is empty.\" in caplog.text          assert len(Config._collector.infos) == 0        def test_check_if_entity_property_key_used_is_predefined(self, caplog):          Config._collector = IssueCollector()          config = Config._applied_config          Config._compile_configs()          Config.check()          assert len(Config._collector.errors) == 0            config._sections[ScenarioConfig.name][\"new\"] = copy(config._sections[ScenarioConfig.name][\"default\"])          config._sections[ScenarioConfig.name][\"new\"]._properties[\"_entity_owner\"] = None          with pytest.raises(SystemExit):              Config._collector = IssueCollector()              Config.check()          assert len(Config._collector.errors) == 1          assert \"Properties of ScenarioConfig `default` cannot have `_entity_owner` as its property.\" in caplog.text            config._sections[ScenarioConfig.name][\"new\"] = copy(config._sections[ScenarioConfig.name][\"default\"])          config._sections[ScenarioConfig.name][\"new\"]._properties[\"_entity_owner\"] = \"entity_owner\"          with pytest.raises(SystemExit):              Config._collector = IssueCollector()              Config.check()          assert len(Config._collector.errors) == 1          expected_error_message = (              \"Properties of ScenarioConfig `default` 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_task_configs(self, caplog):            Config._collector = IssueCollector()          config = Config._applied_config          Config._compile_configs()          Config.check()          assert len(Config._collector.errors) == 0          assert len(Config._collector.warnings) == 0          assert len(Config._collector.infos) == 0            config._sections[ScenarioConfig.name][\"new\"] = copy(config._sections[ScenarioConfig.name][\"default\"])          Config.check()          assert len(Config._collector.errors) == 0          assert len(Config._collector.warnings) == 1          assert \"tasks field of ScenarioConfig `new` is empty.\" in caplog.text          assert len(Config._collector.infos) == 0            config._sections[ScenarioConfig.name][\"new\"]._tasks = \"bar\"          with pytest.raises(SystemExit):              Config._collector = IssueCollector()              Config.check()          assert len(Config._collector.errors) == 1          expected_error_message = (              \"tasks field of ScenarioConfig `new` must be populated with a list of\"              ' TaskConfig objects. Current value of property `tasks` is \"bar\".'          )          assert expected_error_message in caplog.text          assert len(Config._collector.warnings) == 0          assert len(Config._collector.infos) == 0            config._sections[ScenarioConfig.name][\"new\"]._tasks = [\"bar\"]          with pytest.raises(SystemExit):              Config._collector = IssueCollector()              Config.check()          assert len(Config._collector.errors) == 1          expected_error_message = (              \"tasks field of ScenarioConfig `new` must be populated with a list of\"              \" TaskConfig objects. Current value of property `tasks` is ['bar'].\"          )          assert expected_error_message in caplog.text          assert len(Config._collector.warnings) == 0          assert len(Config._collector.infos) == 0            config._sections[ScenarioConfig.name][\"new\"]._tasks = [\"bar\", TaskConfig(\"bar\", print)]          with pytest.raises(SystemExit):              Config._collector = IssueCollector()              Config.check()          assert len(Config._collector.errors) == 1          expected_error_message = (              \"tasks field of ScenarioConfig `new` must be populated with a list of\"              \" TaskConfig objects. Current value of property `tasks` is\"              \" ['bar', <src.taipy.core.config.task_config.TaskConfig object at\"          )          assert expected_error_message in caplog.text          assert len(Config._collector.warnings) == 0          assert len(Config._collector.infos) == 0            config._sections[ScenarioConfig.name][\"new\"]._tasks = [TaskConfig(\"bar\", print)]          Config._collector = IssueCollector()          Config.check()          assert len(Config._collector.errors) == 0          assert len(Config._collector.warnings) == 0          assert len(Config._collector.infos) == 0        def test_check_additional_data_node_configs(self, caplog):            Config._collector = IssueCollector()          config = Config._applied_config          Config._compile_configs()          Config.check()          assert len(Config._collector.errors) == 0          assert len(Config._collector.warnings) == 0          assert len(Config._collector.infos) == 0            config._sections[ScenarioConfig.name][\"new\"] = copy(config._sections[ScenarioConfig.name][\"default\"])          config._sections[ScenarioConfig.name][\"new\"]._tasks = [TaskConfig(\"bar\", print)]          Config._collector = IssueCollector()          Config.check()          assert len(Config._collector.errors) == 0          assert len(Config._collector.warnings) == 0          assert len(Config._collector.infos) == 0            config._sections[ScenarioConfig.name][\"new\"]._additional_data_nodes = \"bar\"          with pytest.raises(SystemExit):              Config._collector = IssueCollector()              Config.check()          assert len(Config._collector.errors) == 1          expected_error_message = (              \"additional_data_nodes field of ScenarioConfig `new` must be populated with a list of\"              ' DataNodeConfig objects. Current value of property `additional_data_nodes` is \"bar\".'          )          assert expected_error_message in caplog.text          assert len(Config._collector.warnings) == 0          assert len(Config._collector.infos) == 0            config._sections[ScenarioConfig.name][\"new\"]._additional_data_nodes = [\"bar\"]          with pytest.raises(SystemExit):              Config._collector = IssueCollector()              Config.check()          assert len(Config._collector.errors) == 1          expected_error_message = (              \"additional_data_nodes field of ScenarioConfig `new` must be populated with a list of\"              \" DataNodeConfig objects. Current value of property `additional_data_nodes` is ['bar'].\"          )          assert expected_error_message in caplog.text          assert len(Config._collector.warnings) == 0          assert len(Config._collector.infos) == 0            config._sections[ScenarioConfig.name][\"new\"]._additional_data_nodes = [\"bar\", DataNodeConfig(\"bar\")]          with pytest.raises(SystemExit):              Config._collector = IssueCollector()              Config.check()          assert len(Config._collector.errors) == 1          expected_error_message = (              \"additional_data_nodes field of ScenarioConfig `new` must be populated with a list of\"              \" DataNodeConfig objects. Current value of property `additional_data_nodes` is\"              \" ['bar', <src.taipy.core.config.data_node_config.DataNodeConfig object at\"          )          assert expected_error_message in caplog.text          assert len(Config._collector.warnings) == 0          assert len(Config._collector.infos) == 0            config._sections[ScenarioConfig.name][\"new\"]._additional_data_nodes = [DataNodeConfig(\"bar\")]          Config._collector = IssueCollector()          Config.check()          assert len(Config._collector.errors) == 0          assert len(Config._collector.warnings) == 0          assert len(Config._collector.infos) == 0        def test_check_additional_data_node_configs_not_in_task_input_output_data_nodes(self, caplog):            Config._collector = IssueCollector()          config = Config._applied_config          Config._compile_configs()          Config.check()          assert len(Config._collector.errors) == 0          assert len(Config._collector.warnings) == 0          assert len(Config._collector.infos) == 0            input_dn_config = DataNodeConfig(\"input_dn\")          output_dn_config = DataNodeConfig(\"output_dn\")          config._sections[ScenarioConfig.name][\"new\"] = copy(config._sections[ScenarioConfig.name][\"default\"])          config._sections[ScenarioConfig.name][\"new\"]._tasks = [              TaskConfig(\"bar\", print, [input_dn_config], [output_dn_config])          ]          Config._collector = IssueCollector()          Config.check()          assert len(Config._collector.errors) == 0          assert len(Config._collector.warnings) == 0          assert len(Config._collector.infos) == 0            config._sections[ScenarioConfig.name][\"new\"]._additional_data_nodes = [input_dn_config]          Config._collector = IssueCollector()          Config.check()          assert len(Config._collector.warnings) == 1          expected_warning_message = (              \"The additional data node `input_dn` in additional_data_nodes field of ScenarioConfig \"              \"`new` has already existed as an input or output data node of ScenarioConfig `new` tasks.\"          )          assert expected_warning_message in caplog.text          assert len(Config._collector.errors) == 0          assert len(Config._collector.infos) == 0            config._sections[ScenarioConfig.name][\"new\"]._additional_data_nodes = [input_dn_config, output_dn_config]          Config._collector = IssueCollector()          Config.check()          assert len(Config._collector.warnings) == 2          expected_warning_message_1 = (              \"The additional data node `input_dn` in additional_data_nodes field of ScenarioConfig \"              \"`new` has already existed as an input or output data node of ScenarioConfig `new` tasks.\"          )          expected_warning_message_2 = (              \"The additional data node `output_dn` in additional_data_nodes field of ScenarioConfig \"              \"`new` has already existed as an input or output data node of ScenarioConfig `new` tasks.\"          )          assert expected_warning_message_1 in caplog.text          assert expected_warning_message_2 in caplog.text          assert len(Config._collector.errors) == 0          assert len(Config._collector.infos) == 0            config._sections[ScenarioConfig.name][\"new\"]._additional_data_nodes = [DataNodeConfig(\"bar\")]          Config._collector = IssueCollector()          Config.check()          assert len(Config._collector.errors) == 0          assert len(Config._collector.warnings) == 0          assert len(Config._collector.infos) == 0        def test_check_tasks_in_sequences_exist_in_scenario_tasks(self, caplog):            Config._collector = IssueCollector()          config = Config._applied_config          Config._compile_configs()          Config.check()          assert len(Config._collector.errors) == 0          assert len(Config._collector.warnings) == 0          assert len(Config._collector.infos) == 0            input_dn_config = DataNodeConfig(\"input_dn\")          output_dn_config = DataNodeConfig(\"output_dn\")          task_config_1 = TaskConfig(\"bar\", print, [input_dn_config], [output_dn_config])          task_config_2 = TaskConfig(\"baz\", print, [input_dn_config], [output_dn_config])          config._sections[ScenarioConfig.name][\"new\"] = copy(config._sections[ScenarioConfig.name][\"default\"])          config._sections[ScenarioConfig.name][\"new\"]._tasks = [task_config_1]          config._sections[ScenarioConfig.name][\"new\"].add_sequences({\"sequence_1\": [task_config_1]})          Config._collector = IssueCollector()          Config.check()          assert len(Config._collector.errors) == 0          assert len(Config._collector.warnings) == 0          assert len(Config._collector.infos) == 0            config._sections[ScenarioConfig.name][\"new\"].add_sequences({\"sequence_2\": [\"task_config\"]})          Config._collector = IssueCollector()          with pytest.raises(SystemExit):              Config.check()          assert len(Config._collector.errors) == 1          expected_error_messgae = (              \"sequences field of ScenarioConfig `new` must be populated with a list of\"              \" TaskConfig objects. Current value of property `sequences` is ['task_config'].\"          )          assert expected_error_messgae in caplog.text          assert len(Config._collector.warnings) == 0          assert len(Config._collector.infos) == 0            config._sections[ScenarioConfig.name][\"new\"].add_sequences({\"sequence_2\": [task_config_1, \"task_config_2\"]})          Config._collector = IssueCollector()          with pytest.raises(SystemExit):              Config.check()          assert len(Config._collector.errors) == 1          expected_error_messgae = (              \"sequences field of ScenarioConfig `new` must be populated with a list of\"              \" TaskConfig objects. Current value of property `sequences` is ['task_config'].\"          )          assert expected_error_messgae in caplog.text          assert len(Config._collector.warnings) == 0          assert len(Config._collector.infos) == 0            config._sections[ScenarioConfig.name][\"new\"].add_sequences({\"sequence_2\": [task_config_2]})          Config._collector = IssueCollector()          with pytest.raises(SystemExit):              Config.check()          assert len(Config._collector.errors) == 1          expected_error_messgae = (              \"The task `baz` in sequences field of ScenarioConfig\"              \" `new` must exist in tasks field of ScenarioConfig `new`.\"          )          assert expected_error_messgae in caplog.text          assert len(Config._collector.warnings) == 0          assert len(Config._collector.infos) == 0            config._sections[ScenarioConfig.name][\"new\"].add_sequences({\"sequence_2\": [task_config_1, task_config_2]})          Config._collector = IssueCollector()          with pytest.raises(SystemExit):              Config.check()          assert len(Config._collector.errors) == 1          expected_error_messgae = (              \"The task `baz` in sequences field of ScenarioConfig\"              \" `new` must exist in tasks field of ScenarioConfig `new`.\"          )          assert expected_error_messgae in caplog.text          assert len(Config._collector.warnings) == 0          assert len(Config._collector.infos) == 0            config._sections[ScenarioConfig.name][\"new\"]._tasks = [task_config_1, task_config_2]          Config._collector = IssueCollector()          Config.check()          assert len(Config._collector.errors) == 0          assert len(Config._collector.warnings) == 0          assert len(Config._collector.infos) == 0        def test_check_frequency(self, caplog):          config = Config._applied_config          Config._compile_configs()            config._sections[ScenarioConfig.name][\"default\"].frequency = \"bar\"          Config._collector = IssueCollector()          Config.check()          assert len(Config._collector.errors) == 0          assert len(Config._collector.warnings) == 0          assert len(Config._collector.infos) == 0            config._sections[ScenarioConfig.name][\"new\"] = copy(config._sections[ScenarioConfig.name][\"default\"])          with pytest.raises(SystemExit):              Config.check()          assert len(Config._collector.errors) == 1          expected_error_message = (              \"frequency field of ScenarioConfig `new` must be populated with a Frequency value.\"              ' Current value of property `frequency` is \"bar\".'          )          assert expected_error_message in caplog.text          assert len(Config._collector.warnings) == 1          assert len(Config._collector.infos) == 0            config._sections[ScenarioConfig.name][\"new\"].frequency = 1          with pytest.raises(SystemExit):              Config._collector = IssueCollector()              Config.check()          assert len(Config._collector.errors) == 1          expected_error_message = (              \"frequency field of ScenarioConfig `new` must be populated with a Frequency value.\"              \" Current value of property `frequency` is 1.\"          )          assert expected_error_message in caplog.text          assert len(Config._collector.warnings) == 1          assert len(Config._collector.infos) == 0            config._sections[ScenarioConfig.name][\"new\"].frequency = Frequency.DAILY          Config._collector = IssueCollector()          Config.check()          assert len(Config._collector.errors) == 0          assert len(Config._collector.warnings) == 1          assert len(Config._collector.infos) == 0        def test_check_comparators(self, caplog):          config = Config._applied_config          Config._compile_configs()            Config._collector = IssueCollector()          Config.check()          assert len(Config._collector.errors) == 0          assert len(Config._collector.warnings) == 0          assert len(Config._collector.infos) == 0            config._sections[ScenarioConfig.name][\"new\"] = copy(config._sections[ScenarioConfig.name][\"default\"])          Config.check()          assert len(Config._collector.errors) == 0          assert len(Config._collector.warnings) == 1          assert len(Config._collector.infos) == 0            config._sections[ScenarioConfig.name][\"new\"].comparators = [\"bar\"]          with pytest.raises(SystemExit):              Config._collector = IssueCollector()              Config.check()          assert len(Config._collector.warnings) == 1          assert len(Config._collector.infos) == 0          assert len(Config._collector.errors) == 1          expected_error_message = (              \"comparators field of ScenarioConfig `new` must be populated with a dictionary value.\"              \" Current value of property `comparators` is ['bar'].\"          )          assert expected_error_message in caplog.text            config._sections[ScenarioConfig.name][\"new\"].comparators = {\"bar\": 1}          with pytest.raises(SystemExit):              Config._collector = IssueCollector()              Config.check()          assert len(Config._collector.warnings) == 1          assert len(Config._collector.infos) == 0          assert len(Config._collector.errors) == 2          expected_data_node_id_error_message = (              \"The key `bar` in comparators field of ScenarioConfig `new` must be populated with a valid data node\"              \" configuration id. Current value of property `comparators` is {'bar': 1}.\"          )          assert expected_data_node_id_error_message in caplog.text          expected_comparator_error_message = (              \"The value of `bar` in comparators field of ScenarioConfig `new` must be populated with a list of\"              \" Callable values. Current value of property `comparators` is {'bar': 1}.\"          )          assert expected_comparator_error_message in caplog.text            Config.configure_data_node(\"foo\", \"in_memory\")          Config.configure_data_node(\"bar\", \"in_memory\")          config._sections[ScenarioConfig.name][\"new\"].comparators = {\"bar\": 1}          with pytest.raises(SystemExit):              Config._collector = IssueCollector()              Config.check()          assert len(Config._collector.warnings) == 1          assert len(Config._collector.infos) == 0          assert len(Config._collector.errors) == 1            config._sections[ScenarioConfig.name][\"new\"].comparators = {\"foo\": subtraction, \"bar\": [subtraction]}          Config._collector = IssueCollector()          Config.check()          assert len(Config._collector.warnings) == 1          assert len(Config._collector.infos) == 0          assert len(Config._collector.errors) == 0 "}
{"text": "from queue import SimpleQueue    from src.taipy.core import taipy as tp  from src.taipy.core.notification import EventEntityType, EventOperation  from src.taipy.core.notification._topic import _Topic  from src.taipy.core.notification.event import Event  from src.taipy.core.notification.notifier import Notifier  from taipy.config import Config, Frequency      def test_register():      def find_registration_and_topic(registration_id):          for topic, registrations in Notifier._topics_registrations_list.items():              for registration in registrations:                  if registration.registration_id == registration_id:                      return topic, registration        assert len(Notifier._topics_registrations_list) == 0        registration_id_0, register_queue_0 = Notifier.register()      topic_0, registration_0 = find_registration_and_topic(registration_id_0)        assert isinstance(registration_id_0, str) and registration_id_0 == registration_0.registration_id      assert isinstance(register_queue_0, SimpleQueue)      assert len(Notifier._topics_registrations_list.keys()) == 1      assert len(Notifier._topics_registrations_list[topic_0]) == 1      assert registration_0.queue == register_queue_0      assert register_queue_0 in [registration.queue for registration in Notifier._topics_registrations_list[topic_0]]        registration_id_1, register_queue_1 = Notifier.register()      topic_1, registration_1 = find_registration_and_topic(registration_id_1)        assert isinstance(registration_id_1, str) and registration_id_1 == registration_1.registration_id      assert isinstance(register_queue_1, SimpleQueue)      assert len(Notifier._topics_registrations_list.keys()) == 1      assert len(Notifier._topics_registrations_list[topic_1]) == 2      assert registration_1.queue == register_queue_1      assert register_queue_1 in [registration.queue for registration in Notifier._topics_registrations_list[topic_1]]        registration_id_2, register_queue_2 = Notifier.register(EventEntityType.SCENARIO)      topic_2, registration_2 = find_registration_and_topic(registration_id_2)        assert isinstance(registration_id_2, str) and registration_id_2 == registration_2.registration_id      assert isinstance(register_queue_2, SimpleQueue)      assert len(Notifier._topics_registrations_list.keys()) == 2      assert len(Notifier._topics_registrations_list[topic_2]) == 1      assert registration_2.queue == register_queue_2      assert register_queue_2 in [registration.queue for registration in Notifier._topics_registrations_list[topic_2]]        registration_id_3, register_queue_3 = Notifier.register(EventEntityType.SCENARIO, \"scenario_id\")      topic_3, registration_3 = find_registration_and_topic(registration_id_3)        assert isinstance(registration_id_3, str) and registration_id_3 == registration_3.registration_id      assert isinstance(register_queue_3, SimpleQueue)      assert len(Notifier._topics_registrations_list.keys()) == 3      assert len(Notifier._topics_registrations_list[topic_3]) == 1      assert registration_3.queue == register_queue_3      assert register_queue_3 in [registration.queue for registration in Notifier._topics_registrations_list[topic_3]]        registration_id_4, register_queue_4 = Notifier.register(          EventEntityType.SEQUENCE, \"sequence_id\", EventOperation.UPDATE, \"tasks\"      )      topic_4, registration_4 = find_registration_and_topic(registration_id_4)        assert isinstance(registration_id_4, str) and registration_id_4 == registration_4.registration_id      assert isinstance(register_queue_4, SimpleQueue)      assert len(Notifier._topics_registrations_list.keys()) == 4      assert len(Notifier._topics_registrations_list[topic_4]) == 1      assert registration_4.queue == register_queue_4      assert register_queue_4 in [registration.queue for registration in Notifier._topics_registrations_list[topic_4]]        registration_id_5, register_queue_5 = Notifier.register(EventEntityType.SCENARIO)      topic_5, registration_5 = find_registration_and_topic(registration_id_5)        assert isinstance(registration_id_5, str) and registration_id_5 == registration_5.registration_id      assert isinstance(register_queue_5, SimpleQueue)      assert len(Notifier._topics_registrations_list.keys()) == 4      assert len(Notifier._topics_registrations_list[topic_5]) == 2      assert registration_5.queue == register_queue_5      assert register_queue_5 in [registration.queue for registration in Notifier._topics_registrations_list[topic_5]]        registration_id_6, register_queue_6 = Notifier.register()      assert len(Notifier._topics_registrations_list.keys()) == 4      assert len(Notifier._topics_registrations_list[topic_0]) == 3        Notifier.unregister(registration_id_6)      assert len(Notifier._topics_registrations_list.keys()) == 4      assert len(Notifier._topics_registrations_list[topic_0]) == 2        Notifier.unregister(registration_id_4)      assert len(Notifier._topics_registrations_list.keys()) == 3      assert topic_4 not in Notifier._topics_registrations_list.keys()        Notifier.unregister(registration_id_0)      assert len(Notifier._topics_registrations_list.keys()) == 3      assert len(Notifier._topics_registrations_list[topic_0]) == 1        Notifier.unregister(registration_id_1)      assert len(Notifier._topics_registrations_list.keys()) == 2        print(Notifier._topics_registrations_list.keys())      assert all(topic not in Notifier._topics_registrations_list.keys() for topic in [topic_0, topic_1])        Notifier.unregister(registration_id_2)      Notifier.unregister(registration_id_3)      Notifier.unregister(registration_id_5)      assert len(Notifier._topics_registrations_list.keys()) == 0      def test_matching():      assert Notifier._is_matching(          Event(entity_type=EventEntityType.CYCLE, entity_id=\"cycle_id\", operation=EventOperation.CREATION), _Topic()      )      assert Notifier._is_matching(          Event(entity_type=EventEntityType.CYCLE, entity_id=\"cycle_id\", operation=EventOperation.CREATION),          _Topic(EventEntityType.CYCLE),      )      assert Notifier._is_matching(          Event(entity_type=EventEntityType.CYCLE, entity_id=\"cycle_id\", operation=EventOperation.CREATION),          _Topic(EventEntityType.CYCLE, \"cycle_id\"),      )      assert Notifier._is_matching(          Event(entity_type=EventEntityType.CYCLE, entity_id=\"cycle_id\", operation=EventOperation.CREATION),          _Topic(operation=EventOperation.CREATION),      )      assert Notifier._is_matching(          Event(entity_type=EventEntityType.CYCLE, entity_id=\"cycle_id\", operation=EventOperation.CREATION),          _Topic(EventEntityType.CYCLE, \"cycle_id\", EventOperation.CREATION),      )        assert Notifier._is_matching(          Event(entity_type=EventEntityType.SCENARIO, entity_id=\"scenario_id\", operation=EventOperation.SUBMISSION),          _Topic(),      )      assert Notifier._is_matching(          Event(entity_type=EventEntityType.SCENARIO, entity_id=\"scenario_id\", operation=EventOperation.SUBMISSION),          _Topic(EventEntityType.SCENARIO),      )      assert Notifier._is_matching(          Event(entity_type=EventEntityType.SCENARIO, entity_id=\"scenario_id\", operation=EventOperation.SUBMISSION),          _Topic(              EventEntityType.SCENARIO,              \"scenario_id\",          ),      )      assert Notifier._is_matching(          Event(entity_type=EventEntityType.SCENARIO, entity_id=\"scenario_id\", operation=EventOperation.SUBMISSION),          _Topic(operation=EventOperation.SUBMISSION),      )      assert Notifier._is_matching(          Event(entity_type=EventEntityType.SCENARIO, entity_id=\"scenario_id\", operation=EventOperation.SUBMISSION),          _Topic(EventEntityType.SCENARIO, \"scenario_id\", EventOperation.SUBMISSION),      )        assert Notifier._is_matching(          Event(              entity_type=EventEntityType.SEQUENCE,              entity_id=\"sequence_id\",              operation=EventOperation.UPDATE,              attribute_name=r\"tasks\",          ),          _Topic(),      )      assert Notifier._is_matching(          Event(              entity_type=EventEntityType.SEQUENCE,              entity_id=\"sequence_id\",              operation=EventOperation.UPDATE,              attribute_name=\"tasks\",          ),          _Topic(EventEntityType.SEQUENCE),      )      assert Notifier._is_matching(          Event(              entity_type=EventEntityType.SEQUENCE,              entity_id=\"sequence_id\",              operation=EventOperation.UPDATE,              attribute_name=\"tasks\",          ),          _Topic(              EventEntityType.SEQUENCE,              \"sequence_id\",          ),      )      assert Notifier._is_matching(          Event(              entity_type=EventEntityType.SEQUENCE,              entity_id=\"sequence_id\",              operation=EventOperation.UPDATE,              attribute_name=\"tasks\",          ),          _Topic(operation=EventOperation.UPDATE),      )      assert Notifier._is_matching(          Event(              entity_type=EventEntityType.SEQUENCE,              entity_id=\"sequence_id\",              operation=EventOperation.UPDATE,              attribute_name=\"tasks\",          ),          _Topic(EventEntityType.SEQUENCE, \"sequence_id\", EventOperation.UPDATE),      )      assert Notifier._is_matching(          Event(              entity_type=EventEntityType.SEQUENCE,              entity_id=\"sequence_id\",              operation=EventOperation.UPDATE,              attribute_name=\"tasks\",          ),          _Topic(attribute_name=\"tasks\"),      )      assert Notifier._is_matching(          Event(              entity_type=EventEntityType.SEQUENCE,              entity_id=\"sequence_id\",              operation=EventOperation.UPDATE,              attribute_name=\"tasks\",          ),          _Topic(EventEntityType.SEQUENCE, attribute_name=\"tasks\"),      )      assert Notifier._is_matching(          Event(              entity_type=EventEntityType.SEQUENCE,              entity_id=\"sequence_id\",              operation=EventOperation.UPDATE,              attribute_name=\"tasks\",          ),          _Topic(operation=EventOperation.UPDATE, attribute_name=\"tasks\"),      )      assert Notifier._is_matching(          Event(              entity_type=EventEntityType.SEQUENCE,              entity_id=\"sequence_id\",              operation=EventOperation.UPDATE,              attribute_name=\"tasks\",          ),          _Topic(EventEntityType.SEQUENCE, \"sequence_id\", EventOperation.UPDATE, \"tasks\"),      )      assert Notifier._is_matching(Event(EventEntityType.TASK, \"task_id\", EventOperation.DELETION), _Topic())      assert Notifier._is_matching(          Event(EventEntityType.TASK, \"task_id\", EventOperation.DELETION), _Topic(EventEntityType.TASK)      )      assert Notifier._is_matching(          Event(entity_type=EventEntityType.TASK, entity_id=\"task_id\", operation=EventOperation.DELETION),          _Topic(              EventEntityType.TASK,              \"task_id\",          ),      )      assert Notifier._is_matching(          Event(entity_type=EventEntityType.TASK, entity_id=\"task_id\", operation=EventOperation.DELETION),          _Topic(operation=EventOperation.DELETION),      )      assert Notifier._is_matching(          Event(entity_type=EventEntityType.TASK, entity_id=\"task_id\", operation=EventOperation.DELETION),          _Topic(EventEntityType.TASK, \"task_id\", EventOperation.DELETION),      )        assert not Notifier._is_matching(          Event(entity_type=EventEntityType.DATA_NODE, entity_id=\"dn_id\", operation=EventOperation.CREATION),          _Topic(EventEntityType.CYCLE),      )      assert not Notifier._is_matching(          Event(entity_type=EventEntityType.DATA_NODE, entity_id=\"dn_id\", operation=EventOperation.CREATION),          _Topic(EventEntityType.SCENARIO, \"scenario_id\"),      )      assert not Notifier._is_matching(          Event(entity_type=EventEntityType.DATA_NODE, entity_id=\"dn_id\", operation=EventOperation.CREATION),          _Topic(EventEntityType.TASK, \"task_id\", EventOperation.CREATION),      )      assert not Notifier._is_matching(          Event(entity_type=EventEntityType.JOB, entity_id=\"job_id\", operation=EventOperation.DELETION),          _Topic(EventEntityType.JOB, \"job_id\", EventOperation.CREATION),      )      assert not Notifier._is_matching(          Event(entity_type=EventEntityType.JOB, entity_id=\"job_id\", operation=EventOperation.DELETION),          _Topic(EventEntityType.JOB, \"job_id_1\", EventOperation.DELETION),      )      assert not Notifier._is_matching(          Event(              entity_type=EventEntityType.JOB,              entity_id=\"job_id\",              operation=EventOperation.UPDATE,              attribute_name=\"status\",          ),          _Topic(EventEntityType.JOB, \"job_id\", EventOperation.UPDATE, \"submit_id\"),      )      assert not Notifier._is_matching(          Event(              entity_type=EventEntityType.JOB,              entity_id=\"job_id\",              operation=EventOperation.UPDATE,              attribute_name=\"status\",          ),          _Topic(operation=EventOperation.UPDATE, attribute_name=\"submit_id\"),      )      def test_publish_creation_event():      _, registration_queue = Notifier.register()        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, flag=\"test\"      )      scenario_config.add_sequences({\"sequence_config\": [task_config]})        # Test CREATION Event        scenario = tp.create_scenario(scenario_config)      cycle = scenario.cycle      task = scenario.tasks[task_config.id]      dn = scenario.data_nodes[dn_config.id]      sequence = scenario.sequences[\"sequence_config\"]        assert registration_queue.qsize() == 5        published_events = []      while registration_queue.qsize() != 0:          published_events.append(registration_queue.get())        expected_event_types = [          EventEntityType.CYCLE,          EventEntityType.DATA_NODE,          EventEntityType.TASK,          EventEntityType.SEQUENCE,          EventEntityType.SCENARIO,      ]      expected_event_entity_id = [cycle.id, dn.id, task.id, sequence.id, scenario.id]        assert all(          [              event.entity_type == expected_event_types[i]              and event.entity_id == expected_event_entity_id[i]              and event.operation == EventOperation.CREATION              and event.attribute_name is None              for i, event in enumerate(published_events)          ]      )      def test_publish_update_event():      _, registration_queue = Notifier.register()        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, flag=\"test\"      )      scenario_config.add_sequences({\"sequence_config\": [task_config]})        scenario = tp.create_scenario(scenario_config)      cycle = scenario.cycle      task = scenario.tasks[task_config.id]      dn = scenario.data_nodes[dn_config.id]      sequence = scenario.sequences[\"sequence_config\"]        assert registration_queue.qsize() == 5      while registration_queue.qsize() > 0:          registration_queue.get()        # Test UPDATE Event        scenario.is_primary = False      assert registration_queue.qsize() == 1        tp.set_primary(scenario)      assert registration_queue.qsize() == 2        tp.subscribe_scenario(print, None, scenario=scenario)      assert registration_queue.qsize() == 3        tp.unsubscribe_scenario(print, None, scenario=scenario)      assert registration_queue.qsize() == 4        tp.tag(scenario, \"testing\")      assert registration_queue.qsize() == 5        tp.untag(scenario, \"testing\")      assert registration_queue.qsize() == 6        scenario.properties[\"flag\"] = \"production\"      assert registration_queue.qsize() == 7        scenario.properties.update({\"description\": \"a scenario\", \"test_mult\": True})      assert registration_queue.qsize() == 9        scenario.properties.pop(\"test_mult\")      assert registration_queue.qsize() == 10        scenario.name = \"my_scenario\"      assert registration_queue.qsize() == 11        cycle.name = \"new cycle name\"      assert registration_queue.qsize() == 12        cycle.properties[\"valid\"] = True      assert registration_queue.qsize() == 13        cycle.properties.update({\"re_run_periodically\": True})      assert registration_queue.qsize() == 14        cycle.properties.pop(\"re_run_periodically\")      assert registration_queue.qsize() == 15        sequence.properties[\"name\"] = \"weather_forecast\"      assert registration_queue.qsize() == 16        tp.subscribe_sequence(print, None, sequence)      assert registration_queue.qsize() == 17        tp.unsubscribe_sequence(print, None, sequence)      assert registration_queue.qsize() == 18        task.skippable = True      assert registration_queue.qsize() == 19        task.properties[\"number_of_run\"] = 2      assert registration_queue.qsize() == 20        task.properties.update({\"debug\": True})      assert registration_queue.qsize() == 21        task.properties.pop(\"debug\")      assert registration_queue.qsize() == 22        dn.editor_id = \"new editor id\"      assert registration_queue.qsize() == 23        dn.properties[\"sorted\"] = True      assert registration_queue.qsize() == 24        dn.properties.update({\"only_fetch_first_100\": True})      assert registration_queue.qsize() == 25        dn.properties.pop(\"only_fetch_first_100\")      assert registration_queue.qsize() == 26        published_events = []      while registration_queue.qsize() != 0:          published_events.append(registration_queue.get())        expected_event_types = [          EventEntityType.SCENARIO,          EventEntityType.SCENARIO,          EventEntityType.SCENARIO,          EventEntityType.SCENARIO,          EventEntityType.SCENARIO,          EventEntityType.SCENARIO,          EventEntityType.SCENARIO,          EventEntityType.SCENARIO,          EventEntityType.SCENARIO,          EventEntityType.SCENARIO,          EventEntityType.SCENARIO,          EventEntityType.CYCLE,          EventEntityType.CYCLE,          EventEntityType.CYCLE,          EventEntityType.CYCLE,          EventEntityType.SEQUENCE,          EventEntityType.SEQUENCE,          EventEntityType.SEQUENCE,          EventEntityType.TASK,          EventEntityType.TASK,          EventEntityType.TASK,          EventEntityType.TASK,          EventEntityType.DATA_NODE,          EventEntityType.DATA_NODE,          EventEntityType.DATA_NODE,          EventEntityType.DATA_NODE,      ]      expected_attribute_names = [          \"is_primary\",          \"is_primary\",          \"subscribers\",          \"subscribers\",          \"tags\",          \"tags\",          \"properties\",          \"properties\",          \"properties\",          \"properties\",          \"properties\",          \"name\",          \"properties\",          \"properties\",          \"properties\",          \"properties\",          \"subscribers\",          \"subscribers\",          \"skippable\",          \"properties\",          \"properties\",          \"properties\",          \"editor_id\",          \"properties\",          \"properties\",          \"properties\",      ]      expected_event_entity_id = [          scenario.id,          scenario.id,          scenario.id,          scenario.id,          scenario.id,          scenario.id,          scenario.id,          scenario.id,          scenario.id,          scenario.id,          scenario.id,          cycle.id,          cycle.id,          cycle.id,          cycle.id,          sequence.id,          sequence.id,          sequence.id,          task.id,          task.id,          task.id,          task.id,          dn.id,          dn.id,          dn.id,          dn.id,      ]        expected_event_operation_type = [EventOperation.UPDATE] * len(expected_event_types)        assert all(          [              event.entity_type == expected_event_types[i]              and event.entity_id == expected_event_entity_id[i]              and event.operation == expected_event_operation_type[i]              and event.attribute_name == expected_attribute_names[i]              for i, event in enumerate(published_events)          ]      )      def test_publish_update_event_in_context_manager():      _, registration_queue = Notifier.register()        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, flag=\"test\"      )      scenario_config.add_sequences({\"sequence_config\": [task_config]})        scenario = tp.create_scenario(scenario_config)      cycle = scenario.cycle      task = scenario.tasks[task_config.id]      dn = scenario.data_nodes[dn_config.id]      sequence = scenario.sequences[\"sequence_config\"]      scenario.properties.update({\"description\": \"a scenario\"})        assert registration_queue.qsize() == 6      while registration_queue.qsize() > 0:          registration_queue.get()        # Test UPDATE Event in Context Manager        assert registration_queue.qsize() == 0        # If multiple entities is in context, the last to enter will be the first to exit      # So the published event will have the order starting with scenario first and ending with dn      with dn as d, task as t, sequence as s, cycle as c, scenario as sc:          sc.is_primary = True          assert registration_queue.qsize() == 0            tp.set_primary(sc)          assert registration_queue.qsize() == 0            sc.properties[\"flag\"] = \"production\"          assert registration_queue.qsize() == 0            sc.properties.update({\"description\": \"a scenario\"})          assert registration_queue.qsize() == 0            sc.properties.pop(\"description\")          assert registration_queue.qsize() == 0            sc.name = \"my_scenario\"          assert registration_queue.qsize() == 0            c.name = \"another new cycle name\"          assert registration_queue.qsize() == 0            c.properties[\"valid\"] = True          assert registration_queue.qsize() == 0            c.properties.update({\"re_run_periodically\": True})          assert registration_queue.qsize() == 0            s.properties[\"name\"] = \"weather_forecast\"          assert registration_queue.qsize() == 0            t.skippable = True          assert registration_queue.qsize() == 0            t.properties[\"number_of_run\"] = 2          assert registration_queue.qsize() == 0            t.properties.update({\"debug\": True})          assert registration_queue.qsize() == 0            d.editor_id = \"another new editor id\"          assert registration_queue.qsize() == 0            d.properties[\"sorted\"] = True          assert registration_queue.qsize() == 0            d.properties.update({\"only_fetch_first_100\": True})          assert registration_queue.qsize() == 0        published_events = []        assert registration_queue.qsize() == 16      while registration_queue.qsize() != 0:          published_events.append(registration_queue.get())        expected_event_types = [          EventEntityType.SCENARIO,          EventEntityType.SCENARIO,          EventEntityType.SCENARIO,          EventEntityType.SCENARIO,          EventEntityType.SCENARIO,          EventEntityType.SCENARIO,          EventEntityType.CYCLE,          EventEntityType.CYCLE,          EventEntityType.CYCLE,          EventEntityType.SEQUENCE,          EventEntityType.TASK,          EventEntityType.TASK,          EventEntityType.TASK,          EventEntityType.DATA_NODE,          EventEntityType.DATA_NODE,          EventEntityType.DATA_NODE,      ]      expected_attribute_names = [          \"is_primary\",          \"is_primary\",          \"properties\",          \"properties\",          \"properties\",          \"properties\",          \"name\",          \"properties\",          \"properties\",          \"properties\",          \"skippable\",          \"properties\",          \"properties\",          \"editor_id\",          \"properties\",          \"properties\",      ]      expected_event_entity_id = [          scenario.id,          scenario.id,          scenario.id,          scenario.id,          scenario.id,          scenario.id,          cycle.id,          cycle.id,          cycle.id,          sequence.id,          task.id,          task.id,          task.id,          dn.id,          dn.id,          dn.id,      ]        assert all(          [              event.entity_type == expected_event_types[i]              and event.entity_id == expected_event_entity_id[i]              and event.operation == EventOperation.UPDATE              and event.attribute_name == expected_attribute_names[i]              for i, event in enumerate(published_events)          ]      )      def test_publish_submission_event():      _, registration_queue = Notifier.register()        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, flag=\"test\"      )      scenario_config.add_sequences({\"sequence_config\": [task_config]})      scenario = tp.create_scenario(scenario_config)        assert registration_queue.qsize() == 5      while registration_queue.qsize() > 0:          registration_queue.get()        # Test SUBMISSION Event        job = scenario.submit()[0]        assert registration_queue.qsize() == 6      published_events = []      while registration_queue.qsize() != 0:          published_events.append(registration_queue.get())        expected_operations = [          EventOperation.CREATION,          EventOperation.CREATION,          EventOperation.UPDATE,          EventOperation.UPDATE,          EventOperation.UPDATE,          EventOperation.SUBMISSION,      ]      expected_attribute_names = [None, None, \"jobs\", \"status\", \"submission_status\", None]      expected_event_types = [          EventEntityType.SUBMISSION,          EventEntityType.JOB,          EventEntityType.SUBMISSION,          EventEntityType.JOB,          EventEntityType.SUBMISSION,          EventEntityType.SCENARIO,      ]      expected_event_entity_id = [job.submit_id, job.id, job.submit_id, job.id, job.submit_id, scenario.id]      assert all(          [              event.entity_type == expected_event_types[i]              and event.entity_id == expected_event_entity_id[i]              and event.operation == expected_operations[i]              and event.attribute_name == expected_attribute_names[i]              for i, event in enumerate(published_events)          ]      )      def test_publish_deletion_event():      _, registration_queue = Notifier.register()        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, flag=\"test\"      )      scenario_config.add_sequences({\"sequence_config\": [task_config]})      scenario = tp.create_scenario(scenario_config)      cycle = scenario.cycle      task = scenario.tasks[task_config.id]      dn = scenario.data_nodes[dn_config.id]      sequence = scenario.sequences[\"sequence_config\"]      job = scenario.submit()[0]        assert registration_queue.qsize() == 11      while registration_queue.qsize() > 0:          registration_queue.get()        # Test DELETION Event        tp.delete(scenario.id)      assert registration_queue.qsize() == 7        published_events = []      while registration_queue.qsize() != 0:          published_events.append(registration_queue.get())        expected_event_types = [          EventEntityType.CYCLE,          EventEntityType.SEQUENCE,          EventEntityType.SCENARIO,          EventEntityType.TASK,          EventEntityType.JOB,          EventEntityType.DATA_NODE,          EventEntityType.SUBMISSION,      ]        expected_event_entity_id = [cycle.id, sequence.id, scenario.id, task.id, job.id, dn.id, job.submit_id]      expected_event_operation_type = [EventOperation.DELETION] * len(expected_event_types)        assert all(          [              event.entity_type == expected_event_types[i]              and event.entity_id == expected_event_entity_id[i]              and event.operation == expected_event_operation_type[i]              and event.attribute_name is None              for i, event in enumerate(published_events)          ]      )        scenario = tp.create_scenario(scenario_config)      cycle = scenario.cycle      assert registration_queue.qsize() == 5        # only to clear the queue      while registration_queue.qsize() != 0:          registration_queue.get()        tp.clean_all_entities_by_version()      assert registration_queue.qsize() == 5        published_events = []      while registration_queue.qsize() != 0:          published_events.append(registration_queue.get())        expected_event_types = [          EventEntityType.JOB,          EventEntityType.CYCLE,          EventEntityType.SCENARIO,          EventEntityType.TASK,          EventEntityType.DATA_NODE,      ]      expected_event_entity_id = [None, cycle.id, scenario.id, None, None]        assert all(          [              event.entity_type == expected_event_types[i]              and event.entity_id == expected_event_entity_id[i]              and event.operation == EventOperation.DELETION              and event.attribute_name is None              for i, event in enumerate(published_events)          ]      ) "}
{"text": "import pytest    from src.taipy.core.exceptions.exceptions import InvalidEventOperation  from src.taipy.core.notification._topic import _Topic  from src.taipy.core.notification.event import EventEntityType, EventOperation      def test_general_topic_creation():      topic_1 = _Topic(None, None, None, None)      assert topic_1.entity_type is None      assert topic_1.entity_id is None      assert topic_1.operation is None      assert topic_1.attribute_name is None        topic_2 = _Topic(EventEntityType.SCENARIO, \"scenario_id\")      assert topic_2.entity_type == EventEntityType.SCENARIO      assert topic_2.entity_id == \"scenario_id\"      assert topic_2.operation is None      assert topic_2.attribute_name is None        topic_3 = _Topic(None, None, EventOperation.CREATION)      assert topic_3.entity_type is None      assert topic_3.entity_id is None      assert topic_3.operation == EventOperation.CREATION      assert topic_3.attribute_name is None        topic_4 = _Topic(None, None, EventOperation.UPDATE, \"properties\")      assert topic_4.entity_type is None      assert topic_4.entity_id is None      assert topic_4.operation == EventOperation.UPDATE      assert topic_4.attribute_name == \"properties\"        topic_5 = _Topic(entity_type=EventEntityType.JOB, operation=EventOperation.DELETION)      assert topic_5.entity_type == EventEntityType.JOB      assert topic_5.entity_id is None      assert topic_5.operation == EventOperation.DELETION      assert topic_5.attribute_name is None        topic_6 = _Topic(entity_type=EventEntityType.SEQUENCE)      assert topic_6.entity_type == EventEntityType.SEQUENCE      assert topic_6.entity_id is None      assert topic_6.operation is None      assert topic_6.attribute_name is None      def test_topic_creation_cycle():      topic_1 = _Topic(EventEntityType.CYCLE, \"cycle_id\", EventOperation.CREATION)      assert topic_1.entity_type == EventEntityType.CYCLE      assert topic_1.entity_id == \"cycle_id\"      assert topic_1.operation == EventOperation.CREATION      assert topic_1.attribute_name is None        topic_2 = _Topic(EventEntityType.CYCLE, \"cycle_id\", EventOperation.UPDATE, \"frequency\")      assert topic_2.entity_type == EventEntityType.CYCLE      assert topic_2.entity_id == \"cycle_id\"      assert topic_2.operation == EventOperation.UPDATE      assert topic_2.attribute_name == \"frequency\"        topic_3 = _Topic(EventEntityType.CYCLE, \"cycle_id\", EventOperation.DELETION)      assert topic_3.entity_type == EventEntityType.CYCLE      assert topic_3.entity_id == \"cycle_id\"      assert topic_3.operation == EventOperation.DELETION      assert topic_3.attribute_name is None        topic_4 = _Topic(EventEntityType.CYCLE, \"cycle_id\", EventOperation.CREATION)      assert topic_4.entity_type == EventEntityType.CYCLE      assert topic_4.entity_id == \"cycle_id\"      assert topic_4.operation == EventOperation.CREATION      assert topic_4.attribute_name is None        # with pytest.raises(InvalidEventAttributeName):      #     _ = Topic(EventEntityType.CYCLE, \"cycle_id\", EventOperation.CREATION, \"frequency\")        # with pytest.raises(InvalidEventAttributeName):      #     _ = Topic(EventEntityType.CYCLE, \"cycle_id\", EventOperation.DELETION, \"frequency\")        # with pytest.raises(InvalidEventAttributeName):      #     _ = Topic(EventEntityType.CYCLE, \"cycle_id\", attribute_name=\"frequency\")        with pytest.raises(InvalidEventOperation):          _ = _Topic(EventEntityType.CYCLE, \"cycle_id\", EventOperation.SUBMISSION)        with pytest.raises(InvalidEventOperation):          _ = _Topic(EventEntityType.CYCLE, \"cycle_id\", EventOperation.SUBMISSION, \"frequency\")      def test_topic_creation_scenario():      topic_1 = _Topic(EventEntityType.SCENARIO, \"scenario_id\", EventOperation.CREATION)      assert topic_1.entity_type == EventEntityType.SCENARIO      assert topic_1.entity_id == \"scenario_id\"      assert topic_1.operation == EventOperation.CREATION      assert topic_1.attribute_name is None        topic_2 = _Topic(EventEntityType.SCENARIO, \"scenario_id\", EventOperation.UPDATE, \"is_primary\")      assert topic_2.entity_type == EventEntityType.SCENARIO      assert topic_2.entity_id == \"scenario_id\"      assert topic_2.operation == EventOperation.UPDATE      assert topic_2.attribute_name == \"is_primary\"        topic_3 = _Topic(EventEntityType.SCENARIO, \"scenario_id\", EventOperation.DELETION)      assert topic_3.entity_type == EventEntityType.SCENARIO      assert topic_3.entity_id == \"scenario_id\"      assert topic_3.operation == EventOperation.DELETION      assert topic_3.attribute_name is None        topic_4 = _Topic(EventEntityType.SCENARIO, \"scenario_id\", EventOperation.SUBMISSION)      assert topic_4.entity_type == EventEntityType.SCENARIO      assert topic_4.entity_id == \"scenario_id\"      assert topic_4.operation == EventOperation.SUBMISSION      assert topic_4.attribute_name is None        topic_5 = _Topic(EventEntityType.SCENARIO, \"scenario_id\", EventOperation.UPDATE, \"properties\")      assert topic_5.entity_type == EventEntityType.SCENARIO      assert topic_5.entity_id == \"scenario_id\"      assert topic_5.operation == EventOperation.UPDATE      assert topic_5.attribute_name == \"properties\"        # with pytest.raises(InvalidEventAttributeName):      #     _ = Topic(EventEntityType.SCENARIO, \"scenario_id\", EventOperation.CREATION, \"is_primary\")        # with pytest.raises(InvalidEventAttributeName):      #     _ = Topic(EventEntityType.SCENARIO, \"scenario_id\", EventOperation.DELETION, \"is_primary\")        # with pytest.raises(InvalidEventAttributeName):      #     _ = Topic(EventEntityType.SCENARIO, \"scenario_id\", EventOperation.SUBMISSION, \"is_primary\")        # with pytest.raises(InvalidEventAttributeName):      #     _ = Topic(EventEntityType.SCENARIO, \"scenario_id\", attribute_name=\"is_primary\")      def test_topic_creation_sequence():      topic_1 = _Topic(EventEntityType.SEQUENCE, \"sequence_id\", EventOperation.CREATION)      assert topic_1.entity_type == EventEntityType.SEQUENCE      assert topic_1.entity_id == \"sequence_id\"      assert topic_1.operation == EventOperation.CREATION      assert topic_1.attribute_name is None        topic_2 = _Topic(EventEntityType.SEQUENCE, \"sequence_id\", EventOperation.UPDATE, \"subscribers\")      assert topic_2.entity_type == EventEntityType.SEQUENCE      assert topic_2.entity_id == \"sequence_id\"      assert topic_2.operation == EventOperation.UPDATE      assert topic_2.attribute_name == \"subscribers\"        topic_3 = _Topic(EventEntityType.SEQUENCE, \"sequence_id\", EventOperation.DELETION)      assert topic_3.entity_type == EventEntityType.SEQUENCE      assert topic_3.entity_id == \"sequence_id\"      assert topic_3.operation == EventOperation.DELETION      assert topic_3.attribute_name is None        topic_4 = _Topic(EventEntityType.SEQUENCE, \"sequence_id\", EventOperation.SUBMISSION)      assert topic_4.entity_type == EventEntityType.SEQUENCE      assert topic_4.entity_id == \"sequence_id\"      assert topic_4.operation == EventOperation.SUBMISSION      assert topic_4.attribute_name is None        topic_5 = _Topic(EventEntityType.SEQUENCE, \"sequence_id\", EventOperation.DELETION)      assert topic_5.entity_type == EventEntityType.SEQUENCE      assert topic_5.entity_id == \"sequence_id\"      assert topic_5.operation == EventOperation.DELETION      assert topic_5.attribute_name is None        # with pytest.raises(InvalidEventAttributeName):      #     _ = Topic(EventEntityType.SEQUENCE, \"sequence_id\", EventOperation.CREATION, \"subscribers\")        # with pytest.raises(InvalidEventAttributeName):      #     _ = Topic(EventEntityType.SEQUENCE, \"sequence_id\", EventOperation.DELETION, \"subscribers\")        # with pytest.raises(InvalidEventAttributeName):      #     _ = Topic(EventEntityType.SEQUENCE, \"sequence_id\", EventOperation.SUBMISSION, \"subscribers\")        # with pytest.raises(InvalidEventAttributeName):      #     _ = Topic(EventEntityType.SEQUENCE, \"sequence_id\", attribute_name=\"subscribers\")      def test_topic_creation_task():      topic_1 = _Topic(EventEntityType.TASK, \"task_id\", EventOperation.CREATION)      assert topic_1.entity_type == EventEntityType.TASK      assert topic_1.entity_id == \"task_id\"      assert topic_1.operation == EventOperation.CREATION      assert topic_1.attribute_name is None        topic_2 = _Topic(EventEntityType.TASK, \"task_id\", EventOperation.UPDATE, \"function\")      assert topic_2.entity_type == EventEntityType.TASK      assert topic_2.entity_id == \"task_id\"      assert topic_2.operation == EventOperation.UPDATE      assert topic_2.attribute_name == \"function\"        topic_3 = _Topic(EventEntityType.TASK, \"task_id\", EventOperation.DELETION)      assert topic_3.entity_type == EventEntityType.TASK      assert topic_3.entity_id == \"task_id\"      assert topic_3.operation == EventOperation.DELETION      assert topic_3.attribute_name is None        topic_4 = _Topic(EventEntityType.TASK, \"task_id\", EventOperation.SUBMISSION)      assert topic_4.entity_type == EventEntityType.TASK      assert topic_4.entity_id == \"task_id\"      assert topic_4.operation == EventOperation.SUBMISSION      assert topic_4.attribute_name is None        topic_5 = _Topic(EventEntityType.TASK, \"task_id\", EventOperation.SUBMISSION)      assert topic_5.entity_type == EventEntityType.TASK      assert topic_5.entity_id == \"task_id\"      assert topic_5.operation == EventOperation.SUBMISSION      assert topic_5.attribute_name is None        # with pytest.raises(InvalidEventAttributeName):      #     _ = Topic(EventEntityType.TASK, \"task_id\", EventOperation.CREATION, \"function\")        # with pytest.raises(InvalidEventAttributeName):      #     _ = Topic(EventEntityType.TASK, \"task_id\", EventOperation.DELETION, \"function\")        # with pytest.raises(InvalidEventAttributeName):      #     _ = Topic(EventEntityType.TASK, \"task_id\", EventOperation.SUBMISSION, \"function\")        # with pytest.raises(InvalidEventAttributeName):      #     _ = Topic(EventEntityType.TASK, \"task_id\", attribute_name=\"function\")      def test_topic_creation_datanode():      topic_1 = _Topic(EventEntityType.DATA_NODE, \"dn_id\", EventOperation.CREATION)      assert topic_1.entity_type == EventEntityType.DATA_NODE      assert topic_1.entity_id == \"dn_id\"      assert topic_1.operation == EventOperation.CREATION      assert topic_1.attribute_name is None        topic_2 = _Topic(EventEntityType.DATA_NODE, \"dn_id\", EventOperation.UPDATE, \"properties\")      assert topic_2.entity_type == EventEntityType.DATA_NODE      assert topic_2.entity_id == \"dn_id\"      assert topic_2.operation == EventOperation.UPDATE      assert topic_2.attribute_name == \"properties\"        topic_3 = _Topic(EventEntityType.DATA_NODE, \"dn_id\", EventOperation.DELETION)      assert topic_3.entity_type == EventEntityType.DATA_NODE      assert topic_3.entity_id == \"dn_id\"      assert topic_3.operation == EventOperation.DELETION      assert topic_3.attribute_name is None        topic_4 = _Topic(None, \"dn_id\", EventOperation.UPDATE, \"scope\")      assert topic_4.entity_type is None      assert topic_4.entity_id == \"dn_id\"      assert topic_4.operation == EventOperation.UPDATE      assert topic_4.attribute_name == \"scope\"        # with pytest.raises(InvalidEventAttributeName):      #     _ = Topic(EventEntityType.DATA_NODE, \"dn_id\", EventOperation.CREATION, \"properties\")        # with pytest.raises(InvalidEventAttributeName):      #     _ = Topic(EventEntityType.DATA_NODE, \"dn_id\", EventOperation.DELETION, \"properties\")        # with pytest.raises(InvalidEventAttributeName):      #     _ = Topic(EventEntityType.DATA_NODE, \"dn_id\", attribute_name=\"properties\")        with pytest.raises(InvalidEventOperation):          _ = _Topic(EventEntityType.DATA_NODE, \"dn_id\", EventOperation.SUBMISSION)        # with pytest.raises(InvalidEventOperation):      #     _ = Topic(EventEntityType.DATA_NODE, \"dn_id\", EventOperation.SUBMISSION, \"properties\")      def test_topic_creation_job():      topic_1 = _Topic(EventEntityType.JOB, \"job_id\", EventOperation.CREATION)      assert topic_1.entity_type == EventEntityType.JOB      assert topic_1.entity_id == \"job_id\"      assert topic_1.operation == EventOperation.CREATION      assert topic_1.attribute_name is None        topic_2 = _Topic(EventEntityType.JOB, \"job_id\", EventOperation.UPDATE, \"force\")      assert topic_2.entity_type == EventEntityType.JOB      assert topic_2.entity_id == \"job_id\"      assert topic_2.operation == EventOperation.UPDATE      assert topic_2.attribute_name == \"force\"        topic_3 = _Topic(EventEntityType.JOB, \"job_id\", EventOperation.DELETION)      assert topic_3.entity_type == EventEntityType.JOB      assert topic_3.entity_id == \"job_id\"      assert topic_3.operation == EventOperation.DELETION      assert topic_3.attribute_name is None        topic_4 = _Topic(EventEntityType.JOB, \"job_id\", EventOperation.CREATION)      assert topic_4.entity_type == EventEntityType.JOB      assert topic_4.entity_id == \"job_id\"      assert topic_4.operation == EventOperation.CREATION      assert topic_4.attribute_name is None        # with pytest.raises(InvalidEventAttributeName):      #     _ = Topic(EventEntityType.JOB, \"job_id\", EventOperation.CREATION, \"force\")        # with pytest.raises(InvalidEventAttributeName):      #     _ = Topic(EventEntityType.JOB, \"job_id\", EventOperation.DELETION, \"force\")        # with pytest.raises(InvalidEventAttributeName):      #     _ = Topic(EventEntityType.JOB, \"job_id\", attribute_name=\"force\")        with pytest.raises(InvalidEventOperation):          _ = _Topic(EventEntityType.JOB, \"job_id\", EventOperation.SUBMISSION)        # with pytest.raises(InvalidEventOperation):      #     _ = Topic(EventEntityType.JOB, \"job_id\", EventOperation.SUBMISSION, \"force\")      def test_topic_equal():      assert _Topic() == _Topic()      assert _Topic(EventEntityType.SCENARIO) == _Topic(EventEntityType.SCENARIO)      assert _Topic(entity_id=\"sequence_id\") == _Topic(entity_id=\"sequence_id\")      assert _Topic(operation=EventOperation.SUBMISSION) == _Topic(operation=EventOperation.SUBMISSION)      assert _Topic(EventEntityType.JOB, \"JOB_id\", EventOperation.UPDATE, \"status\") == _Topic(          EventEntityType.JOB, \"JOB_id\", EventOperation.UPDATE, \"status\"      ) "}
{"text": "#  # Licensed under the Apache License, Version 2.0 (the \"License\"); you may not use this file except in compliance with  # the License. You may obtain a copy of the License at  #  #        http://www.apache.org/licenses/LICENSE-2.0  #  # Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on  # an \"AS IS\" BASIS, WITHOUT 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.exceptions.exceptions import InvalidEventAttributeName, InvalidEventOperation  from src.taipy.core.notification.event import Event, EventEntityType, EventOperation  from taipy.config.common.frequency import Frequency      def test_event_creation_cycle():      event_1 = Event(          entity_type=EventEntityType.CYCLE,          operation=EventOperation.CREATION,          entity_id=\"cycle_id\",      )      assert event_1.creation_date is not None      assert event_1.entity_type == EventEntityType.CYCLE      assert event_1.entity_id == \"cycle_id\"      assert event_1.operation == EventOperation.CREATION      assert event_1.attribute_name is None        event_2 = Event(          entity_type=EventEntityType.CYCLE,          operation=EventOperation.UPDATE,          entity_id=\"cycle_id\",          attribute_name=\"frequency\",          attribute_value=Frequency.DAILY,      )      assert event_2.creation_date is not None      assert event_2.entity_type == EventEntityType.CYCLE      assert event_2.entity_id == \"cycle_id\"      assert event_2.operation == EventOperation.UPDATE      assert event_2.attribute_name == \"frequency\"        event_3 = Event(entity_type=EventEntityType.CYCLE, entity_id=\"cycle_id\", operation=EventOperation.DELETION)      assert event_3.creation_date is not None      assert event_3.entity_type == EventEntityType.CYCLE      assert event_3.entity_id == \"cycle_id\"      assert event_3.operation == EventOperation.DELETION      assert event_3.attribute_name is None        with pytest.raises(InvalidEventAttributeName):          _ = Event(              entity_type=EventEntityType.CYCLE,              operation=EventOperation.CREATION,              entity_id=\"cycle_id\",              attribute_name=\"frequency\",          )        with pytest.raises(InvalidEventAttributeName):          _ = Event(EventEntityType.CYCLE, EventOperation.DELETION, entity_id=\"cycle_id\", attribute_name=\"frequency\")        with pytest.raises(InvalidEventOperation):          _ = Event(              entity_type=EventEntityType.CYCLE,              operation=EventOperation.SUBMISSION,              entity_id=\"cycle_id\",          )        with pytest.raises(InvalidEventOperation):          _ = Event(              entity_type=EventEntityType.CYCLE,              operation=EventOperation.SUBMISSION,              entity_id=\"cycle_id\",              attribute_name=\"frequency\",          )      def test_event_creation_scenario():      event_1 = Event(entity_type=EventEntityType.SCENARIO, entity_id=\"scenario_id\", operation=EventOperation.CREATION)      assert event_1.creation_date is not None      assert event_1.entity_type == EventEntityType.SCENARIO      assert event_1.entity_id == \"scenario_id\"      assert event_1.operation == EventOperation.CREATION      assert event_1.attribute_name is None        event_2 = Event(          entity_type=EventEntityType.SCENARIO,          entity_id=\"scenario_id\",          operation=EventOperation.UPDATE,          attribute_name=\"is_primary\",          attribute_value=True,      )      assert event_2.creation_date is not None      assert event_2.entity_type == EventEntityType.SCENARIO      assert event_2.entity_id == \"scenario_id\"      assert event_2.operation == EventOperation.UPDATE      assert event_2.attribute_name == \"is_primary\"      assert event_2.attribute_value is True        event_3 = Event(entity_type=EventEntityType.SCENARIO, entity_id=\"scenario_id\", operation=EventOperation.DELETION)      assert event_3.creation_date is not None      assert event_3.entity_type == EventEntityType.SCENARIO      assert event_3.entity_id == \"scenario_id\"      assert event_3.operation == EventOperation.DELETION      assert event_3.attribute_name is None        event_4 = Event(entity_type=EventEntityType.SCENARIO, entity_id=\"scenario_id\", operation=EventOperation.SUBMISSION)      assert event_4.creation_date is not None      assert event_4.entity_type == EventEntityType.SCENARIO      assert event_4.entity_id == \"scenario_id\"      assert event_4.operation == EventOperation.SUBMISSION      assert event_4.attribute_name is None        with pytest.raises(InvalidEventAttributeName):          _ = Event(              entity_type=EventEntityType.SCENARIO,              entity_id=\"scenario_id\",              operation=EventOperation.CREATION,              attribute_name=\"is_primary\",          )        with pytest.raises(InvalidEventAttributeName):          _ = Event(              entity_type=EventEntityType.SCENARIO,              entity_id=\"scenario_id\",              operation=EventOperation.DELETION,              attribute_name=\"is_primary\",          )        with pytest.raises(InvalidEventAttributeName):          _ = Event(              entity_type=EventEntityType.SCENARIO,              entity_id=\"scenario_id\",              operation=EventOperation.SUBMISSION,              attribute_name=\"is_primary\",          )      def test_event_creation_sequence():      event_1 = Event(entity_type=EventEntityType.SEQUENCE, entity_id=\"sequence_id\", operation=EventOperation.CREATION)      assert event_1.creation_date is not None      assert event_1.entity_type == EventEntityType.SEQUENCE      assert event_1.entity_id == \"sequence_id\"      assert event_1.operation == EventOperation.CREATION      assert event_1.attribute_name is None        event_2 = Event(          entity_type=EventEntityType.SEQUENCE,          entity_id=\"sequence_id\",          operation=EventOperation.UPDATE,          attribute_name=\"subscribers\",          attribute_value=object(),      )      assert event_2.creation_date is not None      assert event_2.entity_type == EventEntityType.SEQUENCE      assert event_2.entity_id == \"sequence_id\"      assert event_2.operation == EventOperation.UPDATE      assert event_2.attribute_name == \"subscribers\"        event_3 = Event(entity_type=EventEntityType.SEQUENCE, entity_id=\"sequence_id\", operation=EventOperation.DELETION)      assert event_3.creation_date is not None      assert event_3.entity_type == EventEntityType.SEQUENCE      assert event_3.entity_id == \"sequence_id\"      assert event_3.operation == EventOperation.DELETION      assert event_3.attribute_name is None        event_4 = Event(entity_type=EventEntityType.SEQUENCE, entity_id=\"sequence_id\", operation=EventOperation.SUBMISSION)      assert event_4.creation_date is not None      assert event_4.entity_type == EventEntityType.SEQUENCE      assert event_4.entity_id == \"sequence_id\"      assert event_4.operation == EventOperation.SUBMISSION      assert event_4.attribute_name is None        with pytest.raises(InvalidEventAttributeName):          _ = Event(              entity_type=EventEntityType.SEQUENCE,              entity_id=\"sequence_id\",              operation=EventOperation.CREATION,              attribute_name=\"subscribers\",          )        with pytest.raises(InvalidEventAttributeName):          _ = Event(              entity_type=EventEntityType.SEQUENCE,              entity_id=\"sequence_id\",              operation=EventOperation.DELETION,              attribute_name=\"subscribers\",          )        with pytest.raises(InvalidEventAttributeName):          _ = Event(              entity_type=EventEntityType.SEQUENCE,              entity_id=\"sequence_id\",              operation=EventOperation.SUBMISSION,              attribute_name=\"subscribers\",          )      def test_event_creation_task():      event_1 = Event(entity_type=EventEntityType.TASK, entity_id=\"task_id\", operation=EventOperation.CREATION)      assert event_1.creation_date is not None      assert event_1.entity_type == EventEntityType.TASK      assert event_1.entity_id == \"task_id\"      assert event_1.operation == EventOperation.CREATION      assert event_1.attribute_name is None        event_2 = Event(          entity_type=EventEntityType.TASK,          entity_id=\"task_id\",          operation=EventOperation.UPDATE,          attribute_name=\"function\",      )      assert event_2.creation_date is not None      assert event_2.entity_type == EventEntityType.TASK      assert event_2.entity_id == \"task_id\"      assert event_2.operation == EventOperation.UPDATE      assert event_2.attribute_name == \"function\"        event_3 = Event(entity_type=EventEntityType.TASK, entity_id=\"task_id\", operation=EventOperation.DELETION)      assert event_3.creation_date is not None      assert event_3.entity_type == EventEntityType.TASK      assert event_3.entity_id == \"task_id\"      assert event_3.operation == EventOperation.DELETION      assert event_3.attribute_name is None        event_4 = Event(entity_type=EventEntityType.TASK, entity_id=\"task_id\", operation=EventOperation.SUBMISSION)      assert event_4.creation_date is not None      assert event_4.entity_type == EventEntityType.TASK      assert event_4.entity_id == \"task_id\"      assert event_4.operation == EventOperation.SUBMISSION      assert event_4.attribute_name is None        with pytest.raises(InvalidEventAttributeName):          _ = Event(              entity_type=EventEntityType.TASK,              entity_id=\"task_id\",              operation=EventOperation.CREATION,              attribute_name=\"function\",          )        with pytest.raises(InvalidEventAttributeName):          _ = Event(              entity_type=EventEntityType.TASK,              entity_id=\"task_id\",              operation=EventOperation.DELETION,              attribute_name=\"function\",          )        with pytest.raises(InvalidEventAttributeName):          _ = Event(              entity_type=EventEntityType.TASK,              entity_id=\"task_id\",              operation=EventOperation.SUBMISSION,              attribute_name=\"function\",          )      def test_event_creation_datanode():      event_1 = Event(entity_type=EventEntityType.DATA_NODE, entity_id=\"dn_id\", operation=EventOperation.CREATION)      assert event_1.creation_date is not None      assert event_1.entity_type == EventEntityType.DATA_NODE      assert event_1.entity_id == \"dn_id\"      assert event_1.operation == EventOperation.CREATION      assert event_1.attribute_name is None        event_2 = Event(          entity_type=EventEntityType.DATA_NODE,          entity_id=\"dn_id\",          operation=EventOperation.UPDATE,          attribute_name=\"properties\",      )      assert event_2.creation_date is not None      assert event_2.entity_type == EventEntityType.DATA_NODE      assert event_2.entity_id == \"dn_id\"      assert event_2.operation == EventOperation.UPDATE      assert event_2.attribute_name == \"properties\"        event_3 = Event(entity_type=EventEntityType.DATA_NODE, entity_id=\"dn_id\", operation=EventOperation.DELETION)      assert event_3.creation_date is not None      assert event_3.entity_type == EventEntityType.DATA_NODE      assert event_3.entity_id == \"dn_id\"      assert event_3.operation == EventOperation.DELETION      assert event_3.attribute_name is None        with pytest.raises(InvalidEventAttributeName):          _ = Event(              entity_type=EventEntityType.DATA_NODE,              entity_id=\"dn_id\",              operation=EventOperation.CREATION,              attribute_name=\"properties\",          )        with pytest.raises(InvalidEventAttributeName):          _ = Event(              entity_type=EventEntityType.DATA_NODE,              entity_id=\"dn_id\",              operation=EventOperation.DELETION,              attribute_name=\"properties\",          )        with pytest.raises(InvalidEventOperation):          _ = Event(entity_type=EventEntityType.DATA_NODE, entity_id=\"dn_id\", operation=EventOperation.SUBMISSION)        with pytest.raises(InvalidEventOperation):          _ = Event(              entity_type=EventEntityType.DATA_NODE,              entity_id=\"dn_id\",              operation=EventOperation.SUBMISSION,              attribute_name=\"properties\",          )      def test_event_creation_job():      event_1 = Event(entity_type=EventEntityType.JOB, entity_id=\"job_id\", operation=EventOperation.CREATION)      assert event_1.creation_date is not None      assert event_1.entity_type == EventEntityType.JOB      assert event_1.entity_id == \"job_id\"      assert event_1.operation == EventOperation.CREATION      assert event_1.attribute_name is None        event_2 = Event(          entity_type=EventEntityType.JOB, entity_id=\"job_id\", operation=EventOperation.UPDATE, attribute_name=\"force\"      )      assert event_2.creation_date is not None      assert event_2.entity_type == EventEntityType.JOB      assert event_2.entity_id == \"job_id\"      assert event_2.operation == EventOperation.UPDATE      assert event_2.attribute_name == \"force\"        event_3 = Event(entity_type=EventEntityType.JOB, entity_id=\"job_id\", operation=EventOperation.DELETION)      assert event_3.creation_date is not None      assert event_3.entity_type == EventEntityType.JOB      assert event_3.entity_id == \"job_id\"      assert event_3.operation == EventOperation.DELETION      assert event_3.attribute_name is None        with pytest.raises(InvalidEventAttributeName):          _ = Event(              entity_type=EventEntityType.JOB,              entity_id=\"job_id\",              operation=EventOperation.CREATION,              attribute_name=\"force\",          )        with pytest.raises(InvalidEventAttributeName):          _ = Event(              entity_type=EventEntityType.JOB,              entity_id=\"job_id\",              operation=EventOperation.DELETION,              attribute_name=\"force\",          )        with pytest.raises(InvalidEventOperation):          _ = Event(entity_type=EventEntityType.JOB, entity_id=\"job_id\", operation=EventOperation.SUBMISSION)        with pytest.raises(InvalidEventOperation):          _ = Event(              entity_type=EventEntityType.JOB,              entity_id=\"job_id\",              operation=EventOperation.SUBMISSION,              attribute_name=\"force\",          ) "}
{"text": "from dataclasses import dataclass, field  from math import exp  from queue import SimpleQueue    from colorama import init    from src.taipy.core import taipy as tp  from src.taipy.core.config import scenario_config  from src.taipy.core.job.status import Status  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 Snapshot:      \"\"\"      A captured snapshot of the recording core events consumer.      \"\"\"        def __init__(self):          self.collected_events = []          self.entity_type_collected = {}          self.operation_collected = {}          self.attr_name_collected = {}        def capture_event(self, event):          self.collected_events.append(event)          self.entity_type_collected[event.entity_type] = self.entity_type_collected.get(event.entity_type, 0) + 1          self.operation_collected[event.operation] = self.operation_collected.get(event.operation, 0) + 1          if event.attribute_name:              self.attr_name_collected[event.attribute_name] = self.attr_name_collected.get(event.attribute_name, 0) + 1      class RecordingConsumer(CoreEventConsumerBase):      \"\"\"      A straightforward and no-thread core events consumer that allows to      capture snapshots of received events.      \"\"\"        def __init__(self, registration_id: str, queue: SimpleQueue):          super().__init__(registration_id, queue)        def capture(self) -> Snapshot:          \"\"\"          Capture a snapshot of events received between the previous snapshot          (or from the start of this consumer).          \"\"\"          snapshot = Snapshot()          while not self.queue.empty():              event = self.queue.get()              snapshot.capture_event(event)          return snapshot        def process_event(self, event: Event):          # Nothing todo          pass        def start(self):          # Nothing to do here          pass        def stop(self):          # Nothing to do here either          pass      def identity(x):      return x      def test_events_published_for_scenario_creation():      input_config = Config.configure_data_node(\"the_input\")      output_config = Config.configure_data_node(\"the_output\")      task_config = Config.configure_task(\"the_task\", identity, input=input_config, output=output_config)      sc_config = Config.configure_scenario(          \"the_scenario\", task_configs=[task_config], frequency=Frequency.DAILY, sequences={\"the_seq\": [task_config]}      )      register_id_0, register_queue_0 = Notifier.register()      all_evts = RecordingConsumer(register_id_0, register_queue_0)      all_evts.start()      # Create a scenario only trigger 6 creation events (for cycle, data node(x2), task, sequence and scenario)      tp.create_scenario(sc_config)      snapshot = all_evts.capture()        assert len(snapshot.collected_events) == 6      assert snapshot.entity_type_collected.get(EventEntityType.CYCLE, 0) == 1      assert snapshot.entity_type_collected.get(EventEntityType.DATA_NODE, 0) == 2      assert snapshot.entity_type_collected.get(EventEntityType.TASK, 0) == 1      assert snapshot.entity_type_collected.get(EventEntityType.SEQUENCE, 0) == 1      assert snapshot.entity_type_collected.get(EventEntityType.SCENARIO, 0) == 1      assert snapshot.operation_collected.get(EventOperation.CREATION, 0) == 6      all_evts.stop()      def test_no_event_published_for_getting_scenario():      input_config = Config.configure_data_node(\"the_input\")      output_config = Config.configure_data_node(\"the_output\")      task_config = Config.configure_task(\"the_task\", identity, input=input_config, output=output_config)      sc_config = Config.configure_scenario(          \"the_scenario\", task_configs=[task_config], frequency=Frequency.DAILY, sequences={\"the_seq\": [task_config]}      )      scenario = tp.create_scenario(sc_config)        register_id_0, register_queue_0 = Notifier.register()      all_evts = RecordingConsumer(register_id_0, register_queue_0)      all_evts.start()      # Get all scenarios does not trigger any event      tp.get_scenarios()      snapshot = all_evts.capture()        assert len(snapshot.collected_events) == 0        # Get one scenario does not trigger any event      tp.get(scenario.id)      snapshot = all_evts.capture()      assert len(snapshot.collected_events) == 0        all_evts.stop()      def test_events_published_for_writing_dn():      input_config = Config.configure_data_node(\"the_input\")      output_config = Config.configure_data_node(\"the_output\")      task_config = Config.configure_task(\"the_task\", identity, input=input_config, output=output_config)      sc_config = Config.configure_scenario(          \"the_scenario\", task_configs=[task_config], frequency=Frequency.DAILY, sequences={\"the_seq\": [task_config]}      )      scenario = tp.create_scenario(sc_config)      register_id_0, register_queue_0 = Notifier.register()      all_evts = RecordingConsumer(register_id_0, register_queue_0)      all_evts.start()        # Write input manually trigger 4 data node update events      # for last_edit_date, editor_id, editor_expiration_date and edit_in_progress      scenario.the_input.write(\"test\")      snapshot = all_evts.capture()      assert len(snapshot.collected_events) == 4      assert snapshot.entity_type_collected.get(EventEntityType.CYCLE, 0) == 0      assert snapshot.entity_type_collected.get(EventEntityType.DATA_NODE, 0) == 4      assert snapshot.entity_type_collected.get(EventEntityType.TASK, 0) == 0      assert snapshot.entity_type_collected.get(EventEntityType.SEQUENCE, 0) == 0      assert snapshot.entity_type_collected.get(EventEntityType.SCENARIO, 0) == 0      assert snapshot.operation_collected.get(EventOperation.CREATION, 0) == 0      assert snapshot.operation_collected.get(EventOperation.UPDATE, 0) == 4      all_evts.stop()      def test_events_published_for_scenario_submission():      input_config = Config.configure_data_node(\"the_input\")      output_config = Config.configure_data_node(\"the_output\")      task_config = Config.configure_task(\"the_task\", identity, input=input_config, output=output_config)      sc_config = Config.configure_scenario(          \"the_scenario\", task_configs=[task_config], frequency=Frequency.DAILY, sequences={\"the_seq\": [task_config]}      )      scenario = tp.create_scenario(sc_config)      scenario.the_input.write(\"test\")      register_id_0, register_queue_0 = Notifier.register()      all_evts = RecordingConsumer(register_id_0, register_queue_0)      all_evts.start()      # Submit a scenario triggers:      # 1 scenario submission event      # 7 dn update events (for last_edit_date, editor_id(x2), editor_expiration_date(x2) and edit_in_progress(x2))      # 1 job creation event      # 3 job update events (for status: PENDING, RUNNING and COMPLETED)      # 1 submission creation event      # 1 submission update event for jobs      # 3 submission update events (for status: PENDING, RUNNING and COMPLETED)      scenario.submit()      snapshot = all_evts.capture()      assert len(snapshot.collected_events) == 17      assert snapshot.entity_type_collected.get(EventEntityType.CYCLE, 0) == 0      assert snapshot.entity_type_collected.get(EventEntityType.DATA_NODE, 0) == 7      assert snapshot.entity_type_collected.get(EventEntityType.TASK, 0) == 0      assert snapshot.entity_type_collected.get(EventEntityType.SEQUENCE, 0) == 0      assert snapshot.entity_type_collected.get(EventEntityType.SCENARIO, 0) == 1      assert snapshot.entity_type_collected.get(EventEntityType.JOB, 0) == 4      assert snapshot.entity_type_collected.get(EventEntityType.SUBMISSION, 0) == 5      assert snapshot.operation_collected.get(EventOperation.CREATION, 0) == 2      assert snapshot.operation_collected.get(EventOperation.UPDATE, 0) == 14      assert snapshot.operation_collected.get(EventOperation.SUBMISSION, 0) == 1        assert snapshot.attr_name_collected[\"last_edit_date\"] == 1      assert snapshot.attr_name_collected[\"editor_id\"] == 2      assert snapshot.attr_name_collected[\"editor_expiration_date\"] == 2      assert snapshot.attr_name_collected[\"edit_in_progress\"] == 2      assert snapshot.attr_name_collected[\"status\"] == 3      assert snapshot.attr_name_collected[\"jobs\"] == 1      assert snapshot.attr_name_collected[\"submission_status\"] == 3        all_evts.stop()      def test_events_published_for_scenario_deletion():      input_config = Config.configure_data_node(\"the_input\")      output_config = Config.configure_data_node(\"the_output\")      task_config = Config.configure_task(\"the_task\", identity, input=input_config, output=output_config)      sc_config = Config.configure_scenario(          \"the_scenario\", task_configs=[task_config], frequency=Frequency.DAILY, sequences={\"the_seq\": [task_config]}      )      scenario = tp.create_scenario(sc_config)      scenario.the_input.write(\"test\")      scenario.submit()      register_id_0, register_queue_0 = Notifier.register()      all_evts = RecordingConsumer(register_id_0, register_queue_0)      all_evts.start()      # Delete a scenario trigger 8 deletion events      # 1 scenario deletion event      # 1 cycle deletion event      # 2 dn deletion events (for input and output)      # 1 task deletion event      # 1 sequence deletion event      # 1 job deletion event      # 1 submission deletion event      tp.delete(scenario.id)      snapshot = all_evts.capture()        assert len(snapshot.collected_events) == 8      assert snapshot.entity_type_collected.get(EventEntityType.CYCLE, 0) == 1      assert snapshot.entity_type_collected.get(EventEntityType.DATA_NODE, 0) == 2      assert snapshot.entity_type_collected.get(EventEntityType.TASK, 0) == 1      assert snapshot.entity_type_collected.get(EventEntityType.SEQUENCE, 0) == 1      assert snapshot.entity_type_collected.get(EventEntityType.SCENARIO, 0) == 1      assert snapshot.entity_type_collected.get(EventEntityType.SUBMISSION, 0) == 1      assert snapshot.entity_type_collected.get(EventEntityType.JOB, 0) == 1      assert snapshot.operation_collected.get(EventOperation.UPDATE, 0) == 0      assert snapshot.operation_collected.get(EventOperation.SUBMISSION, 0) == 0      assert snapshot.operation_collected.get(EventOperation.DELETION, 0) == 8        all_evts.stop()      def test_job_events():      input_config = Config.configure_data_node(\"the_input\")      output_config = Config.configure_data_node(\"the_output\")      task_config = Config.configure_task(\"the_task\", identity, input=input_config, output=output_config)      sc_config = Config.configure_scenario(          \"the_scenario\", task_configs=[task_config], frequency=Frequency.DAILY, sequences={\"the_seq\": [task_config]}      )      register_id, register_queue = Notifier.register(entity_type=EventEntityType.JOB)      consumer = RecordingConsumer(register_id, register_queue)      consumer.start()        # Create scenario      scenario = tp.create_scenario(sc_config)      snapshot = consumer.capture()      assert len(snapshot.collected_events) == 0        # Submit scenario      scenario.submit()      snapshot = consumer.capture()        # 2 events expected: one for creation, another for status update      assert len(snapshot.collected_events) == 2      assert snapshot.collected_events[0].operation == EventOperation.CREATION      assert snapshot.collected_events[0].entity_type == EventEntityType.JOB      assert snapshot.collected_events[0].metadata.get(\"task_config_id\") == task_config.id        assert snapshot.collected_events[1].operation == EventOperation.UPDATE      assert snapshot.collected_events[1].entity_type == EventEntityType.JOB      assert snapshot.collected_events[1].metadata.get(\"task_config_id\") == task_config.id      assert snapshot.collected_events[1].attribute_name == \"status\"      assert snapshot.collected_events[1].attribute_value == Status.BLOCKED        job = tp.get_jobs()[0]        tp.cancel_job(job)      snapshot = consumer.capture()      assert len(snapshot.collected_events) == 1      event = snapshot.collected_events[0]      assert event.metadata.get(\"task_config_id\") == task_config.id      assert event.attribute_name == \"status\"      assert event.attribute_value == Status.CANCELED        consumer.stop()      def test_scenario_events():      input_config = Config.configure_data_node(\"the_input\")      output_config = Config.configure_data_node(\"the_output\")      task_config = Config.configure_task(\"the_task\", identity, input=input_config, output=output_config)      sc_config = Config.configure_scenario(          \"the_scenario\", task_configs=[task_config], frequency=Frequency.DAILY, sequences={\"the_seq\": [task_config]}      )      register_id, register_queue = Notifier.register(entity_type=EventEntityType.SCENARIO)      consumer = RecordingConsumer(register_id, register_queue)      consumer.start()      scenario = tp.create_scenario(sc_config)        snapshot = consumer.capture()      assert len(snapshot.collected_events) == 1      assert snapshot.collected_events[0].operation == EventOperation.CREATION      assert snapshot.collected_events[0].entity_type == EventEntityType.SCENARIO      assert snapshot.collected_events[0].metadata.get(\"config_id\") == scenario.config_id        scenario.submit()      snapshot = consumer.capture()      assert len(snapshot.collected_events) == 1      assert snapshot.collected_events[0].operation == EventOperation.SUBMISSION      assert snapshot.collected_events[0].entity_type == EventEntityType.SCENARIO      assert snapshot.collected_events[0].metadata.get(\"config_id\") == scenario.config_id        # Delete scenario      tp.delete(scenario.id)      snapshot = consumer.capture()      assert len(snapshot.collected_events) == 1        assert snapshot.collected_events[0].operation == EventOperation.DELETION      assert snapshot.collected_events[0].entity_type == EventEntityType.SCENARIO        consumer.stop()      def test_data_node_events():      input_config = Config.configure_data_node(\"the_input\")      output_config = Config.configure_data_node(\"the_output\")      task_config = Config.configure_task(\"the_task\", identity, input=input_config, output=output_config)      sc_config = Config.configure_scenario(          \"the_scenario\", task_configs=[task_config], frequency=Frequency.DAILY, sequences={\"the_seq\": [task_config]}      )      register_id, register_queue = Notifier.register(entity_type=EventEntityType.DATA_NODE)      consumer = RecordingConsumer(register_id, register_queue)      consumer.start()        scenario = tp.create_scenario(sc_config)        snapshot = consumer.capture()      # We expect two creation events since we have two data nodes:      assert len(snapshot.collected_events) == 2        assert snapshot.collected_events[0].operation == EventOperation.CREATION      assert snapshot.collected_events[0].entity_type == EventEntityType.DATA_NODE      assert snapshot.collected_events[0].metadata.get(\"config_id\") in [output_config.id, input_config.id]        assert snapshot.collected_events[1].operation == EventOperation.CREATION      assert snapshot.collected_events[1].entity_type == EventEntityType.DATA_NODE      assert snapshot.collected_events[1].metadata.get(\"config_id\") in [output_config.id, input_config.id]        # Delete scenario      tp.delete(scenario.id)      snapshot = consumer.capture()      assert len(snapshot.collected_events) == 2        assert snapshot.collected_events[0].operation == EventOperation.DELETION      assert snapshot.collected_events[0].entity_type == EventEntityType.DATA_NODE        assert snapshot.collected_events[1].operation == EventOperation.DELETION      assert snapshot.collected_events[1].entity_type == EventEntityType.DATA_NODE        consumer.stop() "}
{"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": "#  # Licensed under the Apache License, Version 2.0 (the \"License\"); you may not use this file except in compliance with  # the License. You may obtain a copy of the License at  #  #        http://www.apache.org/licenses/LICENSE-2.0  #  # Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on  # an \"AS IS\" BASIS, WITHOUT 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 datetime  from datetime import timedelta    from src.taipy.core import CycleId  from src.taipy.core.cycle._cycle_manager import _CycleManager  from src.taipy.core.cycle.cycle import Cycle  from taipy.config.common.frequency import Frequency      def test_create_cycle_entity(current_datetime):      cycle_1 = Cycle(          Frequency.DAILY,          {\"key\": \"value\"},          creation_date=current_datetime,          start_date=current_datetime,          end_date=current_datetime,          name=\"foo\",      )      assert cycle_1.id is not None      assert cycle_1.name == \"foo\"      assert cycle_1.properties == {\"key\": \"value\"}      assert cycle_1.creation_date == current_datetime      assert cycle_1.start_date == current_datetime      assert cycle_1.end_date == current_datetime      assert cycle_1.key == \"value\"      assert cycle_1.frequency == Frequency.DAILY        cycle_2 = Cycle(Frequency.YEARLY, {}, current_datetime, current_datetime, current_datetime)      assert cycle_2.name == current_datetime.strftime(\"%Y\")      assert cycle_2.frequency == Frequency.YEARLY        cycle_3 = Cycle(Frequency.MONTHLY, {}, current_datetime, current_datetime, current_datetime)      assert cycle_3.name == current_datetime.strftime(\"%B %Y\")      assert cycle_3.frequency == Frequency.MONTHLY        cycle_4 = Cycle(Frequency.WEEKLY, {}, current_datetime, current_datetime, current_datetime)      assert cycle_4.name == current_datetime.strftime(\"Week %W %Y, from %d. %B\")      assert cycle_4.frequency == Frequency.WEEKLY        cycle_5 = Cycle(Frequency.DAILY, {}, current_datetime, current_datetime, current_datetime)      assert cycle_5.name == current_datetime.strftime(\"%A, %d. %B %Y\")      assert cycle_5.frequency == Frequency.DAILY      def test_cycle_name(current_datetime):      start_date = datetime.datetime(2023, 1, 2)      cycle = Cycle(Frequency.DAILY, {}, current_datetime, start_date, start_date, \"name\", CycleId(\"id\"))      assert cycle.name == \"name\"      cycle = Cycle(Frequency.DAILY, {}, current_datetime, start_date, start_date, None, CycleId(\"id\"))      assert cycle.name == \"Monday, 02. January 2023\"      cycle = Cycle(Frequency.WEEKLY, {}, current_datetime, start_date, start_date, None, CycleId(\"id\"))      assert cycle.name == \"Week 01 2023, from 02. January\"      cycle = Cycle(Frequency.MONTHLY, {}, current_datetime, start_date, start_date, None, CycleId(\"id\"))      assert cycle.name == \"January 2023\"      cycle = Cycle(Frequency.QUARTERLY, {}, current_datetime, start_date, start_date, None, CycleId(\"id\"))      assert cycle.name == \"2023 Q1\"      cycle = Cycle(Frequency.YEARLY, {}, current_datetime, start_date, start_date, None, CycleId(\"id\"))      assert cycle.name == \"2023\"      def test_cycle_label(current_datetime):      cycle = Cycle(          Frequency.DAILY,          {\"key\": \"value\"},          creation_date=current_datetime,          start_date=current_datetime,          end_date=current_datetime,      )      assert cycle.get_label() == cycle.name      assert cycle.get_simple_label() == cycle.name        cycle._properties[\"label\"] = \"label\"      assert cycle.get_label() == \"label\"      assert cycle.get_simple_label() == \"label\"      def test_add_property_to_scenario(current_datetime):      cycle = Cycle(          Frequency.WEEKLY,          {\"key\": \"value\"},          current_datetime,          current_datetime,          current_datetime,          name=\"foo\",      )      assert cycle.properties == {\"key\": \"value\"}      assert cycle.key == \"value\"        cycle.properties[\"new_key\"] = \"new_value\"        assert cycle.properties == {\"key\": \"value\", \"new_key\": \"new_value\"}      assert cycle.key == \"value\"      assert cycle.new_key == \"new_value\"      def test_auto_set_and_reload(current_datetime):      cycle_1 = Cycle(          Frequency.WEEKLY,          {\"key\": \"value\"},          current_datetime,          current_datetime,          current_datetime,          name=\"foo\",      )        _CycleManager._set(cycle_1)      cycle_2 = _CycleManager._get(cycle_1)        # auto set & reload on frequency attribute      assert cycle_1.frequency == Frequency.WEEKLY      cycle_1.frequency = Frequency.YEARLY      assert cycle_1.frequency == Frequency.YEARLY      assert cycle_2.frequency == Frequency.YEARLY      cycle_2.frequency = Frequency.MONTHLY      assert cycle_1.frequency == Frequency.MONTHLY      assert cycle_2.frequency == Frequency.MONTHLY        new_datetime_1 = current_datetime + timedelta(1)      new_datetime_2 = current_datetime + timedelta(2)        # auto set & reload on creation_date attribute      assert cycle_1.creation_date == current_datetime      assert cycle_2.creation_date == current_datetime      cycle_1.creation_date = new_datetime_1      assert cycle_1.creation_date == new_datetime_1      assert cycle_2.creation_date == new_datetime_1      cycle_2.creation_date = new_datetime_2      assert cycle_1.creation_date == new_datetime_2      assert cycle_2.creation_date == new_datetime_2        # auto set & reload on start_date attribute      assert cycle_1.start_date == current_datetime      assert cycle_2.start_date == current_datetime      cycle_1.start_date = new_datetime_1      assert cycle_1.start_date == new_datetime_1      assert cycle_2.start_date == new_datetime_1      cycle_2.start_date = new_datetime_2      assert cycle_1.start_date == new_datetime_2      assert cycle_2.start_date == new_datetime_2        # auto set & reload on end_date attribute      assert cycle_1.end_date == current_datetime      assert cycle_2.end_date == current_datetime      cycle_1.end_date = new_datetime_1      assert cycle_1.end_date == new_datetime_1      assert cycle_2.end_date == new_datetime_1      cycle_2.end_date = new_datetime_2      assert cycle_1.end_date == new_datetime_2      assert cycle_2.end_date == new_datetime_2        # auto set & reload on names attribute      assert cycle_1.name == \"foo\"      assert cycle_2.name == \"foo\"      cycle_1.name = \"fed\"      assert cycle_1.name == \"fed\"      assert cycle_2.name == \"fed\"      cycle_2.name = \"def\"      assert cycle_1.name == \"def\"      assert cycle_2.name == \"def\"        # auto set & reload on properties attribute      assert cycle_1.properties == {\"key\": \"value\"}      assert cycle_2.properties == {\"key\": \"value\"}      cycle_1._properties[\"qux\"] = 4      assert cycle_1.properties[\"qux\"] == 4      assert cycle_2.properties[\"qux\"] == 4        assert cycle_1.properties == {\"key\": \"value\", \"qux\": 4}      assert cycle_2.properties == {\"key\": \"value\", \"qux\": 4}      cycle_2._properties[\"qux\"] = 5      assert cycle_1.properties[\"qux\"] == 5      assert cycle_2.properties[\"qux\"] == 5        cycle_1.properties[\"temp_key_1\"] = \"temp_value_1\"      cycle_1.properties[\"temp_key_2\"] = \"temp_value_2\"      assert cycle_1.properties == {          \"qux\": 5,          \"key\": \"value\",          \"temp_key_1\": \"temp_value_1\",          \"temp_key_2\": \"temp_value_2\",      }      assert cycle_2.properties == {          \"qux\": 5,          \"key\": \"value\",          \"temp_key_1\": \"temp_value_1\",          \"temp_key_2\": \"temp_value_2\",      }      cycle_1.properties.pop(\"temp_key_1\")      assert \"temp_key_1\" not in cycle_1.properties.keys()      assert \"temp_key_1\" not in cycle_1.properties.keys()      assert cycle_1.properties == {          \"key\": \"value\",          \"qux\": 5,          \"temp_key_2\": \"temp_value_2\",      }      assert cycle_2.properties == {          \"key\": \"value\",          \"qux\": 5,          \"temp_key_2\": \"temp_value_2\",      }      cycle_2.properties.pop(\"temp_key_2\")      assert cycle_1.properties == {\"key\": \"value\", \"qux\": 5}      assert cycle_2.properties == {\"key\": \"value\", \"qux\": 5}      assert \"temp_key_2\" not in cycle_1.properties.keys()      assert \"temp_key_2\" not in cycle_2.properties.keys()        cycle_1.properties[\"temp_key_3\"] = 0      assert cycle_1.properties == {\"key\": \"value\", \"qux\": 5, \"temp_key_3\": 0}      assert cycle_2.properties == {\"key\": \"value\", \"qux\": 5, \"temp_key_3\": 0}      cycle_1.properties.update({\"temp_key_3\": 1})      assert cycle_1.properties == {\"key\": \"value\", \"qux\": 5, \"temp_key_3\": 1}      assert cycle_2.properties == {\"key\": \"value\", \"qux\": 5, \"temp_key_3\": 1}      cycle_1.properties.update(dict())      assert cycle_1.properties == {\"key\": \"value\", \"qux\": 5, \"temp_key_3\": 1}      assert cycle_2.properties == {\"key\": \"value\", \"qux\": 5, \"temp_key_3\": 1}      cycle_1.properties.pop(\"key\")      cycle_1.properties[\"temp_key_4\"] = 0      cycle_1.properties[\"temp_key_5\"] = 0        new_datetime_3 = new_datetime_1 + timedelta(5)      with cycle_1 as cycle:          assert cycle.frequency == Frequency.MONTHLY          assert cycle.creation_date == new_datetime_2          assert cycle.start_date == new_datetime_2          assert cycle.end_date == new_datetime_2          assert cycle.name == \"def\"          assert cycle._is_in_context          assert cycle.properties[\"qux\"] == 5          assert cycle.properties[\"temp_key_3\"] == 1          assert cycle.properties[\"temp_key_4\"] == 0          assert cycle.properties[\"temp_key_5\"] == 0            cycle.frequency = Frequency.YEARLY          cycle.creation_date = new_datetime_3          cycle.start_date = new_datetime_3          cycle.end_date = new_datetime_3          cycle.name = \"abc\"          assert cycle.name == \"def\"          assert cycle._name == \"abc\"          cycle.properties[\"qux\"] = 9          cycle.properties.pop(\"temp_key_3\")          cycle.properties.pop(\"temp_key_4\")          cycle.properties.update({\"temp_key_4\": 1})          cycle.properties.update({\"temp_key_5\": 2})          cycle.properties.pop(\"temp_key_5\")          cycle.properties.update(dict())            assert cycle.frequency == Frequency.MONTHLY          assert cycle.creation_date == new_datetime_2          assert cycle.start_date == new_datetime_2          assert cycle.end_date == new_datetime_2          assert cycle._is_in_context          assert cycle.properties[\"qux\"] == 5          assert cycle.name == \"def\"          assert cycle.properties[\"temp_key_3\"] == 1          assert cycle.properties[\"temp_key_4\"] == 0          assert cycle.properties[\"temp_key_5\"] == 0        assert cycle_1.frequency == Frequency.YEARLY      assert cycle_1.creation_date == new_datetime_3      assert cycle_1.start_date == new_datetime_3      assert cycle_1.end_date == new_datetime_3      assert cycle_1.name == \"abc\"      assert cycle_1.properties[\"qux\"] == 9      assert \"temp_key_3\" not in cycle_1.properties.keys()      assert cycle_1.properties[\"temp_key_4\"] == 1      assert \"temp_key_5\" not in cycle_1.properties.keys() "}
{"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": "from datetime import datetime    from src.taipy.core._orchestrator._orchestrator_factory import _OrchestratorFactory  from src.taipy.core.config.job_config import JobConfig  from src.taipy.core.cycle._cycle_manager import _CycleManager  from src.taipy.core.cycle.cycle import Cycle  from src.taipy.core.cycle.cycle_id import CycleId  from src.taipy.core.data._data_manager import _DataManager  from src.taipy.core.job._job_manager import _JobManager  from src.taipy.core.scenario._scenario_manager import _ScenarioManager  from src.taipy.core.sequence._sequence_manager import _SequenceManager  from src.taipy.core.task._task_manager import _TaskManager  from taipy.config.common.frequency import Frequency  from taipy.config.common.scope import Scope  from taipy.config.config import Config      def test_save_and_get_cycle_entity(tmpdir, cycle, current_datetime):      _CycleManager._repository.base_path = tmpdir        assert len(_CycleManager._get_all()) == 0        _CycleManager._set(cycle)      assert _CycleManager._exists(cycle.id)        cycle_1 = _CycleManager._get(cycle.id)        assert cycle_1.id == cycle.id      assert cycle_1.name == cycle.name      assert cycle_1.properties == cycle.properties      assert cycle_1.creation_date == cycle.creation_date      assert cycle_1.start_date == cycle.start_date      assert cycle_1.end_date == cycle.end_date      assert cycle_1.frequency == cycle.frequency        assert len(_CycleManager._get_all()) == 1      assert _CycleManager._get(cycle.id) == cycle      assert _CycleManager._get(cycle.id).name == cycle.name      assert isinstance(_CycleManager._get(cycle.id).creation_date, datetime)      assert _CycleManager._get(cycle.id).creation_date == cycle.creation_date      assert _CycleManager._get(cycle.id).frequency == Frequency.DAILY        cycle_2_id = CycleId(\"cycle_2\")      assert _CycleManager._get(cycle_2_id) is None      assert not _CycleManager._exists(cycle_2_id)        cycle_3 = Cycle(          Frequency.MONTHLY,          {},          creation_date=current_datetime,          start_date=current_datetime,          end_date=current_datetime,          name=\"bar\",          id=cycle_1.id,      )      _CycleManager._set(cycle_3)        cycle_3 = _CycleManager._get(cycle_1.id)        assert _CycleManager._exists(cycle_1.id)      assert len(_CycleManager._get_all()) == 1      assert cycle_3.id == cycle_1.id      assert cycle_3.name == cycle_3.name      assert cycle_3.properties == cycle_3.properties      assert cycle_3.creation_date == current_datetime      assert cycle_3.start_date == current_datetime      assert cycle_3.end_date == current_datetime      assert cycle_3.frequency == cycle_3.frequency      def test_create_and_delete_cycle_entity(tmpdir):      _CycleManager._repository.base_path = tmpdir        assert len(_CycleManager._get_all()) == 0        cycle_1 = _CycleManager._create(Frequency.DAILY, name=\"foo\", key=\"value\")        assert cycle_1.id is not None      assert cycle_1.name == \"foo\"      assert cycle_1.properties == {\"key\": \"value\"}      assert cycle_1.creation_date is not None      assert cycle_1.start_date is not None      assert cycle_1.end_date is not None      assert cycle_1.start_date < cycle_1.creation_date < cycle_1.end_date      assert cycle_1.key == \"value\"      assert cycle_1.frequency == Frequency.DAILY        cycle_1_id = cycle_1.id        assert _CycleManager._exists(cycle_1.id)      assert len(_CycleManager._get_all()) == 1      assert _CycleManager._get(cycle_1_id) == cycle_1      assert _CycleManager._get(cycle_1_id).name == \"foo\"      assert isinstance(_CycleManager._get(cycle_1_id).creation_date, datetime)      assert _CycleManager._get(cycle_1_id).frequency == Frequency.DAILY        cycle_2_id = CycleId(\"cycle_2\")      assert _CycleManager._get(cycle_2_id) is None      assert not _CycleManager._exists(cycle_2_id)        cycle_3 = _CycleManager._create(Frequency.MONTHLY, \"bar\")        assert cycle_3.id is not None      assert cycle_3.name == \"bar\"      assert isinstance(cycle_3.creation_date, datetime)      assert cycle_3.frequency == Frequency.MONTHLY        cycle_3_id = cycle_3.id        assert _CycleManager._exists(cycle_3_id)      assert len(_CycleManager._get_all()) == 2      assert _CycleManager._get(cycle_3_id).name == \"bar\"        cycle_4 = _CycleManager._create(Frequency.YEARLY, \"baz\")      cycle_4_id = cycle_4.id        assert _CycleManager._exists(cycle_4_id)      assert len(_CycleManager._get_all()) == 3        _CycleManager._delete(cycle_4_id)        assert len(_CycleManager._get_all()) == 2      assert not _CycleManager._exists(cycle_4_id)      assert _CycleManager._get(cycle_4_id) is None        _CycleManager._delete_all()      assert len(_CycleManager._get_all()) == 0      assert not any(_CycleManager._exists(cycle_id) for cycle_id in [cycle_1_id, cycle_3_id, cycle_4_id])      def test_get_cycle_start_date_and_end_date():      creation_date_1 = datetime.fromisoformat(\"2021-11-11T11:11:01.000001\")        daily_start_date_1 = _CycleManager._get_start_date_of_cycle(Frequency.DAILY, creation_date=creation_date_1)      weekly_start_date_1 = _CycleManager._get_start_date_of_cycle(Frequency.WEEKLY, creation_date=creation_date_1)      monthly_start_date_1 = _CycleManager._get_start_date_of_cycle(Frequency.MONTHLY, creation_date=creation_date_1)      yearly_start_date_1 = _CycleManager._get_start_date_of_cycle(Frequency.YEARLY, creation_date=creation_date_1)        assert daily_start_date_1 == datetime.fromisoformat(\"2021-11-11T00:00:00.000000\")      assert weekly_start_date_1 == datetime.fromisoformat(\"2021-11-08T00:00:00.000000\")      assert monthly_start_date_1 == datetime.fromisoformat(\"2021-11-01T00:00:00.000000\")      assert yearly_start_date_1 == datetime.fromisoformat(\"2021-01-01T00:00:00.000000\")        daily_end_date_1 = _CycleManager._get_end_date_of_cycle(Frequency.DAILY, start_date=daily_start_date_1)      weekly_end_date_1 = _CycleManager._get_end_date_of_cycle(Frequency.WEEKLY, start_date=weekly_start_date_1)      monthly_end_date_1 = _CycleManager._get_end_date_of_cycle(Frequency.MONTHLY, start_date=monthly_start_date_1)      yearly_end_date_1 = _CycleManager._get_end_date_of_cycle(Frequency.YEARLY, start_date=yearly_start_date_1)        assert daily_end_date_1 == datetime.fromisoformat(\"2021-11-11T23:59:59.999999\")      assert weekly_end_date_1 == datetime.fromisoformat(\"2021-11-14T23:59:59.999999\")      assert monthly_end_date_1 == datetime.fromisoformat(\"2021-11-30T23:59:59.999999\")      assert yearly_end_date_1 == datetime.fromisoformat(\"2021-12-31T23:59:59.999999\")        creation_date_2 = datetime.now()        daily_start_date_2 = _CycleManager._get_start_date_of_cycle(Frequency.DAILY, creation_date=creation_date_2)      daily_end_date_2 = _CycleManager._get_end_date_of_cycle(Frequency.DAILY, daily_start_date_2)      assert daily_start_date_2.date() == creation_date_2.date()      assert daily_end_date_2.date() == creation_date_2.date()      assert daily_start_date_2 < creation_date_2 < daily_end_date_2        weekly_start_date_2 = _CycleManager._get_start_date_of_cycle(Frequency.WEEKLY, creation_date=creation_date_2)      weekly_end_date_2 = _CycleManager._get_end_date_of_cycle(Frequency.WEEKLY, weekly_start_date_2)      assert weekly_start_date_2 < creation_date_2 < weekly_end_date_2        monthly_start_date_2 = _CycleManager._get_start_date_of_cycle(Frequency.MONTHLY, creation_date=creation_date_2)      monthly_end_date_2 = _CycleManager._get_end_date_of_cycle(Frequency.MONTHLY, monthly_start_date_2)      assert monthly_start_date_2.month == creation_date_2.month and monthly_start_date_2.day == 1      assert monthly_end_date_2.month == creation_date_2.month      assert monthly_start_date_2 < creation_date_2 < monthly_end_date_2        yearly_start_date_2 = _CycleManager._get_start_date_of_cycle(Frequency.YEARLY, creation_date=creation_date_2)      yearly_end_date_2 = _CycleManager._get_end_date_of_cycle(Frequency.YEARLY, yearly_start_date_2)      assert yearly_start_date_2.year == creation_date_2.year      assert yearly_start_date_2 == datetime(creation_date_2.year, 1, 1)      assert yearly_end_date_2.year == creation_date_2.year      assert yearly_end_date_2.date() == datetime(creation_date_2.year, 12, 31).date()      assert yearly_start_date_2 < creation_date_2 < yearly_end_date_2      def test_hard_delete_shared_entities():      Config.configure_job_executions(mode=JobConfig._DEVELOPMENT_MODE)        dn_config_1 = Config.configure_data_node(\"my_input_1\", \"in_memory\", scope=Scope.SCENARIO, default_data=\"testing\")      dn_config_2 = Config.configure_data_node(\"my_input_2\", \"in_memory\", scope=Scope.SCENARIO, default_data=\"testing\")      dn_config_3 = Config.configure_data_node(\"my_input_3\", \"in_memory\", scope=Scope.CYCLE, default_data=\"testing\")      dn_config_4 = Config.configure_data_node(\"my_input_4\", \"in_memory\", scope=Scope.GLOBAL, default_data=\"testing\")      task_config_1 = Config.configure_task(\"task_config_1\", print, dn_config_1, dn_config_2)      task_config_2 = Config.configure_task(\"task_config_2\", print, dn_config_2, dn_config_3)      task_config_3 = Config.configure_task(\"task_config_3\", print, dn_config_3, dn_config_4)  # scope = global      creation_date = datetime.now()      scenario_config_1 = Config.configure_scenario(          \"scenario_config_1\",          [task_config_1, task_config_2, task_config_3],          creation_date=creation_date,          frequency=Frequency.DAILY,      )      scenario_config_1.add_sequences(          {              \"sequence_1\": [task_config_1, task_config_2],              \"sequence_2\": [task_config_1, task_config_2],              \"sequence_3\": [task_config_3],          }      )      scenario_config_2 = Config.configure_scenario(          \"scenario_config_2\", [task_config_2, task_config_3]      )  # No Frequency so cycle attached to scenarios      scenario_config_2.add_sequences({\"sequence_3\": [task_config_3]})        _OrchestratorFactory._build_dispatcher()        scenario_1 = _ScenarioManager._create(scenario_config_1)      scenario_2 = _ScenarioManager._create(scenario_config_1)      scenario_3 = _ScenarioManager._create(scenario_config_2)      scenario_1.submit()      scenario_2.submit()      scenario_3.submit()        assert len(_ScenarioManager._get_all()) == 3      assert len(_SequenceManager._get_all()) == 7      assert len(_TaskManager._get_all()) == 7      assert len(_DataManager._get_all()) == 8      assert len(_JobManager._get_all()) == 8      assert len(_CycleManager._get_all()) == 1      _CycleManager._hard_delete(scenario_1.cycle.id)      assert len(_CycleManager._get_all()) == 0      assert len(_ScenarioManager._get_all()) == 1      assert len(_SequenceManager._get_all()) == 1      assert len(_TaskManager._get_all()) == 2      assert len(_JobManager._get_all()) == 2      assert len(_DataManager._get_all()) == 3      def test_get_primary(tmpdir, cycle, current_datetime):      _CycleManager._repository.base_path = tmpdir        assert len(_CycleManager._get_all()) == 0        _CycleManager._set(cycle)      cycle_1 = _CycleManager._get(cycle.id)      cycle_2 = Cycle(Frequency.MONTHLY, {}, current_datetime, current_datetime, current_datetime, name=\"foo\")      _CycleManager._set(cycle_2)      cycle_2 = _CycleManager._get(cycle_2.id)      cycles = _CycleManager._get_all()      assert len(_CycleManager._get_all()) == 2      assert (          len(_CycleManager._get_cycles_by_frequency_and_start_date(cycle_1.frequency, cycle_1.start_date, cycles)) == 1      )      assert (          len(_CycleManager._get_cycles_by_frequency_and_start_date(cycle_2.frequency, cycle_2.start_date, cycles)) == 1      )      assert (          len(              _CycleManager._get_cycles_by_frequency_and_start_date(                  Frequency.WEEKLY, datetime(2000, 1, 1, 1, 0, 0, 0), cycles              )          )          == 0      )        assert (          len(              _CycleManager._get_cycles_by_frequency_and_overlapping_date(                  cycle_1.frequency, cycle_1.creation_date, cycles              )          )          == 1      )      assert (          _CycleManager._get_cycles_by_frequency_and_overlapping_date(cycle_1.frequency, cycle_1.creation_date, cycles)[0]          == cycle_1      )      assert (          len(              _CycleManager._get_cycles_by_frequency_and_overlapping_date(                  Frequency.WEEKLY, datetime(2000, 1, 1, 1, 0, 0, 0), cycles              )          )          == 0      ) "}
{"text": "from datetime import datetime    from src.taipy.core._orchestrator._orchestrator_factory import _OrchestratorFactory  from src.taipy.core.config.job_config import JobConfig  from src.taipy.core.cycle._cycle_manager import _CycleManager  from src.taipy.core.cycle._cycle_manager_factory import _CycleManagerFactory  from src.taipy.core.cycle.cycle import Cycle  from src.taipy.core.cycle.cycle_id import CycleId  from src.taipy.core.data._data_manager import _DataManager  from src.taipy.core.job._job_manager import _JobManager  from src.taipy.core.scenario._scenario_manager import _ScenarioManager  from src.taipy.core.scenario._scenario_manager_factory import _ScenarioManagerFactory  from src.taipy.core.sequence._sequence_manager import _SequenceManager  from src.taipy.core.task._task_manager import _TaskManager  from taipy.config.common.frequency import Frequency  from taipy.config.common.scope import Scope  from taipy.config.config import Config      def test_save_and_get_cycle_entity(init_sql_repo, cycle, current_datetime):      _CycleManager._repository = _CycleManagerFactory._build_repository()        _CycleManager._delete_all()      assert len(_CycleManager._get_all()) == 0        _CycleManager._set(cycle)      assert _CycleManager._exists(cycle.id)        cycle_1 = _CycleManager._get(cycle.id)        assert cycle_1.id == cycle.id      assert cycle_1.name == cycle.name      assert cycle_1.properties == cycle.properties      assert cycle_1.creation_date == cycle.creation_date      assert cycle_1.start_date == cycle.start_date      assert cycle_1.end_date == cycle.end_date      assert cycle_1.frequency == cycle.frequency        assert len(_CycleManager._get_all()) == 1      assert _CycleManager._get(cycle.id) == cycle      assert _CycleManager._get(cycle.id).name == cycle.name      assert isinstance(_CycleManager._get(cycle.id).creation_date, datetime)      assert _CycleManager._get(cycle.id).creation_date == cycle.creation_date      assert _CycleManager._get(cycle.id).frequency == Frequency.DAILY        cycle_2_id = CycleId(\"cycle_2\")      assert _CycleManager._get(cycle_2_id) is None      assert not _CycleManager._exists(cycle_2_id)        cycle_3 = Cycle(          Frequency.MONTHLY,          {},          creation_date=current_datetime,          start_date=current_datetime,          end_date=current_datetime,          name=\"bar\",          id=cycle_1.id,      )        _CycleManager._set(cycle_3)        cycle_3 = _CycleManager._get(cycle_1.id)        assert _CycleManager._exists(cycle_1.id)      assert len(_CycleManager._get_all()) == 1      assert cycle_3.id == cycle_1.id      assert cycle_3.name == cycle_3.name      assert cycle_3.properties == cycle_3.properties      assert cycle_3.creation_date == current_datetime      assert cycle_3.start_date == current_datetime      assert cycle_3.end_date == current_datetime      assert cycle_3.frequency == cycle_3.frequency      def test_create_and_delete_cycle_entity(init_sql_repo):      _CycleManager._repository = _CycleManagerFactory._build_repository()        _CycleManager._delete_all()      assert len(_CycleManager._get_all()) == 0        cycle_1 = _CycleManager._create(Frequency.DAILY, name=\"foo\", key=\"value\", display_name=\"foo\")        assert cycle_1.id is not None      assert cycle_1.name == \"foo\"      assert cycle_1.properties == {\"key\": \"value\", \"display_name\": \"foo\"}      assert cycle_1.creation_date is not None      assert cycle_1.start_date is not None      assert cycle_1.end_date is not None      assert cycle_1.start_date < cycle_1.creation_date < cycle_1.end_date      assert cycle_1.key == \"value\"      assert cycle_1.frequency == Frequency.DAILY        cycle_1_id = cycle_1.id        assert _CycleManager._exists(cycle_1.id)      assert len(_CycleManager._get_all()) == 1      assert _CycleManager._get(cycle_1_id) == cycle_1      assert _CycleManager._get(cycle_1_id).name == \"foo\"      assert isinstance(_CycleManager._get(cycle_1_id).creation_date, datetime)      assert _CycleManager._get(cycle_1_id).frequency == Frequency.DAILY        cycle_2_id = CycleId(\"cycle_2\")      assert _CycleManager._get(cycle_2_id) is None      assert not _CycleManager._exists(cycle_2_id)        cycle_3 = _CycleManager._create(Frequency.MONTHLY, \"bar\")        assert cycle_3.id is not None      assert cycle_3.name == \"bar\"      assert isinstance(cycle_3.creation_date, datetime)      assert cycle_3.frequency == Frequency.MONTHLY        cycle_3_id = cycle_3.id        assert _CycleManager._exists(cycle_3_id)      assert len(_CycleManager._get_all()) == 2      assert _CycleManager._get(cycle_3_id).name == \"bar\"        cycle_4 = _CycleManager._create(Frequency.YEARLY, \"baz\")      cycle_4_id = cycle_4.id        assert _CycleManager._exists(cycle_4_id)      assert len(_CycleManager._get_all()) == 3        _CycleManager._delete(cycle_4_id)        assert len(_CycleManager._get_all()) == 2      assert not _CycleManager._exists(cycle_4_id)      assert _CycleManager._get(cycle_4_id) is None        _CycleManager._delete_all()      assert len(_CycleManager._get_all()) == 0      assert not any(_CycleManager._exists(cycle_id) for cycle_id in [cycle_1_id, cycle_3_id, cycle_4_id])      def test_get_cycle_start_date_and_end_date(init_sql_repo):      _CycleManager._repository = _CycleManagerFactory._build_repository()        _CycleManager._delete_all()        creation_date_1 = datetime.fromisoformat(\"2021-11-11T11:11:01.000001\")        daily_start_date_1 = _CycleManager._get_start_date_of_cycle(Frequency.DAILY, creation_date=creation_date_1)      weekly_start_date_1 = _CycleManager._get_start_date_of_cycle(Frequency.WEEKLY, creation_date=creation_date_1)      monthly_start_date_1 = _CycleManager._get_start_date_of_cycle(Frequency.MONTHLY, creation_date=creation_date_1)      yearly_start_date_1 = _CycleManager._get_start_date_of_cycle(Frequency.YEARLY, creation_date=creation_date_1)        assert daily_start_date_1 == datetime.fromisoformat(\"2021-11-11T00:00:00.000000\")      assert weekly_start_date_1 == datetime.fromisoformat(\"2021-11-08T00:00:00.000000\")      assert monthly_start_date_1 == datetime.fromisoformat(\"2021-11-01T00:00:00.000000\")      assert yearly_start_date_1 == datetime.fromisoformat(\"2021-01-01T00:00:00.000000\")        daily_end_date_1 = _CycleManager._get_end_date_of_cycle(Frequency.DAILY, start_date=daily_start_date_1)      weekly_end_date_1 = _CycleManager._get_end_date_of_cycle(Frequency.WEEKLY, start_date=weekly_start_date_1)      monthly_end_date_1 = _CycleManager._get_end_date_of_cycle(Frequency.MONTHLY, start_date=monthly_start_date_1)      yearly_end_date_1 = _CycleManager._get_end_date_of_cycle(Frequency.YEARLY, start_date=yearly_start_date_1)        assert daily_end_date_1 == datetime.fromisoformat(\"2021-11-11T23:59:59.999999\")      assert weekly_end_date_1 == datetime.fromisoformat(\"2021-11-14T23:59:59.999999\")      assert monthly_end_date_1 == datetime.fromisoformat(\"2021-11-30T23:59:59.999999\")      assert yearly_end_date_1 == datetime.fromisoformat(\"2021-12-31T23:59:59.999999\")        creation_date_2 = datetime.now()        daily_start_date_2 = _CycleManager._get_start_date_of_cycle(Frequency.DAILY, creation_date=creation_date_2)      daily_end_date_2 = _CycleManager._get_end_date_of_cycle(Frequency.DAILY, daily_start_date_2)      assert daily_start_date_2.date() == creation_date_2.date()      assert daily_end_date_2.date() == creation_date_2.date()      assert daily_start_date_2 < creation_date_2 < daily_end_date_2        weekly_start_date_2 = _CycleManager._get_start_date_of_cycle(Frequency.WEEKLY, creation_date=creation_date_2)      weekly_end_date_2 = _CycleManager._get_end_date_of_cycle(Frequency.WEEKLY, weekly_start_date_2)      assert weekly_start_date_2 < creation_date_2 < weekly_end_date_2        monthly_start_date_2 = _CycleManager._get_start_date_of_cycle(Frequency.MONTHLY, creation_date=creation_date_2)      monthly_end_date_2 = _CycleManager._get_end_date_of_cycle(Frequency.MONTHLY, monthly_start_date_2)      assert monthly_start_date_2.month == creation_date_2.month and monthly_start_date_2.day == 1      assert monthly_end_date_2.month == creation_date_2.month      assert monthly_start_date_2 < creation_date_2 < monthly_end_date_2        yearly_start_date_2 = _CycleManager._get_start_date_of_cycle(Frequency.YEARLY, creation_date=creation_date_2)      yearly_end_date_2 = _CycleManager._get_end_date_of_cycle(Frequency.YEARLY, yearly_start_date_2)      assert yearly_start_date_2.year == creation_date_2.year      assert yearly_start_date_2 == datetime(creation_date_2.year, 1, 1)      assert yearly_end_date_2.year == creation_date_2.year      assert yearly_end_date_2.date() == datetime(creation_date_2.year, 12, 31).date()      assert yearly_start_date_2 < creation_date_2 < yearly_end_date_2      def test_hard_delete_shared_entities(init_sql_repo):      Config.configure_job_executions(mode=JobConfig._DEVELOPMENT_MODE)      _ScenarioManager._repository = _ScenarioManagerFactory._build_repository()        dn_config_1 = Config.configure_data_node(\"my_input_1\", \"in_memory\", scope=Scope.SCENARIO, default_data=\"testing\")      dn_config_2 = Config.configure_data_node(\"my_input_2\", \"in_memory\", scope=Scope.SCENARIO, default_data=\"testing\")      dn_config_3 = Config.configure_data_node(\"my_input_3\", \"in_memory\", scope=Scope.CYCLE, default_data=\"testing\")      dn_config_4 = Config.configure_data_node(\"my_input_4\", \"in_memory\", scope=Scope.GLOBAL, default_data=\"testing\")      task_config_1 = Config.configure_task(\"task_config_1\", print, dn_config_1, dn_config_2)      task_config_2 = Config.configure_task(\"task_config_2\", print, dn_config_2, dn_config_3)      task_config_3 = Config.configure_task(\"task_config_3\", print, dn_config_3, dn_config_4)  # scope = global      creation_date = datetime.now()      scenario_config_1 = Config.configure_scenario(          \"scenario_config_1\",          [task_config_1, task_config_2, task_config_3],          creation_date=creation_date,          frequency=Frequency.DAILY,      )      scenario_config_1.add_sequences(          {              \"sequence_1\": [task_config_1, task_config_2],              \"sequence_2\": [task_config_1, task_config_2],              \"sequence_3\": [task_config_3],          }      )      scenario_config_2 = Config.configure_scenario(          \"scenario_config_2\", [task_config_2, task_config_3]      )  # No Frequency so cycle attached to scenarios      scenario_config_2.add_sequences({\"sequence_3\": [task_config_3]})        _OrchestratorFactory._build_dispatcher()        scenario_1 = _ScenarioManager._create(scenario_config_1)      scenario_2 = _ScenarioManager._create(scenario_config_1)      scenario_3 = _ScenarioManager._create(scenario_config_2)      scenario_1.submit()      scenario_2.submit()      scenario_3.submit()        assert len(_ScenarioManager._get_all()) == 3      assert len(_SequenceManager._get_all()) == 7      assert len(_TaskManager._get_all()) == 7      assert len(_DataManager._get_all()) == 8      assert len(_JobManager._get_all()) == 8      assert len(_CycleManager._get_all()) == 1      _CycleManager._hard_delete(scenario_1.cycle.id)      assert len(_CycleManager._get_all()) == 0      assert len(_ScenarioManager._get_all()) == 1      assert len(_SequenceManager._get_all()) == 1      assert len(_TaskManager._get_all()) == 2      assert len(_JobManager._get_all()) == 2      assert len(_DataManager._get_all()) == 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 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": "#  # Licensed under the Apache License, Version 2.0 (the \"License\"); you may not use this file except in compliance with  # the License. You may obtain a copy of the License at  #  #        http://www.apache.org/licenses/LICENSE-2.0  #  # Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on  # an \"AS IS\" BASIS, WITHOUT 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 List    from src.taipy.core import DataNode, Sequence, SequenceId, Task, TaskId  from src.taipy.core._entity._dag import _DAG  from taipy.config.common.scope import Scope      def assert_x(x: int, *nodes):      for node in nodes:          assert node.x == x      def assert_y(y: List[int], *nodes):      for node in nodes:          assert node.y in y          y.remove(node.y)      def assert_x_y(x: int, y: List[int], *nodes):      assert_x(x, *nodes)      for node in nodes:          assert node.y in y          y.remove(node.y)      def assert_edge_exists(src, dest, dag: _DAG):      list_of_tuples = [(edge.src.entity.id, edge.dest.entity.id) for edge in dag.edges]      assert (src, dest) in list_of_tuples      class TestDAG:      def test_get_dag_1(self):          data_node_1 = DataNode(\"foo\", Scope.SCENARIO, \"s1\")          data_node_2 = DataNode(\"bar\", Scope.SCENARIO, \"s2\")          data_node_3 = DataNode(\"baz\", Scope.SCENARIO, \"s3\")          data_node_4 = DataNode(\"qux\", Scope.SCENARIO, \"s4\")          data_node_5 = DataNode(\"quux\", Scope.SCENARIO, \"s5\")          data_node_6 = DataNode(\"quuz\", Scope.SCENARIO, \"s6\")          data_node_7 = DataNode(\"corge\", Scope.SCENARIO, \"s7\")          task_1 = Task(\"grault\", {}, print, [data_node_1, data_node_2], [data_node_3, data_node_4], TaskId(\"t1\"))          task_2 = Task(\"garply\", {}, print, [data_node_3], [data_node_5], TaskId(\"t2\"))          task_3 = Task(\"waldo\", {}, print, [data_node_5, data_node_4], [data_node_6], TaskId(\"t3\"))          task_4 = Task(\"fred\", {}, print, [data_node_4], [data_node_7], TaskId(\"t4\"))          sequence = Sequence({}, [task_4, task_2, task_1, task_3], SequenceId(\"p1\"))            dag = sequence._get_dag()          # s1 ---             ---> s3 ---> t2 ---> s5 ----          #       |           |                           |          #       |---> t1 ---|      -------------------------> t3 ---> s6          #       |           |      |          # s2 ---             ---> s4 ---> t4 ---> s7            assert dag.length == 7          assert dag.width == 2          assert dag._grid_length == 7          assert dag._grid_width == 3          assert len(dag.nodes) == 11          assert_x_y(0, [0, 2], dag.nodes[\"s1\"], dag.nodes[\"s2\"])          assert_x_y(1, [1], dag.nodes[\"t1\"])          assert_x_y(2, [0, 2], dag.nodes[\"s3\"], dag.nodes[\"s4\"])          assert_x_y(3, [0, 2], dag.nodes[\"t2\"], dag.nodes[\"t4\"])          assert_x_y(4, [0, 2], dag.nodes[\"s5\"], dag.nodes[\"s7\"])          assert_x_y(5, [1], dag.nodes[\"t3\"])          assert_x_y(6, [1], dag.nodes[\"s6\"])          assert len(dag.edges) == 11          assert_edge_exists(\"s1\", \"t1\", dag)          assert_edge_exists(\"s2\", \"t1\", dag)          assert_edge_exists(\"t1\", \"s3\", dag)          assert_edge_exists(\"t1\", \"s4\", dag)          assert_edge_exists(\"s3\", \"t2\", dag)          assert_edge_exists(\"t2\", \"s5\", dag)          assert_edge_exists(\"s5\", \"t3\", dag)          assert_edge_exists(\"s4\", \"t3\", dag)          assert_edge_exists(\"t3\", \"s6\", dag)          assert_edge_exists(\"s4\", \"t4\", dag)          assert_edge_exists(\"t4\", \"s7\", dag)        def test_get_dag_2(self):          data_node_1 = DataNode(\"foo\", Scope.SCENARIO, \"s1\")          data_node_2 = DataNode(\"bar\", Scope.SCENARIO, \"s2\")          data_node_4 = DataNode(\"qux\", Scope.SCENARIO, \"s4\")          data_node_5 = DataNode(\"quux\", Scope.SCENARIO, \"s5\")          data_node_6 = DataNode(\"quuz\", Scope.SCENARIO, \"s6\")          data_node_7 = DataNode(\"corge\", Scope.SCENARIO, \"s7\")          task_1 = Task(\"grault\", {}, print, [data_node_1, data_node_2], [data_node_4], TaskId(\"t1\"))          task_2 = Task(\"garply\", {}, print, None, [data_node_5], TaskId(\"t2\"))          task_3 = Task(\"waldo\", {}, print, [data_node_5, data_node_4], [data_node_6], TaskId(\"t3\"))          task_4 = Task(\"fred\", {}, print, [data_node_4], [data_node_7], TaskId(\"t4\"))          sequence = Sequence({}, [task_4, task_2, task_1, task_3], SequenceId(\"p1\"))            #  6  |   t2 _____          #  5  |           \\          #  4  |            s5 _________________ t3 _______ s6          #  3  |   s1 __            _ s4 _____/          #  2  |        \\ _ t1 ____/          \\_ t4 _______ s7          #  1  |        /          #  0  |   s2 --          #     |________________________________________________          #         0        1         2          3          4            dag = sequence._get_dag()            assert dag.length == 5          assert dag.width == 3          assert dag._grid_length == 5          assert dag._grid_width == 7          assert len(dag.nodes) == 10          assert_x_y(0, [0, 3, 6], dag.nodes[\"s1\"], dag.nodes[\"s2\"], dag.nodes[\"t2\"])          assert_x_y(1, [2, 4], dag.nodes[\"t1\"], dag.nodes[\"s5\"])          assert_x_y(2, [3], dag.nodes[\"s4\"])          assert_x_y(3, [2, 4], dag.nodes[\"t3\"], dag.nodes[\"t4\"])          assert_x_y(4, [2, 4], dag.nodes[\"s6\"], dag.nodes[\"s7\"])          assert len(dag.edges) == 9          assert_edge_exists(\"s1\", \"t1\", dag)          assert_edge_exists(\"s2\", \"t1\", dag)          assert_edge_exists(\"t1\", \"s4\", dag)          assert_edge_exists(\"t2\", \"s5\", dag)          assert_edge_exists(\"s5\", \"t3\", dag)          assert_edge_exists(\"s4\", \"t3\", dag)          assert_edge_exists(\"t3\", \"s6\", dag)          assert_edge_exists(\"s4\", \"t4\", dag)          assert_edge_exists(\"t4\", \"s7\", dag)        def test_get_dag_3(self):          data_node_1 = DataNode(\"foo\", Scope.SCENARIO, \"s1\")          data_node_2 = DataNode(\"bar\", Scope.SCENARIO, \"s2\")          data_node_3 = DataNode(\"quuz\", Scope.SCENARIO, \"s3\")          data_node_4 = DataNode(\"qux\", Scope.SCENARIO, \"s4\")          data_node_5 = DataNode(\"quux\", Scope.SCENARIO, \"s5\")          data_node_6 = DataNode(\"corge\", Scope.SCENARIO, \"s6\")          data_node_7 = DataNode(\"hugh\", Scope.SCENARIO, \"s7\")            task_1 = Task(\"grault\", {}, print, [data_node_1, data_node_2, data_node_3], [data_node_4], TaskId(\"t1\"))          task_2 = Task(\"waldo\", {}, print, [data_node_4], None, id=TaskId(\"t2\"))          task_3 = Task(\"fred\", {}, print, [data_node_4], [data_node_5], TaskId(\"t3\"))          task_4 = Task(\"garply\", {}, print, output=[data_node_6], id=TaskId(\"t4\"))          task_5 = Task(\"bob\", {}, print, [data_node_7], None, TaskId(\"t5\"))          sequence = Sequence({}, [task_5, task_3, task_4, task_1, task_2], SequenceId(\"p1\"))            #  12 |  s7 __          #  11 |       \\          #  10 |        \\          #  9  |  t4 _   \\_ t5          #  8  |      \\                     ____ t3 ___          #  7  |       \\                   /           \\          #  6  |  s3 _  \\__ s6      _ s4 _/             \\___ s5          #  5  |      \\            /      \\          #  4  |       \\          /        \\____ t2          #  3  |  s2 ___\\__ t1 __/          #  2  |        /          #  1  |       /          #  0  |  s1 _/          #     |________________________________________________          #         0         1         2          3          4          dag = sequence._get_dag()            assert dag.length == 5          assert dag.width == 5          assert dag._grid_length == 5          assert dag._grid_width == 13          assert len(dag.nodes) == 12            assert_x_y(              0, [0, 3, 6, 9, 12], dag.nodes[\"s1\"], dag.nodes[\"s2\"], dag.nodes[\"s3\"], dag.nodes[\"s7\"], dag.nodes[\"t4\"]          )          assert_x_y(1, [3, 6, 9], dag.nodes[\"t1\"], dag.nodes[\"t5\"], dag.nodes[\"s6\"])          assert_x_y(2, [6], dag.nodes[\"s4\"])          assert_x_y(3, [4, 8], dag.nodes[\"t2\"], dag.nodes[\"t3\"])          assert_x_y(4, [6], dag.nodes[\"s5\"])          assert len(dag.edges) == 9          assert_edge_exists(\"s1\", \"t1\", dag)          assert_edge_exists(\"s2\", \"t1\", dag)          assert_edge_exists(\"s3\", \"t1\", dag)          assert_edge_exists(\"t1\", \"s4\", dag)          assert_edge_exists(\"s4\", \"t2\", dag)          assert_edge_exists(\"s4\", \"t3\", dag)          assert_edge_exists(\"t3\", \"s5\", dag)          assert_edge_exists(\"t4\", \"s6\", dag)          assert_edge_exists(\"s7\", \"t5\", dag)        def test_get_dag_4(self):          data_node_1 = DataNode(\"foo\", Scope.SCENARIO, \"s1\")          data_node_2 = DataNode(\"bar\", Scope.SCENARIO, \"s2\")          data_node_3 = DataNode(\"quuz\", Scope.SCENARIO, \"s3\")          data_node_4 = DataNode(\"qux\", Scope.SCENARIO, \"s4\")          data_node_5 = DataNode(\"quux\", Scope.SCENARIO, \"s5\")          data_node_6 = DataNode(\"corge\", Scope.SCENARIO, \"s6\")            task_1 = Task(\"grault\", {}, print, [data_node_1, data_node_2, data_node_3], [data_node_4], TaskId(\"t1\"))          task_2 = Task(\"waldo\", {}, print, [data_node_4], None, id=TaskId(\"t2\"))          task_3 = Task(\"fred\", {}, print, [data_node_4], [data_node_5], TaskId(\"t3\"))          task_4 = Task(\"garply\", {}, print, output=[data_node_6], id=TaskId(\"t4\"))          sequence = Sequence({}, [task_3, task_4, task_1, task_2], SequenceId(\"p1\"))            #  6  |  t4 __          #  5  |       \\          #  4  |  s3 _  \\__ s6            ______ t3 ___          #  3  |      \\          ___ s4 _/             \\___ s5          #  2  |  s2 __\\__ t1 __/        \\______ t2          #  1  |       /          #  0  |  s1 _/          #     |________________________________________________          #         0         1         2          3          4          dag = sequence._get_dag()            assert dag.length == 5          assert dag.width == 4          assert dag._grid_length == 5          assert dag._grid_width == 7          assert len(dag.nodes) == 10            assert_x_y(0, [0, 2, 4, 6], dag.nodes[\"s1\"], dag.nodes[\"s2\"], dag.nodes[\"s3\"], dag.nodes[\"t4\"])          assert_x_y(1, [2, 4], dag.nodes[\"t1\"], dag.nodes[\"s6\"])          assert_x_y(2, [3], dag.nodes[\"s4\"])          assert_x_y(3, [2, 4], dag.nodes[\"t2\"], dag.nodes[\"t3\"])          assert_x_y(4, [3], dag.nodes[\"s5\"])          assert len(dag.edges) == 8          assert_edge_exists(\"s1\", \"t1\", dag)          assert_edge_exists(\"s2\", \"t1\", dag)          assert_edge_exists(\"s3\", \"t1\", dag)          assert_edge_exists(\"t1\", \"s4\", dag)          assert_edge_exists(\"s4\", \"t2\", dag)          assert_edge_exists(\"s4\", \"t3\", dag)          assert_edge_exists(\"t3\", \"s5\", dag)          assert_edge_exists(\"t4\", \"s6\", dag)        def test_get_dag_5(self):          data_node_1 = DataNode(\"foo\", Scope.SCENARIO, \"s1\")          data_node_2 = DataNode(\"bar\", Scope.SCENARIO, \"s2\")          task_1 = Task(\"baz\", {}, print, [data_node_1], [data_node_2], TaskId(\"t1\"))          sequence = Sequence({}, [task_1], SequenceId(\"p1\"))            #  1  |          #  0  |  s1 __ t1 __ s2          #     |_________________          #         0    1     2          dag = sequence._get_dag()            assert dag.length == 3          assert dag.width == 1          assert dag._grid_length == 3          assert dag._grid_width == 1          assert len(dag.nodes) == 3            assert_x_y(0, [0], dag.nodes[\"s1\"])          assert_x_y(1, [0], dag.nodes[\"t1\"])          assert_x_y(2, [0], dag.nodes[\"s2\"])          assert len(dag.edges) == 2          assert_edge_exists(\"s1\", \"t1\", dag)          assert_edge_exists(\"t1\", \"s2\", dag)        def test_get_dag_6(self):          data_node_1 = DataNode(\"foo\", Scope.SCENARIO, \"s1\")          data_node_2 = DataNode(\"bar\", Scope.SCENARIO, \"s2\")          data_node_3 = DataNode(\"baz\", Scope.SCENARIO, \"s3\")          data_node_4 = DataNode(\"qux\", Scope.SCENARIO, \"s4\")          task_1 = Task(\"quux\", {}, print, [data_node_1, data_node_2], [data_node_3], TaskId(\"t1\"))          task_2 = Task(\"quuz\", {}, print, [data_node_2], [data_node_4], TaskId(\"t2\"))          sequence = Sequence({}, [task_1, task_2], SequenceId(\"p1\"))            #  2  |          #     |          #  1  |  s1 ___ t1 __ s3          #     |      /          #  0  |  s2 /__ t2 __ s4          #     |_________________          #         0     1     2          dag = sequence._get_dag()            assert dag.length == 3          assert dag.width == 2          assert dag._grid_length == 3          assert dag._grid_width == 2          assert len(dag.nodes) == 6            assert_x_y(0, [0, 1], dag.nodes[\"s1\"], dag.nodes[\"s2\"])          assert_x_y(1, [0, 1], dag.nodes[\"t1\"], dag.nodes[\"t2\"])          assert_x_y(2, [0, 1], dag.nodes[\"s3\"], dag.nodes[\"s4\"])          assert len(dag.edges) == 5          assert_edge_exists(\"s1\", \"t1\", dag)          assert_edge_exists(\"s2\", \"t1\", dag)          assert_edge_exists(\"t1\", \"s3\", dag)          assert_edge_exists(\"s2\", \"t2\", dag)          assert_edge_exists(\"t2\", \"s4\", dag) "}
{"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 filecmp  import os  import shutil  import sys  from unittest.mock import patch    import mongomock  import pytest    from src.taipy.core._entity._migrate_cli import _MigrateCLI      @pytest.fixture(scope=\"function\", autouse=True)  def clean_data_folder():      if os.path.exists(\"tests/core/_entity/.data\"):          shutil.rmtree(\"tests/core/_entity/.data\")      yield      def test_migrate_fs_default(caplog):      _MigrateCLI.create_parser()        # Test migrate with default .data folder      with pytest.raises(SystemExit):          with patch(\"sys.argv\", [\"prog\", \"migrate\", \"--repository-type\", \"filesystem\", \"--skip-backup\"]):              _MigrateCLI.parse_arguments()      assert \"Starting entity migration from '.data' folder\" in caplog.text      def test_migrate_fs_specified_folder(caplog):      _MigrateCLI.create_parser()        # Copy data_sample to .data folder for testing      data_sample_path = \"tests/core/_entity/data_sample\"      data_path = \"tests/core/_entity/.data\"      shutil.copytree(data_sample_path, data_path)        # Run with --skip-backup to only test the migration      with pytest.raises(SystemExit):          with patch(\"sys.argv\", [\"prog\", \"migrate\", \"--repository-type\", \"filesystem\", data_path, \"--skip-backup\"]):              _MigrateCLI.parse_arguments()      assert f\"Starting entity migration from '{data_path}' folder\" in caplog.text        # Compare migrated .data folder with data_sample_migrated      dircmp_result = filecmp.dircmp(data_path, \"tests/core/_entity/data_sample_migrated\")      assert not dircmp_result.diff_files and not dircmp_result.left_only and not dircmp_result.right_only      for subdir in dircmp_result.subdirs.values():          assert not subdir.diff_files and not subdir.left_only and not subdir.right_only      def test_migrate_fs_backup_and_remove(caplog):      _MigrateCLI.create_parser()        # Copy data_sample to .data folder for testing      data_sample_path = \"tests/core/_entity/data_sample\"      data_path = \"tests/core/_entity/.data\"      backup_path = \"tests/core/_entity/.data_backup\"      shutil.copytree(data_sample_path, data_path)        # Remove backup when it does not exist should raise an error      with pytest.raises(SystemExit) as err:          with patch(\"sys.argv\", [\"prog\", \"migrate\", \"--repository-type\", \"filesystem\", data_path, \"--remove-backup\"]):              _MigrateCLI.parse_arguments()      assert err.value.code == 1      assert f\"The backup folder '{backup_path}' does not exist.\" in caplog.text      assert not os.path.exists(backup_path)        # Run without --skip-backup to create the backup folder      with pytest.raises(SystemExit):          with patch(\"sys.argv\", [\"prog\", \"migrate\", \"--repository-type\", \"filesystem\", data_path]):              _MigrateCLI.parse_arguments()      assert f\"Backed up entities from '{data_path}' to '{backup_path}' folder before migration.\" in caplog.text        assert os.path.exists(backup_path)        # Remove backup      with pytest.raises(SystemExit):          with patch(\"sys.argv\", [\"prog\", \"migrate\", \"--repository-type\", \"filesystem\", data_path, \"--remove-backup\"]):              _MigrateCLI.parse_arguments()      assert f\"Removed backup entities from the backup folder '{backup_path}'.\" in caplog.text      assert not os.path.exists(backup_path)      def test_migrate_fs_backup_and_restore(caplog):      _MigrateCLI.create_parser()        # Copy data_sample to .data folder for testing      data_sample_path = \"tests/core/_entity/data_sample\"      data_path = \"tests/core/_entity/.data\"      backup_path = \"tests/core/_entity/.data_backup\"      shutil.copytree(data_sample_path, data_path)        # Restore backup when it does not exist should raise an error      with pytest.raises(SystemExit) as err:          with patch(\"sys.argv\", [\"prog\", \"migrate\", \"--repository-type\", \"filesystem\", data_path, \"--restore\"]):              _MigrateCLI.parse_arguments()      assert err.value.code == 1      assert f\"The backup folder '{backup_path}' does not exist.\" in caplog.text      assert not os.path.exists(backup_path)        # Run without --skip-backup to create the backup folder      with pytest.raises(SystemExit):          with patch(\"sys.argv\", [\"prog\", \"migrate\", \"--repository-type\", \"filesystem\", data_path]):              _MigrateCLI.parse_arguments()        assert os.path.exists(backup_path)        # restore the backup      with pytest.raises(SystemExit):          with patch(\"sys.argv\", [\"prog\", \"migrate\", \"--repository-type\", \"filesystem\", data_path, \"--restore\"]):              _MigrateCLI.parse_arguments()      assert f\"Restored entities from the backup folder '{backup_path}' to '{data_path}'.\" in caplog.text      assert not os.path.exists(backup_path)        # Compare migrated .data folder with data_sample to ensure restoreing the backup worked      dircmp_result = filecmp.dircmp(data_path, \"tests/core/_entity/data_sample\")      assert not dircmp_result.diff_files and not dircmp_result.left_only and not dircmp_result.right_only      for subdir in dircmp_result.subdirs.values():          assert not subdir.diff_files and not subdir.left_only and not subdir.right_only      def test_migrate_fs_non_existing_folder(caplog):      _MigrateCLI.create_parser()        # Test migrate with a non-existing folder      with pytest.raises(SystemExit) as err:          with patch(\"sys.argv\", [\"prog\", \"migrate\", \"--repository-type\", \"filesystem\", \"non-existing-folder\"]):              _MigrateCLI.parse_arguments()      assert err.value.code == 1      assert \"Folder 'non-existing-folder' does not exist.\" in caplog.text      @patch(\"src.taipy.core._entity._migrate_cli._migrate_sql_entities\")  def test_migrate_sql_specified_path(_migrate_sql_entities_mock, tmp_sqlite):      _MigrateCLI.create_parser()        # Test the _migrate_sql_entities is called once with the correct path      with pytest.raises(SystemExit):          with patch(\"sys.argv\", [\"prog\", \"migrate\", \"--repository-type\", \"sql\", tmp_sqlite, \"--skip-backup\"]):              _MigrateCLI.parse_arguments()              assert _migrate_sql_entities_mock.assert_called_once_with(path=tmp_sqlite)      def test_migrate_sql_backup_and_remove(caplog, tmp_sqlite):      _MigrateCLI.create_parser()        # Create the .sqlite file to test      with open(tmp_sqlite, \"w\") as f:          f.write(\"\")        file_name, file_extension = tmp_sqlite.rsplit(\".\", 1)      backup_sqlite = f\"{file_name}_backup.{file_extension}\"        # Remove backup when it does not exist should raise an error      with pytest.raises(SystemExit) as err:          with patch(\"sys.argv\", [\"prog\", \"migrate\", \"--repository-type\", \"sql\", tmp_sqlite, \"--remove-backup\"]):              _MigrateCLI.parse_arguments()      assert err.value.code == 1      assert f\"The backup database '{backup_sqlite}' does not exist.\" in caplog.text      assert not os.path.exists(backup_sqlite)        # Run without --skip-backup to create the backup database      with pytest.raises(Exception):          with patch(\"sys.argv\", [\"prog\", \"migrate\", \"--repository-type\", \"sql\", tmp_sqlite]):              _MigrateCLI.parse_arguments()        assert os.path.exists(backup_sqlite)        # Remove backup      with pytest.raises(SystemExit):          with patch(\"sys.argv\", [\"prog\", \"migrate\", \"--repository-type\", \"sql\", tmp_sqlite, \"--remove-backup\"]):              _MigrateCLI.parse_arguments()      assert f\"Removed backup entities from the backup database '{backup_sqlite}'.\" in caplog.text      assert not os.path.exists(backup_sqlite)      @pytest.mark.skipif(sys.platform == \"win32\", reason=\"Does not run on windows due to PermissionError: [WinError 32]\")  def test_migrate_sql_backup_and_restore(caplog, tmp_sqlite):      _MigrateCLI.create_parser()        # Create the .sqlite file to test      with open(tmp_sqlite, \"w\") as f:          f.write(\"\")        file_name, file_extension = tmp_sqlite.rsplit(\".\", 1)      backup_sqlite = f\"{file_name}_backup.{file_extension}\"        # Restore backup when it does not exist should raise an error      with pytest.raises(SystemExit) as err:          with patch(\"sys.argv\", [\"prog\", \"migrate\", \"--repository-type\", \"sql\", tmp_sqlite, \"--restore\"]):              _MigrateCLI.parse_arguments()      assert err.value.code == 1      assert f\"The backup database '{backup_sqlite}' does not exist.\" in caplog.text      assert not os.path.exists(backup_sqlite)        # Run without --skip-backup to create the backup database      with pytest.raises(Exception):          with patch(\"sys.argv\", [\"prog\", \"migrate\", \"--repository-type\", \"sql\", tmp_sqlite]):              _MigrateCLI.parse_arguments()        assert os.path.exists(backup_sqlite)        # Restore the backup      with pytest.raises(SystemExit):          with patch(\"sys.argv\", [\"prog\", \"migrate\", \"--repository-type\", \"sql\", tmp_sqlite, \"--restore\"]):              _MigrateCLI.parse_arguments()      assert f\"Restored entities from the backup database '{backup_sqlite}' to '{tmp_sqlite}'.\" in caplog.text      assert not os.path.exists(backup_sqlite)      def test_migrate_sql_non_existing_path(caplog):      _MigrateCLI.create_parser()        # Test migrate without providing a path      with pytest.raises(SystemExit) as err:          with patch(\"sys.argv\", [\"prog\", \"migrate\", \"--repository-type\", \"sql\"]):              _MigrateCLI.parse_arguments()        assert err.value.code == 1      assert \"Missing the required sqlite path.\" in caplog.text        caplog.clear()        # Test migrate with a non-existing-path.sqlite file      with pytest.raises(SystemExit) as err:          with patch(\"sys.argv\", [\"prog\", \"migrate\", \"--repository-type\", \"sql\", \"non-existing-path.sqlite\"]):              _MigrateCLI.parse_arguments()      assert err.value.code == 1      assert \"File 'non-existing-path.sqlite' does not exist.\" in caplog.text      @patch(\"src.taipy.core._entity._migrate_cli._migrate_mongo_entities\")  def test_call_to_migrate_mongo(_migrate_mongo_entities_mock):      _MigrateCLI.create_parser()        with pytest.raises(SystemExit):          with patch(\"sys.argv\", [\"prog\", \"migrate\", \"--repository-type\", \"mongo\"]):              _MigrateCLI.parse_arguments()              assert _migrate_mongo_entities_mock.assert_called_once_with()        with pytest.raises(SystemExit):          with patch(\"sys.argv\", [\"prog\", \"migrate\", \"--repository-type\", \"mongo\", \"host\", \"port\", \"user\", \"password\"]):              _MigrateCLI.parse_arguments()              assert _migrate_mongo_entities_mock.assert_called_once_with(\"host\", \"port\", \"user\", \"password\")      @mongomock.patch(servers=((\"localhost\", 27017),))  def test_migrate_mongo_backup_and_remove(caplog):      _MigrateCLI.create_parser()        mongo_backup_path = \".mongo_backup\"        # Remove backup when it does not exist should raise an error      with pytest.raises(SystemExit) as err:          with patch(\"sys.argv\", [\"prog\", \"migrate\", \"--repository-type\", \"mongo\", \"--remove-backup\"]):              _MigrateCLI.parse_arguments()      assert err.value.code == 1      assert f\"The backup folder '{mongo_backup_path}' does not exist.\" in caplog.text      assert not os.path.exists(mongo_backup_path)        # Run without --skip-backup to create the backup database      with pytest.raises(Exception):          with patch(\"sys.argv\", [\"prog\", \"migrate\", \"--repository-type\", \"mongo\"]):              _MigrateCLI.parse_arguments()        assert os.path.exists(mongo_backup_path)        # Remove backup      with pytest.raises(SystemExit):          with patch(\"sys.argv\", [\"prog\", \"migrate\", \"--repository-type\", \"mongo\", \"--remove-backup\"]):              _MigrateCLI.parse_arguments()      assert f\"Removed backup entities from the backup folder '{mongo_backup_path}'.\" in caplog.text      assert not os.path.exists(mongo_backup_path)      @mongomock.patch(servers=((\"localhost\", 27017),))  def test_migrate_mongo_backup_and_restore(caplog):      _MigrateCLI.create_parser()        mongo_backup_path = \".mongo_backup\"        # Restore backup when it does not exist should raise an error      with pytest.raises(SystemExit) as err:          with patch(\"sys.argv\", [\"prog\", \"migrate\", \"--repository-type\", \"mongo\", \"--restore\"]):              _MigrateCLI.parse_arguments()      assert err.value.code == 1      assert f\"The backup folder '{mongo_backup_path}' does not exist.\" in caplog.text      assert not os.path.exists(mongo_backup_path)        # Run without --skip-backup to create the backup database      with pytest.raises(Exception):          with patch(\"sys.argv\", [\"prog\", \"migrate\", \"--repository-type\", \"mongo\"]):              _MigrateCLI.parse_arguments()        assert os.path.exists(mongo_backup_path)        # Restore the backup      with pytest.raises(SystemExit):          with patch(\"sys.argv\", [\"prog\", \"migrate\", \"--repository-type\", \"mongo\", \"--restore\"]):              _MigrateCLI.parse_arguments()      assert f\"Restored entities from the backup folder '{mongo_backup_path}'.\" in caplog.text      assert not os.path.exists(mongo_backup_path)      def test_not_provide_valid_repository_type(caplog):      _MigrateCLI.create_parser()        with pytest.raises(SystemExit):          with patch(\"sys.argv\", [\"prog\", \"migrate\"]):              _MigrateCLI.parse_arguments()              assert \"the following arguments are required: --repository-type\" in caplog.text        with pytest.raises(SystemExit):          with patch(\"sys.argv\", [\"prog\", \"migrate\", \"--repository-type\"]):              _MigrateCLI.parse_arguments()              assert \"argument --repository-type: expected at least one argument\" in caplog.text        with pytest.raises(SystemExit):          with patch(\"sys.argv\", [\"prog\", \"migrate\", \"--repository-type\", \"invalid-repository-type\"]):              _MigrateCLI.parse_arguments()              assert \"Unknown repository type invalid-repository-type\" in caplog.text "}
{"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": "from datetime import datetime, timedelta  from typing import Callable, Iterable, Optional  from unittest.mock import ANY, patch    import pytest    from src.taipy.core import Job  from src.taipy.core._orchestrator._orchestrator import _Orchestrator  from src.taipy.core._orchestrator._orchestrator_factory import _OrchestratorFactory  from src.taipy.core._version._version_manager import _VersionManager  from src.taipy.core.common import _utils  from src.taipy.core.common._utils import _Subscriber  from src.taipy.core.config.job_config import JobConfig  from src.taipy.core.cycle._cycle_manager import _CycleManager  from src.taipy.core.data._data_manager import _DataManager  from src.taipy.core.data.in_memory import InMemoryDataNode  from src.taipy.core.exceptions.exceptions import (      DeletingPrimaryScenario,      DifferentScenarioConfigs,      InsufficientScenarioToCompare,      NonExistingComparator,      NonExistingScenario,      NonExistingScenarioConfig,      NonExistingTask,      SequenceTaskConfigDoesNotExistInSameScenarioConfig,      UnauthorizedTagError,  )  from src.taipy.core.job._job_manager import _JobManager  from src.taipy.core.scenario._scenario_manager import _ScenarioManager  from src.taipy.core.scenario._scenario_manager_factory import _ScenarioManagerFactory  from src.taipy.core.scenario.scenario import Scenario  from src.taipy.core.scenario.scenario_id import ScenarioId  from src.taipy.core.sequence._sequence_manager import _SequenceManager  from src.taipy.core.sequence.sequence import Sequence  from src.taipy.core.sequence.sequence_id import SequenceId  from src.taipy.core.task._task_manager import _TaskManager  from src.taipy.core.task.task import Task  from src.taipy.core.task.task_id import TaskId  from taipy.config.common.frequency import Frequency  from taipy.config.common.scope import Scope  from taipy.config.config import Config  from tests.core.utils import assert_true_after_time  from tests.core.utils.NotifyMock import NotifyMock      def test_set_and_get_scenario(cycle):      Config.configure_job_executions(mode=JobConfig._DEVELOPMENT_MODE)      _OrchestratorFactory._build_dispatcher()        scenario_id_1 = ScenarioId(\"scenario_id_1\")      scenario_1 = Scenario(\"scenario_name_1\", [], {}, [], scenario_id_1)        input_dn_2 = InMemoryDataNode(\"foo\", Scope.SCENARIO)      output_dn_2 = InMemoryDataNode(\"bar\", Scope.SCENARIO)      additional_dn_2 = InMemoryDataNode(\"zyx\", Scope.SCENARIO)      task_name_2 = \"task_2\"      task_2 = Task(task_name_2, {}, print, [input_dn_2], [output_dn_2], TaskId(\"task_id_2\"))      scenario_id_2 = ScenarioId(\"scenario_id_2\")      scenario_2 = Scenario(          \"scenario_name_2\",          [task_2],          {},          [additional_dn_2],          scenario_id_2,          datetime.now(),          True,          cycle,          sequences={\"sequence_2\": {\"tasks\": [task_2]}},      )        additional_dn_3 = InMemoryDataNode(\"baz\", Scope.SCENARIO)      task_name_3 = \"task_3\"      task_3 = Task(task_name_3, {}, print, id=TaskId(\"task_id_3\"))      scenario_3_with_same_id = Scenario(          \"scenario_name_3\",          [task_3],          {},          [additional_dn_3],          scenario_id_1,          datetime.now(),          False,          cycle,          sequences={\"sequence_3\": {}},      )        # No existing scenario      assert len(_ScenarioManager._get_all()) == 0      assert _ScenarioManager._get(scenario_id_1) is None      assert _ScenarioManager._get(scenario_1) is None      assert _ScenarioManager._get(scenario_id_2) is None      assert _ScenarioManager._get(scenario_2) is None        # Save one scenario. We expect to have only one scenario stored      _ScenarioManager._set(scenario_1)      assert len(_ScenarioManager._get_all()) == 1      assert _ScenarioManager._get(scenario_id_1).id == scenario_1.id      assert _ScenarioManager._get(scenario_id_1).config_id == scenario_1.config_id      assert len(_ScenarioManager._get(scenario_id_1).tasks) == 0      assert len(_ScenarioManager._get(scenario_id_1).additional_data_nodes) == 0      assert len(_ScenarioManager._get(scenario_id_1).data_nodes) == 0      assert len(_ScenarioManager._get(scenario_id_1).sequences) == 0      assert _ScenarioManager._get(scenario_1).id == scenario_1.id      assert _ScenarioManager._get(scenario_1).config_id == scenario_1.config_id      assert len(_ScenarioManager._get(scenario_1).tasks) == 0      assert len(_ScenarioManager._get(scenario_1).additional_data_nodes) == 0      assert len(_ScenarioManager._get(scenario_1).data_nodes) == 0      assert len(_ScenarioManager._get(scenario_1).sequences) == 0      assert _ScenarioManager._get(scenario_id_2) is None      assert _ScenarioManager._get(scenario_2) is None        # Save a second scenario. Now, we expect to have a total of two scenarios stored      _TaskManager._set(task_2)      _CycleManager._set(cycle)      _ScenarioManager._set(scenario_2)      _DataManager._set(additional_dn_2)      assert len(_ScenarioManager._get_all()) == 2      assert _ScenarioManager._get(scenario_id_1).id == scenario_1.id      assert _ScenarioManager._get(scenario_id_1).config_id == scenario_1.config_id      assert len(_ScenarioManager._get(scenario_id_1).tasks) == 0      assert len(_ScenarioManager._get(scenario_id_1).additional_data_nodes) == 0      assert len(_ScenarioManager._get(scenario_id_1).data_nodes) == 0      assert len(_ScenarioManager._get(scenario_id_1).sequences) == 0      assert _ScenarioManager._get(scenario_1).id == scenario_1.id      assert _ScenarioManager._get(scenario_1).config_id == scenario_1.config_id      assert len(_ScenarioManager._get(scenario_1).tasks) == 0      assert len(_ScenarioManager._get(scenario_1).additional_data_nodes) == 0      assert len(_ScenarioManager._get(scenario_1).data_nodes) == 0      assert len(_ScenarioManager._get(scenario_1).sequences) == 0      assert _ScenarioManager._get(scenario_id_2).id == scenario_2.id      assert _ScenarioManager._get(scenario_id_2).config_id == scenario_2.config_id      assert len(_ScenarioManager._get(scenario_id_2).tasks) == 1      assert len(_ScenarioManager._get(scenario_id_2).additional_data_nodes) == 1      assert len(_ScenarioManager._get(scenario_id_2).data_nodes) == 3      assert len(_ScenarioManager._get(scenario_id_2).sequences) == 1      assert _ScenarioManager._get(scenario_2).id == scenario_2.id      assert _ScenarioManager._get(scenario_2).config_id == scenario_2.config_id      assert len(_ScenarioManager._get(scenario_2).tasks) == 1      assert len(_ScenarioManager._get(scenario_2).additional_data_nodes) == 1      assert len(_ScenarioManager._get(scenario_2).data_nodes) == 3      assert len(_ScenarioManager._get(scenario_2).sequences) == 1      assert _TaskManager._get(task_2.id).id == task_2.id      assert _ScenarioManager._get(scenario_id_2).cycle == cycle      assert _ScenarioManager._get(scenario_2).cycle == cycle      assert _CycleManager._get(cycle.id).id == cycle.id        # We save the first scenario again. We expect nothing to change      _ScenarioManager._set(scenario_1)      assert len(_ScenarioManager._get_all()) == 2      assert _ScenarioManager._get(scenario_id_1).id == scenario_1.id      assert _ScenarioManager._get(scenario_id_1).config_id == scenario_1.config_id      assert len(_ScenarioManager._get(scenario_id_1).tasks) == 0      assert len(_ScenarioManager._get(scenario_id_1).additional_data_nodes) == 0      assert len(_ScenarioManager._get(scenario_id_1).data_nodes) == 0      assert len(_ScenarioManager._get(scenario_id_1).sequences) == 0      assert _ScenarioManager._get(scenario_1).id == scenario_1.id      assert _ScenarioManager._get(scenario_1).config_id == scenario_1.config_id      assert len(_ScenarioManager._get(scenario_1).tasks) == 0      assert len(_ScenarioManager._get(scenario_1).additional_data_nodes) == 0      assert len(_ScenarioManager._get(scenario_1).data_nodes) == 0      assert len(_ScenarioManager._get(scenario_1).sequences) == 0      assert _ScenarioManager._get(scenario_id_2).id == scenario_2.id      assert _ScenarioManager._get(scenario_id_2).config_id == scenario_2.config_id      assert len(_ScenarioManager._get(scenario_id_2).tasks) == 1      assert len(_ScenarioManager._get(scenario_id_2).additional_data_nodes) == 1      assert len(_ScenarioManager._get(scenario_id_2).data_nodes) == 3      assert len(_ScenarioManager._get(scenario_id_2).sequences) == 1      assert _ScenarioManager._get(scenario_2).id == scenario_2.id      assert _ScenarioManager._get(scenario_2).config_id == scenario_2.config_id      assert len(_ScenarioManager._get(scenario_2).tasks) == 1      assert len(_ScenarioManager._get(scenario_2).additional_data_nodes) == 1      assert len(_ScenarioManager._get(scenario_2).data_nodes) == 3      assert len(_ScenarioManager._get(scenario_2).sequences) == 1      assert _TaskManager._get(task_2.id).id == task_2.id      assert _CycleManager._get(cycle.id).id == cycle.id        # We save a third scenario with same id as the first one.      # We expect the first scenario to be updated      _DataManager._set(additional_dn_3)      _TaskManager._set(task_3)      _TaskManager._set(scenario_2.tasks[task_name_2])      _ScenarioManager._set(scenario_3_with_same_id)      assert len(_ScenarioManager._get_all()) == 2      assert _ScenarioManager._get(scenario_id_1).id == scenario_1.id      assert _ScenarioManager._get(scenario_id_1).config_id == scenario_3_with_same_id.config_id      assert len(_ScenarioManager._get(scenario_id_1).tasks) == 1      assert len(_ScenarioManager._get(scenario_id_1).additional_data_nodes) == 1      assert len(_ScenarioManager._get(scenario_id_1).data_nodes) == 1      assert len(_ScenarioManager._get(scenario_id_1).sequences) == 1      assert _ScenarioManager._get(scenario_id_1).cycle == cycle      assert _ScenarioManager._get(scenario_1).id == scenario_1.id      assert _ScenarioManager._get(scenario_1).config_id == scenario_3_with_same_id.config_id      assert len(_ScenarioManager._get(scenario_1).tasks) == 1      assert len(_ScenarioManager._get(scenario_1).additional_data_nodes) == 1      assert len(_ScenarioManager._get(scenario_1).data_nodes) == 1      assert len(_ScenarioManager._get(scenario_1).sequences) == 1      assert _ScenarioManager._get(scenario_1).cycle == cycle      assert _ScenarioManager._get(scenario_id_2).id == scenario_2.id      assert _ScenarioManager._get(scenario_id_2).config_id == scenario_2.config_id      assert len(_ScenarioManager._get(scenario_id_2).tasks) == 1      assert len(_ScenarioManager._get(scenario_id_2).additional_data_nodes) == 1      assert len(_ScenarioManager._get(scenario_id_2).data_nodes) == 3      assert len(_ScenarioManager._get(scenario_id_2).sequences) == 1      assert _ScenarioManager._get(scenario_2).id == scenario_2.id      assert _ScenarioManager._get(scenario_2).config_id == scenario_2.config_id      assert len(_ScenarioManager._get(scenario_2).tasks) == 1      assert len(_ScenarioManager._get(scenario_2).additional_data_nodes) == 1      assert len(_ScenarioManager._get(scenario_2).data_nodes) == 3      assert len(_ScenarioManager._get(scenario_2).sequences) == 1      assert _TaskManager._get(task_2.id).id == task_2.id      def test_raise_sequence_task_configs_not_in_scenario_config():      data_node = Config.configure_pickle_data_node(\"temp\")      task_config_1 = Config.configure_task(\"task_1\", print, output=[data_node])      task_config_2 = Config.configure_task(\"task_2\", print, input=[data_node])      scenario_config_1 = Config.configure_scenario(\"scenario_1\")      scenario_config_1.add_sequences({\"sequence_0\": []})        _ScenarioManager._create(scenario_config_1)        scenario_config_1.add_sequences({\"sequence_1\": [task_config_1]})      with pytest.raises(SequenceTaskConfigDoesNotExistInSameScenarioConfig) as err:          _ScenarioManager._create(scenario_config_1)      assert err.value.args == ([task_config_1.id], \"sequence_1\", scenario_config_1.id)        scenario_config_1._tasks = [task_config_1]      _ScenarioManager._create(scenario_config_1)        scenario_config_1.add_sequences({\"sequence_2\": [task_config_1]})      _ScenarioManager._create(scenario_config_1)        scenario_config_1.add_sequences({\"sequence_3\": [task_config_1, task_config_2]})      with pytest.raises(SequenceTaskConfigDoesNotExistInSameScenarioConfig) as err:          _ScenarioManager._create(scenario_config_1)      assert err.value.args == ([task_config_2.id], \"sequence_3\", scenario_config_1.id)        scenario_config_1._tasks = [task_config_1, task_config_2]      _ScenarioManager._create(scenario_config_1)      def test_get_all_on_multiple_versions_environment():      # Create 5 scenarios with 2 versions each      # Only version 1.0 has the scenario with config_id = \"config_id_1\"      # Only version 2.0 has the scenario with config_id = \"config_id_6\"      for version in range(1, 3):          for i in range(5):              _ScenarioManager._set(                  Scenario(f\"config_id_{i+version}\", [], {}, [], ScenarioId(f\"id{i}_v{version}\"), version=f\"{version}.0\")              )        _VersionManager._set_experiment_version(\"1.0\")      assert len(_ScenarioManager._get_all()) == 5      assert len(_ScenarioManager._get_all_by(filters=[{\"version\": \"1.0\", \"config_id\": \"config_id_1\"}])) == 1      assert len(_ScenarioManager._get_all_by(filters=[{\"version\": \"1.0\", \"config_id\": \"config_id_6\"}])) == 0        _VersionManager._set_experiment_version(\"2.0\")      assert len(_ScenarioManager._get_all()) == 5      assert len(_ScenarioManager._get_all_by(filters=[{\"version\": \"2.0\", \"config_id\": \"config_id_1\"}])) == 0      assert len(_ScenarioManager._get_all_by(filters=[{\"version\": \"2.0\", \"config_id\": \"config_id_6\"}])) == 1        _VersionManager._set_development_version(\"1.0\")      assert len(_ScenarioManager._get_all()) == 5      assert len(_ScenarioManager._get_all_by(filters=[{\"version\": \"1.0\", \"config_id\": \"config_id_1\"}])) == 1      assert len(_ScenarioManager._get_all_by(filters=[{\"version\": \"1.0\", \"config_id\": \"config_id_6\"}])) == 0        _VersionManager._set_development_version(\"2.0\")      assert len(_ScenarioManager._get_all()) == 5      assert len(_ScenarioManager._get_all_by(filters=[{\"version\": \"2.0\", \"config_id\": \"config_id_1\"}])) == 0      assert len(_ScenarioManager._get_all_by(filters=[{\"version\": \"2.0\", \"config_id\": \"config_id_6\"}])) == 1      def test_create_scenario_does_not_modify_config():      Config.configure_job_executions(mode=JobConfig._DEVELOPMENT_MODE)        creation_date_1 = datetime.now()      name_1 = \"name_1\"      scenario_config = Config.configure_scenario(\"sc\", None, None, Frequency.DAILY)      assert scenario_config.properties.get(\"name\") is None      assert len(scenario_config.properties) == 0        _OrchestratorFactory._build_dispatcher()        scenario = _ScenarioManager._create(scenario_config, creation_date=creation_date_1, name=name_1)      assert len(scenario_config.properties) == 0      assert len(scenario.properties) == 1      assert scenario.properties.get(\"name\") == name_1      assert scenario.name == name_1        scenario.properties[\"foo\"] = \"bar\"      _ScenarioManager._set(scenario)      assert len(scenario_config.properties) == 0      assert len(scenario.properties) == 2      assert scenario.properties.get(\"foo\") == \"bar\"      assert scenario.properties.get(\"name\") == name_1      assert scenario.name == name_1        scenario_2 = _ScenarioManager._create(scenario_config, creation_date=creation_date_1)      assert scenario_2.name is None      def test_create_and_delete_scenario():      Config.configure_job_executions(mode=JobConfig._DEVELOPMENT_MODE)        creation_date_1 = datetime.now()      creation_date_2 = creation_date_1 + timedelta(minutes=10)        name_1 = \"name_1\"        _ScenarioManager._delete_all()      assert len(_ScenarioManager._get_all()) == 0        scenario_config = Config.configure_scenario(\"sc\", None, None, Frequency.DAILY)        _OrchestratorFactory._build_dispatcher()        scenario_1 = _ScenarioManager._create(scenario_config, creation_date=creation_date_1, name=name_1)      assert scenario_1.config_id == \"sc\"      assert scenario_1.sequences == {}      assert scenario_1.tasks == {}      assert scenario_1.additional_data_nodes == {}      assert scenario_1.data_nodes == {}      assert scenario_1.cycle.frequency == Frequency.DAILY      assert scenario_1.is_primary      assert scenario_1.cycle.creation_date == creation_date_1      assert scenario_1.cycle.start_date.date() == creation_date_1.date()      assert scenario_1.cycle.end_date.date() == creation_date_1.date()      assert scenario_1.creation_date == creation_date_1      assert scenario_1.name == name_1      assert scenario_1.properties[\"name\"] == name_1      assert scenario_1.tags == set()        cycle_id_1 = scenario_1.cycle.id      assert _CycleManager._get(cycle_id_1).id == cycle_id_1      _ScenarioManager._delete(scenario_1.id)      assert _ScenarioManager._get(scenario_1.id) is None      assert _CycleManager._get(cycle_id_1) is None        # Recreate scenario_1      scenario_1 = _ScenarioManager._create(scenario_config, creation_date=creation_date_1, name=name_1)        scenario_2 = _ScenarioManager._create(scenario_config, creation_date=creation_date_2)      assert scenario_2.config_id == \"sc\"      assert scenario_2.sequences == {}      assert scenario_2.tasks == {}      assert scenario_2.additional_data_nodes == {}      assert scenario_2.data_nodes == {}      assert scenario_2.cycle.frequency == Frequency.DAILY      assert not scenario_2.is_primary      assert scenario_2.cycle.creation_date == creation_date_1      assert scenario_2.cycle.start_date.date() == creation_date_2.date()      assert scenario_2.cycle.end_date.date() == creation_date_2.date()      assert scenario_2.properties.get(\"name\") is None      assert scenario_2.tags == set()        assert scenario_1 != scenario_2      assert scenario_1.cycle == scenario_2.cycle        assert len(_ScenarioManager._get_all()) == 2      with pytest.raises(DeletingPrimaryScenario):          _ScenarioManager._delete(              scenario_1.id,          )        _ScenarioManager._delete(          scenario_2.id,      )      assert len(_ScenarioManager._get_all()) == 1      _ScenarioManager._delete(scenario_1.id)      assert len(_ScenarioManager._get_all()) == 0      def test_is_deletable():      assert len(_ScenarioManager._get_all()) == 0      scenario_config = Config.configure_scenario(\"sc\", None, None, Frequency.DAILY)      creation_date = datetime.now()      scenario_1_primary = _ScenarioManager._create(scenario_config, creation_date=creation_date, name=\"1\")      scenario_2 = _ScenarioManager._create(scenario_config, creation_date=creation_date, name=\"2\")        assert len(_ScenarioManager._get_all()) == 2      assert scenario_1_primary.is_primary      assert not _ScenarioManager._is_deletable(scenario_1_primary)      assert not _ScenarioManager._is_deletable(scenario_1_primary.id)      assert not scenario_2.is_primary      assert _ScenarioManager._is_deletable(scenario_2)      assert _ScenarioManager._is_deletable(scenario_2.id)        _ScenarioManager._hard_delete(scenario_2.id)      del scenario_2        assert len(_ScenarioManager._get_all()) == 1      assert scenario_1_primary.is_primary      assert _ScenarioManager._is_deletable(scenario_1_primary)      assert _ScenarioManager._is_deletable(scenario_1_primary.id)      def test_assign_scenario_as_parent_of_task_and_additional_data_nodes():        dn_config_1 = Config.configure_data_node(\"dn_1\", \"in_memory\", scope=Scope.GLOBAL)      dn_config_2 = Config.configure_data_node(\"dn_2\", \"in_memory\", scope=Scope.GLOBAL)      dn_config_3 = Config.configure_data_node(\"dn_3\", \"in_memory\", scope=Scope.SCENARIO)      additional_dn_config_1 = Config.configure_data_node(\"additional_dn_1\", \"in_memory\", scope=Scope.GLOBAL)      additional_dn_config_2 = Config.configure_data_node(\"additional_dn_2\", \"in_memory\", scope=Scope.SCENARIO)      task_config_1 = Config.configure_task(\"task_1\", print, [dn_config_1], [dn_config_2])      task_config_2 = Config.configure_task(\"task_2\", print, [dn_config_2], [dn_config_3])      task_config_3 = Config.configure_task(\"task_3\", print, [dn_config_2], [dn_config_3])      scenario_config_1 = Config.configure_scenario(          \"scenario_1\", [task_config_1, task_config_2], [additional_dn_config_1, additional_dn_config_2]      )      scenario_config_1.add_sequences({\"sequence_1\": [task_config_1, task_config_2]})      scenario_config_2 = Config.configure_scenario(          \"scenario_2\", [task_config_1, task_config_2, task_config_3], [additional_dn_config_1, additional_dn_config_2]      )      scenario_config_2.add_sequences(          {\"sequence_1\": [task_config_1, task_config_2], \"sequence_2\": [task_config_1, task_config_3]}      )        scenario_1 = _ScenarioManager._create(scenario_config_1)      sequence_1_s1 = scenario_1.sequences[\"sequence_1\"]        assert all([sequence.parent_ids == {scenario_1.id} for sequence in scenario_1.sequences.values()])      tasks = scenario_1.tasks.values()      assert all([task.parent_ids == {scenario_1.id, sequence_1_s1.id} for task in tasks])      data_nodes = {}      for task in tasks:          data_nodes.update(task.data_nodes)      assert data_nodes[\"dn_1\"].parent_ids == {scenario_1.tasks[\"task_1\"].id}      assert data_nodes[\"dn_2\"].parent_ids == {scenario_1.tasks[\"task_1\"].id, scenario_1.tasks[\"task_2\"].id}      assert data_nodes[\"dn_3\"].parent_ids == {scenario_1.tasks[\"task_2\"].id}      additional_data_nodes = scenario_1.additional_data_nodes      assert additional_data_nodes[\"additional_dn_1\"].parent_ids == {scenario_1.id}      assert additional_data_nodes[\"additional_dn_2\"].parent_ids == {scenario_1.id}        scenario_2 = _ScenarioManager._create(scenario_config_2)      sequence_1_s2 = scenario_2.sequences[\"sequence_1\"]      sequence_2_s2 = scenario_2.sequences[\"sequence_2\"]        assert all([sequence.parent_ids == {scenario_2.id} for sequence in scenario_2.sequences.values()])      assert scenario_1.tasks[\"task_1\"] == scenario_2.tasks[\"task_1\"]      assert scenario_1.tasks[\"task_1\"].parent_ids == {          scenario_1.id,          sequence_1_s1.id,          scenario_2.id,          sequence_1_s2.id,          sequence_2_s2.id,      }      assert scenario_1.tasks[\"task_2\"].parent_ids == {scenario_1.id, sequence_1_s1.id}      assert scenario_2.tasks[\"task_2\"].parent_ids == {scenario_2.id, sequence_1_s2.id}      assert scenario_2.tasks[\"task_3\"].parent_ids == {scenario_2.id, sequence_2_s2.id}      additional_data_nodes = scenario_2.additional_data_nodes      assert additional_data_nodes[\"additional_dn_1\"].parent_ids == {scenario_1.id, scenario_2.id}      assert additional_data_nodes[\"additional_dn_2\"].parent_ids == {scenario_2.id}        _ScenarioManager._hard_delete(scenario_1.id)      _ScenarioManager._hard_delete(scenario_2.id)      _TaskManager._delete_all()      _DataManager._delete_all()        dn_config_1 = Config.configure_data_node(\"dn_1\", \"in_memory\", scope=Scope.GLOBAL)      dn_config_2 = Config.configure_data_node(\"dn_2\", \"in_memory\", scope=Scope.GLOBAL)      dn_config_3 = Config.configure_data_node(\"dn_3\", \"in_memory\", scope=Scope.GLOBAL)      additional_dn_config_1 = Config.configure_data_node(\"additional_dn_1\", \"in_memory\", scope=Scope.GLOBAL)      additional_dn_config_2 = Config.configure_data_node(\"additional_dn_2\", \"in_memory\", scope=Scope.GLOBAL)      task_config_1 = Config.configure_task(\"task_1\", print, [dn_config_1], [dn_config_2])      task_config_2 = Config.configure_task(\"task_2\", print, [dn_config_2], [dn_config_3])      task_config_3 = Config.configure_task(\"task_3\", print, [dn_config_2], [dn_config_3])      scenario_config_1 = Config.configure_scenario(          \"scenario_1\", [task_config_1, task_config_2], [additional_dn_config_1, additional_dn_config_2]      )      scenario_config_1.add_sequences({\"sequence_1\": [task_config_1, task_config_2]})      scenario_config_2 = Config.configure_scenario(          \"scenario_2\", [task_config_1, task_config_2, task_config_3], [additional_dn_config_1, additional_dn_config_2]      )      scenario_config_2.add_sequences(          {\"sequence_1\": [task_config_1, task_config_2], \"sequence_2\": [task_config_1, task_config_3]}      )        scenario_1 = _ScenarioManager._create(scenario_config_1)      sequence_1_s1 = scenario_1.sequences[\"sequence_1\"]      assert scenario_1.sequences[\"sequence_1\"].parent_ids == {scenario_1.id}      tasks = scenario_1.tasks.values()      assert all([task.parent_ids == {scenario_1.id, sequence_1_s1.id} for task in tasks])      data_nodes = {}      for task in tasks:          data_nodes.update(task.data_nodes)      assert data_nodes[\"dn_1\"].parent_ids == {scenario_1.tasks[\"task_1\"].id}      assert data_nodes[\"dn_2\"].parent_ids == {scenario_1.tasks[\"task_1\"].id, scenario_1.tasks[\"task_2\"].id}      assert data_nodes[\"dn_3\"].parent_ids == {scenario_1.tasks[\"task_2\"].id}      additional_data_nodes = scenario_1.additional_data_nodes      assert additional_data_nodes[\"additional_dn_1\"].parent_ids == {scenario_1.id}      assert additional_data_nodes[\"additional_dn_2\"].parent_ids == {scenario_1.id}        scenario_2 = _ScenarioManager._create(scenario_config_2)      sequence_1_s2 = scenario_2.sequences[\"sequence_1\"]      sequence_2_s2 = scenario_2.sequences[\"sequence_2\"]        assert scenario_1.sequences[\"sequence_1\"].parent_ids == {scenario_1.id}      assert scenario_2.sequences[\"sequence_1\"].parent_ids == {scenario_2.id}      assert scenario_2.sequences[\"sequence_2\"].parent_ids == {scenario_2.id}      tasks = {**scenario_1.tasks, **scenario_2.tasks}      assert tasks[\"task_1\"].parent_ids == {          scenario_1.id,          scenario_2.id,          sequence_1_s1.id,          sequence_1_s2.id,          sequence_2_s2.id,      }      assert tasks[\"task_2\"].parent_ids == {scenario_1.id, scenario_2.id, sequence_1_s1.id, sequence_1_s2.id}      assert tasks[\"task_3\"].parent_ids == {scenario_2.id, sequence_2_s2.id}      additional_data_nodes = scenario_2.additional_data_nodes      assert additional_data_nodes[\"additional_dn_1\"].parent_ids == {scenario_1.id, scenario_2.id}      assert additional_data_nodes[\"additional_dn_2\"].parent_ids == {scenario_1.id, scenario_2.id}      def mult_by_2(nb: int):      return nb * 2      def mult_by_3(nb: int):      return nb * 3      def mult_by_4(nb: int):      return nb * 4      def test_scenario_manager_only_creates_data_node_once():      Config.configure_job_executions(mode=JobConfig._DEVELOPMENT_MODE)        # dn_1 ---> mult_by_2 ---> dn_2 ---> mult_by_3 ---> dn_6      # dn_1 ---> mult_by_4 ---> dn_4        dn_config_1 = Config.configure_data_node(\"foo\", \"in_memory\", Scope.GLOBAL, default_data=1)      dn_config_2 = Config.configure_data_node(\"bar\", \"in_memory\", Scope.CYCLE, default_data=0)      dn_config_6 = Config.configure_data_node(\"baz\", \"in_memory\", Scope.CYCLE, default_data=0)      dn_config_4 = Config.configure_data_node(\"qux\", \"in_memory\", Scope.SCENARIO, default_data=0)      task_mult_by_2_config = Config.configure_task(\"mult_by_2\", mult_by_2, [dn_config_1], dn_config_2)      task_mult_by_3_config = Config.configure_task(\"mult_by_3\", mult_by_3, [dn_config_2], dn_config_6)      task_mult_by_4_config = Config.configure_task(\"mult_by_4\", mult_by_4, [dn_config_1], dn_config_4)      scenario_config = Config.configure_scenario(          \"awesome_scenario\", [task_mult_by_2_config, task_mult_by_3_config, task_mult_by_4_config], None, Frequency.DAILY      )      scenario_config.add_sequences(          {\"by_6\": [task_mult_by_2_config, task_mult_by_3_config], \"by_4\": [task_mult_by_4_config]}      )        _OrchestratorFactory._build_dispatcher()        assert len(_DataManager._get_all()) == 0      assert len(_TaskManager._get_all()) == 0      assert len(_SequenceManager._get_all()) == 0      assert len(_ScenarioManager._get_all()) == 0      assert len(_CycleManager._get_all()) == 0        scenario_1 = _ScenarioManager._create(scenario_config)        assert len(_DataManager._get_all()) == 4      assert len(_TaskManager._get_all()) == 3      assert len(_SequenceManager._get_all()) == 2      assert len(_ScenarioManager._get_all()) == 1      assert scenario_1.foo.read() == 1      assert scenario_1.bar.read() == 0      assert scenario_1.baz.read() == 0      assert scenario_1.qux.read() == 0      assert scenario_1.by_6._get_sorted_tasks()[0][0].config_id == task_mult_by_2_config.id      assert scenario_1.by_6._get_sorted_tasks()[1][0].config_id == task_mult_by_3_config.id      assert scenario_1.by_4._get_sorted_tasks()[0][0].config_id == task_mult_by_4_config.id      assert scenario_1.tasks.keys() == {task_mult_by_2_config.id, task_mult_by_3_config.id, task_mult_by_4_config.id}        scenario_1_sorted_tasks = scenario_1._get_sorted_tasks()      expected = [{task_mult_by_2_config.id, task_mult_by_4_config.id}, {task_mult_by_3_config.id}]      for i, list_tasks_by_level in enumerate(scenario_1_sorted_tasks):          assert set([t.config_id for t in list_tasks_by_level]) == expected[i]      assert scenario_1.cycle.frequency == Frequency.DAILY        _ScenarioManager._create(scenario_config)        assert len(_DataManager._get_all()) == 5      assert len(_TaskManager._get_all()) == 4      assert len(_SequenceManager._get_all()) == 4      assert len(_ScenarioManager._get_all()) == 2      def test_notification_subscribe(mocker):      Config.configure_job_executions(mode=JobConfig._DEVELOPMENT_MODE)        mocker.patch(\"src.taipy.core._entity._reload._Reloader._reload\", side_effect=lambda m, o: o)        scenario_config = Config.configure_scenario(          \"awesome_scenario\",          [              Config.configure_task(                  \"mult_by_2\",                  mult_by_2,                  [Config.configure_data_node(\"foo\", \"in_memory\", Scope.SCENARIO, default_data=1)],                  Config.configure_data_node(\"bar\", \"in_memory\", Scope.SCENARIO, default_data=0),              )          ],      )        _OrchestratorFactory._build_dispatcher()        scenario = _ScenarioManager._create(scenario_config)        notify_1 = NotifyMock(scenario)      notify_2 = NotifyMock(scenario)      mocker.patch.object(_utils, \"_load_fct\", side_effect=[notify_1, notify_2])        # test subscribing notification      _ScenarioManager._subscribe(callback=notify_1, scenario=scenario)      _ScenarioManager._submit(scenario)      notify_1.assert_called_3_times()        notify_1.reset()        # test unsubscribing notification      # test notis subscribe only on new jobs      # _ScenarioManager._get(scenario)      _ScenarioManager._unsubscribe(callback=notify_1, scenario=scenario)      _ScenarioManager._subscribe(callback=notify_2, scenario=scenario)      _ScenarioManager._submit(scenario)        notify_1.assert_not_called()      notify_2.assert_called_3_times()      class Notify:      def __call__(self, *args, **kwargs):          self.args = args        def assert_called_with(self, args):          assert args in self.args      def test_notification_subscribe_multiple_params(mocker):      Config.configure_job_executions(mode=JobConfig._DEVELOPMENT_MODE)        mocker.patch(\"src.taipy.core._entity._reload._Reloader._reload\", side_effect=lambda m, o: o)        scenario_config = Config.configure_scenario(          \"awesome_scenario\",          [              Config.configure_task(                  \"mult_by_2\",                  mult_by_2,                  [Config.configure_data_node(\"foo\", \"in_memory\", Scope.SCENARIO, default_data=1)],                  Config.configure_data_node(\"bar\", \"in_memory\", Scope.SCENARIO, default_data=0),              )          ],      )      notify = mocker.Mock()        _OrchestratorFactory._build_dispatcher()        scenario = _ScenarioManager._create(scenario_config)      _ScenarioManager._subscribe(callback=notify, params=[\"foobar\", 123, 1.2], scenario=scenario)      mocker.patch.object(_ScenarioManager, \"_get\", return_value=scenario)        _ScenarioManager._submit(scenario)        notify.assert_called_with(\"foobar\", 123, 1.2, scenario, ANY)      def notify_multi_param(param, *args):      assert len(param) == 3      def notify1(*args, **kwargs):      ...      def notify2(*args, **kwargs):      ...      def test_notification_unsubscribe(mocker):      Config.configure_job_executions(mode=JobConfig._DEVELOPMENT_MODE)        mocker.patch(\"src.taipy.core._entity._reload._Reloader._reload\", side_effect=lambda m, o: o)        scenario_config = Config.configure_scenario(          \"awesome_scenario\",          [              Config.configure_task(                  \"mult_by_2\",                  mult_by_2,                  [Config.configure_data_node(\"foo\", \"in_memory\", Scope.SCENARIO, default_data=1)],                  Config.configure_data_node(\"bar\", \"in_memory\", Scope.SCENARIO, default_data=0),              )          ],      )        _OrchestratorFactory._build_dispatcher()        scenario = _ScenarioManager._create(scenario_config)        notify_1 = notify1      notify_2 = notify2        # test subscribing notification      _ScenarioManager._subscribe(callback=notify_1, scenario=scenario)      _ScenarioManager._unsubscribe(callback=notify_1, scenario=scenario)      _ScenarioManager._subscribe(callback=notify_2, scenario=scenario)      _ScenarioManager._submit(scenario.id)        with pytest.raises(ValueError):          _ScenarioManager._unsubscribe(callback=notify_1, scenario=scenario)      _ScenarioManager._unsubscribe(callback=notify_2, scenario=scenario)      def test_notification_unsubscribe_multi_param():      Config.configure_job_executions(mode=JobConfig._DEVELOPMENT_MODE)        scenario_config = Config.configure_scenario(          \"awesome_scenario\",          [              Config.configure_task(                  \"mult_by_2\",                  mult_by_2,                  [Config.configure_data_node(\"foo\", \"in_memory\", Scope.SCENARIO, default_data=1)],                  Config.configure_data_node(\"bar\", \"in_memory\", Scope.SCENARIO, default_data=0),              )          ],      )        _OrchestratorFactory._build_dispatcher()        scenario = _ScenarioManager._create(scenario_config)        # test subscribing notification      _ScenarioManager._subscribe(callback=notify_multi_param, params=[\"foobar\", 123, 0], scenario=scenario)      _ScenarioManager._subscribe(callback=notify_multi_param, params=[\"foobar\", 123, 1], scenario=scenario)      _ScenarioManager._subscribe(callback=notify_multi_param, params=[\"foobar\", 123, 2], scenario=scenario)        assert len(scenario.subscribers) == 3        # if no params are passed, removes the first occurrence of the subscriber when theres more than one copy      scenario.unsubscribe(notify_multi_param)      assert len(scenario.subscribers) == 2      assert _Subscriber(notify_multi_param, [\"foobar\", 123, 0]) not in scenario.subscribers        # If params are passed, find the corresponding pair of callback and params to remove      scenario.unsubscribe(notify_multi_param, [\"foobar\", 123, 2])      assert len(scenario.subscribers) == 1      assert _Subscriber(notify_multi_param, [\"foobar\", 123, 2]) not in scenario.subscribers        # If params are passed but is not on the list of subscribers, throws a ValueErrors      with pytest.raises(ValueError):          scenario.unsubscribe(notify_multi_param, [\"foobar\", 123, 10000])      def test_scenario_notification_subscribe_all():      Config.configure_job_executions(mode=JobConfig._DEVELOPMENT_MODE)        scenario_config = Config.configure_scenario(          \"awesome_scenario\",          [              Config.configure_task(                  \"mult_by_2\",                  mult_by_2,                  [Config.configure_data_node(\"foo\", \"in_memory\", Scope.SCENARIO, default_data=1)],                  Config.configure_data_node(\"bar\", \"in_memory\", Scope.SCENARIO, default_data=0),              )          ],      )      other_scenario_config = Config.configure_scenario(          \"other_scenario\",          [              Config.configure_task(                  \"other_mult_by_2_2\",                  mult_by_2,                  [Config.configure_data_node(\"other_foo\", \"in_memory\", Scope.SCENARIO, default_data=1)],                  Config.configure_data_node(\"other_bar\", \"in_memory\", Scope.SCENARIO, default_data=0),              )          ],      )      _OrchestratorFactory._build_dispatcher()      scenario = _ScenarioManager._create(scenario_config)      other_scenario = _ScenarioManager._create(other_scenario_config)      notify_1 = NotifyMock(scenario)      _ScenarioManager._subscribe(notify_1)      assert len(_ScenarioManager._get(scenario.id).subscribers) == 1      assert len(_ScenarioManager._get(other_scenario.id).subscribers) == 1      def test_is_promotable_to_primary_scenario():      assert len(_ScenarioManager._get_all()) == 0      scenario_config = Config.configure_scenario(\"sc\", set(), set(), Frequency.DAILY)      creation_date = datetime.now()      scenario_1 = _ScenarioManager._create(scenario_config, creation_date=creation_date, name=\"1\")  # primary scenario      scenario_2 = _ScenarioManager._create(scenario_config, creation_date=creation_date, name=\"2\")        assert len(_ScenarioManager._get_all()) == 2      assert scenario_1.is_primary      assert not _ScenarioManager._is_promotable_to_primary(scenario_1)      assert not _ScenarioManager._is_promotable_to_primary(scenario_1.id)      assert not scenario_2.is_primary      assert _ScenarioManager._is_promotable_to_primary(scenario_2)      assert _ScenarioManager._is_promotable_to_primary(scenario_2.id)        _ScenarioManager._set_primary(scenario_2)        assert len(_ScenarioManager._get_all()) == 2      assert not scenario_1.is_primary      assert _ScenarioManager._is_promotable_to_primary(scenario_1)      assert _ScenarioManager._is_promotable_to_primary(scenario_1.id)      assert scenario_2.is_primary      assert not _ScenarioManager._is_promotable_to_primary(scenario_2)      assert not _ScenarioManager._is_promotable_to_primary(scenario_2.id)      def test_get_set_primary_scenario():      Config.configure_job_executions(mode=JobConfig._DEVELOPMENT_MODE)      _OrchestratorFactory._build_dispatcher()        cycle_1 = _CycleManager._create(Frequency.DAILY, name=\"foo\")        scenario_1 = Scenario(\"sc_1\", [], {}, ScenarioId(\"sc_1\"), is_primary=False, cycle=cycle_1)      scenario_2 = Scenario(\"sc_2\", [], {}, ScenarioId(\"sc_2\"), is_primary=False, cycle=cycle_1)        _ScenarioManager._delete_all()      _CycleManager._delete_all()        assert len(_ScenarioManager._get_all()) == 0      assert len(_CycleManager._get_all()) == 0        _CycleManager._set(cycle_1)        _ScenarioManager._set(scenario_1)      _ScenarioManager._set(scenario_2)        assert len(_ScenarioManager._get_primary_scenarios()) == 0      assert len(_ScenarioManager._get_all_by_cycle(cycle_1)) == 2        _ScenarioManager._set_primary(scenario_1)        assert len(_ScenarioManager._get_primary_scenarios()) == 1      assert len(_ScenarioManager._get_all_by_cycle(cycle_1)) == 2      assert _ScenarioManager._get_primary(cycle_1) == scenario_1        _ScenarioManager._set_primary(scenario_2)        assert len(_ScenarioManager._get_primary_scenarios()) == 1      assert len(_ScenarioManager._get_all_by_cycle(cycle_1)) == 2      assert _ScenarioManager._get_primary(cycle_1) == scenario_2      def test_hard_delete_one_single_scenario_with_scenario_data_nodes():      Config.configure_job_executions(mode=JobConfig._DEVELOPMENT_MODE)        dn_input_config = Config.configure_data_node(\"my_input\", \"in_memory\", scope=Scope.SCENARIO, default_data=\"testing\")      dn_output_config = Config.configure_data_node(\"my_output\", \"in_memory\", scope=Scope.SCENARIO)      task_config = Config.configure_task(\"task_config\", print, dn_input_config, dn_output_config)      scenario_config = Config.configure_scenario(\"scenario_config\", [task_config])      scenario_config.add_sequences({\"sequence_config\": [task_config]})        _OrchestratorFactory._build_dispatcher()        scenario = _ScenarioManager._create(scenario_config)      _ScenarioManager._submit(scenario.id)        assert len(_ScenarioManager._get_all()) == 1      assert len(_SequenceManager._get_all()) == 1      assert len(_TaskManager._get_all()) == 1      assert len(_DataManager._get_all()) == 2      assert len(_JobManager._get_all()) == 1      _ScenarioManager._hard_delete(scenario.id)      assert len(_ScenarioManager._get_all()) == 0      assert len(_SequenceManager._get_all()) == 0      assert len(_TaskManager._get_all()) == 0      assert len(_DataManager._get_all()) == 0      assert len(_JobManager._get_all()) == 0      def test_hard_delete_one_scenario_among_two_with_scenario_data_nodes():      Config.configure_job_executions(mode=JobConfig._DEVELOPMENT_MODE)        dn_input_config = Config.configure_data_node(\"my_input\", \"in_memory\", scope=Scope.SCENARIO, default_data=\"testing\")      dn_output_config = Config.configure_data_node(\"my_output\", \"in_memory\", scope=Scope.SCENARIO)      task_config = Config.configure_task(\"task_config\", print, dn_input_config, dn_output_config)      scenario_config = Config.configure_scenario(\"scenario_config\", [task_config])      scenario_config.add_sequences({\"sequence_config\": [task_config]})        _OrchestratorFactory._build_dispatcher()        scenario_1 = _ScenarioManager._create(scenario_config)      scenario_2 = _ScenarioManager._create(scenario_config)      _ScenarioManager._submit(scenario_1.id)      _ScenarioManager._submit(scenario_2.id)        assert len(_ScenarioManager._get_all()) == 2      assert len(_SequenceManager._get_all()) == 2      assert len(_TaskManager._get_all()) == 2      assert len(_DataManager._get_all()) == 4      assert len(_JobManager._get_all()) == 2      _ScenarioManager._hard_delete(scenario_1.id)      assert len(_ScenarioManager._get_all()) == 1      assert len(_SequenceManager._get_all()) == 1      assert len(_TaskManager._get_all()) == 1      assert len(_DataManager._get_all()) == 2      assert len(_JobManager._get_all()) == 1      assert _ScenarioManager._get(scenario_2.id) is not None      def test_hard_delete_one_scenario_among_two_with_cycle_data_nodes():      Config.configure_job_executions(mode=JobConfig._DEVELOPMENT_MODE)        dn_input_config = Config.configure_data_node(\"my_input\", \"in_memory\", scope=Scope.CYCLE, default_data=\"testing\")      dn_output_config = Config.configure_data_node(\"my_output\", \"in_memory\", scope=Scope.CYCLE)      task_config = Config.configure_task(\"task_config\", print, dn_input_config, dn_output_config)      scenario_config = Config.configure_scenario(\"scenario_config\", [task_config])      scenario_config.add_sequences({\"sequence_config\": [task_config]})        _OrchestratorFactory._build_dispatcher()        scenario_1 = _ScenarioManager._create(scenario_config)      scenario_2 = _ScenarioManager._create(scenario_config)      _ScenarioManager._submit(scenario_1.id)      _ScenarioManager._submit(scenario_2.id)        assert len(_ScenarioManager._get_all()) == 2      assert len(_SequenceManager._get_all()) == 2      assert len(_TaskManager._get_all()) == 1      assert len(_DataManager._get_all()) == 2      assert len(_JobManager._get_all()) == 2      _ScenarioManager._hard_delete(scenario_1.id)      assert len(_ScenarioManager._get_all()) == 1      assert len(_SequenceManager._get_all()) == 1      assert len(_TaskManager._get_all()) == 1      assert len(_DataManager._get_all()) == 2      assert len(_JobManager._get_all()) == 2      assert _ScenarioManager._get(scenario_2.id) is not None      def test_hard_delete_shared_entities():      Config.configure_job_executions(mode=JobConfig._DEVELOPMENT_MODE)        dn_config_1 = Config.configure_data_node(\"my_input_1\", \"in_memory\", scope=Scope.CYCLE, default_data=\"testing\")      dn_config_2 = Config.configure_data_node(\"my_input_2\", \"in_memory\", scope=Scope.SCENARIO, default_data=\"testing\")      dn_config_3 = Config.configure_data_node(\"my_input_3\", \"in_memory\", scope=Scope.GLOBAL, default_data=\"testing\")      dn_config_4 = Config.configure_data_node(\"my_input_4\", \"in_memory\", scope=Scope.GLOBAL, default_data=\"testing\")      task_config_1 = Config.configure_task(\"task_config_1\", print, dn_config_1, dn_config_2)      task_config_2 = Config.configure_task(\"task_config_2\", print, dn_config_2, dn_config_3)      task_config_3 = Config.configure_task(\"task_config_3\", print, dn_config_3, dn_config_4)  # scope = global      task_config_4 = Config.configure_task(\"task_config_4\", print, dn_config_1)  # scope = cycle      scenario_config_1 = Config.configure_scenario(          \"scenario_config_1\",          [task_config_1, task_config_2, task_config_3, task_config_4],          frequency=Frequency.WEEKLY,      )      scenario_config_1.add_sequences(          {              \"sequence_config_1\": [task_config_1, task_config_2],              \"sequence_config_2\": [task_config_1, task_config_2],              \"sequence_config_3\": [task_config_3],              \"sequence_config_4\": [task_config_4],          }      )        _OrchestratorFactory._build_dispatcher()        scenario_1 = _ScenarioManager._create(scenario_config_1)      scenario_2 = _ScenarioManager._create(scenario_config_1)      scenario_1.submit()      scenario_2.submit()        assert len(_CycleManager._get_all()) == 1      assert len(_ScenarioManager._get_all()) == 2      assert len(_SequenceManager._get_all()) == 8      assert len(_TaskManager._get_all()) == 6      assert len(_DataManager._get_all()) == 5      assert len(_JobManager._get_all()) == 8      _ScenarioManager._hard_delete(scenario_2.id)      assert len(_CycleManager._get_all()) == 1      assert len(_ScenarioManager._get_all()) == 1      assert len(_SequenceManager._get_all()) == 4      assert len(_TaskManager._get_all()) == 4      assert len(_DataManager._get_all()) == 4      assert len(_JobManager._get_all()) == 6      def test_is_submittable():      assert len(_ScenarioManager._get_all()) == 0        dn_config = Config.configure_in_memory_data_node(\"dn\", 10)      task_config = Config.configure_task(\"task\", print, [dn_config])      scenario_config = Config.configure_scenario(\"sc\", set([task_config]), set(), Frequency.DAILY)      scenario = _ScenarioManager._create(scenario_config)        assert len(_ScenarioManager._get_all()) == 1      assert _ScenarioManager._is_submittable(scenario)      assert _ScenarioManager._is_submittable(scenario.id)      assert not _ScenarioManager._is_submittable(\"Scenario_temp\")        scenario.dn.edit_in_progress = True      assert not _ScenarioManager._is_submittable(scenario)      assert not _ScenarioManager._is_submittable(scenario.id)        scenario.dn.edit_in_progress = False      assert _ScenarioManager._is_submittable(scenario)      assert _ScenarioManager._is_submittable(scenario.id)      def test_submit():      Config.configure_job_executions(mode=JobConfig._DEVELOPMENT_MODE)      _OrchestratorFactory._build_dispatcher()        data_node_1 = InMemoryDataNode(\"foo\", Scope.SCENARIO, \"s1\")      data_node_2 = InMemoryDataNode(\"bar\", Scope.SCENARIO, \"s2\")      data_node_3 = InMemoryDataNode(\"baz\", Scope.SCENARIO, \"s3\")      data_node_4 = InMemoryDataNode(\"qux\", Scope.SCENARIO, \"s4\")      data_node_5 = InMemoryDataNode(\"quux\", Scope.SCENARIO, \"s5\")      data_node_6 = InMemoryDataNode(\"quuz\", Scope.SCENARIO, \"s6\")      data_node_7 = InMemoryDataNode(\"corge\", Scope.SCENARIO, \"s7\")      data_node_8 = InMemoryDataNode(\"fum\", Scope.SCENARIO, \"s8\")      task_1 = Task(          \"grault\",          {},          print,          [data_node_1, data_node_2],          [data_node_3, data_node_4],          TaskId(\"t1\"),      )      task_2 = Task(\"garply\", {}, print, [data_node_3], [data_node_5], TaskId(\"t2\"))      task_3 = Task(\"waldo\", {}, print, [data_node_5, data_node_4], [data_node_6], TaskId(\"t3\"))      task_4 = Task(\"fred\", {}, print, [data_node_4], [data_node_7], TaskId(\"t4\"))      task_5 = Task(\"thud\", {}, print, [data_node_6], [data_node_8], TaskId(\"t5\"))        scenario = Scenario(          \"scenario_name\",          [task_5, task_4, task_2, task_1, task_3],          {},          [],          ScenarioId(\"sce_id\"),      )        class MockOrchestrator(_Orchestrator):          submit_calls = []            @classmethod          def _lock_dn_output_and_create_job(              cls,              task: Task,              submit_id: str,              submit_entity_id: str,              callbacks: Optional[Iterable[Callable]] = None,              force: bool = False,          ) -> Job:              cls.submit_calls.append(task.id)              return super()._lock_dn_output_and_create_job(task, submit_id, submit_entity_id, callbacks, force)        with patch(\"src.taipy.core.task._task_manager._TaskManager._orchestrator\", new=MockOrchestrator):          with pytest.raises(NonExistingScenario):              _ScenarioManager._submit(scenario.id)          with pytest.raises(NonExistingScenario):              _ScenarioManager._submit(scenario)            # scenario and sequence do exist, but tasks does not exist.          # We expect an exception to be raised          _ScenarioManager._set(scenario)          with pytest.raises(NonExistingTask):              _ScenarioManager._submit(scenario.id)          with pytest.raises(NonExistingTask):              _ScenarioManager._submit(scenario)            # scenario, sequence, and tasks do exist.          # We expect all the tasks to be submitted once,          # and respecting specific constraints on the order          _TaskManager._set(task_1)          _TaskManager._set(task_2)          _TaskManager._set(task_3)          _TaskManager._set(task_4)          _TaskManager._set(task_5)          _ScenarioManager._submit(scenario.id)          submit_calls = _TaskManager._orchestrator().submit_calls          assert len(submit_calls) == 5          assert set(submit_calls) == {task_1.id, task_2.id, task_4.id, task_3.id, task_5.id}          assert submit_calls.index(task_2.id) < submit_calls.index(task_3.id)          assert submit_calls.index(task_1.id) < submit_calls.index(task_3.id)          assert submit_calls.index(task_1.id) < submit_calls.index(task_2.id)          assert submit_calls.index(task_1.id) < submit_calls.index(task_4.id)            _ScenarioManager._submit(scenario)          submit_calls = _TaskManager._orchestrator().submit_calls          assert len(submit_calls) == 10          assert set(submit_calls) == {task_1.id, task_2.id, task_4.id, task_3.id, task_5.id}          assert submit_calls.index(task_2.id) < submit_calls.index(task_3.id)          assert submit_calls.index(task_1.id) < submit_calls.index(task_3.id)          assert submit_calls.index(task_1.id) < submit_calls.index(task_2.id)          assert submit_calls.index(task_1.id) < submit_calls.index(task_4.id)      def my_print(a, b):      print(a + b)      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\")      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\")      json_dn_cfg = Config.configure_parquet_data_node(\"wrong_json_file_path\", default_path=\"wrong_path.json\")      task_cfg = Config.configure_task(\"task\", my_print, [csv_dn_cfg, pickle_dn_cfg], parquet_dn_cfg)      task_2_cfg = Config.configure_task(\"task2\", my_print, [csv_dn_cfg, parquet_dn_cfg], json_dn_cfg)      scenario_cfg = Config.configure_scenario(\"scenario\", [task_cfg, task_2_cfg])      sc_manager = _ScenarioManagerFactory._build_manager()      scenario = sc_manager._create(scenario_cfg)      sc_manager._submit(scenario)        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 scenario.get_inputs()      ]      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 scenario.data_nodes.values()          if input_dn not in scenario.get_inputs()      ]      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_one_input_dn_wrong_file_path(caplog):      csv_dn_cfg = Config.configure_csv_data_node(\"wrong_csv_file_path\", default_path=\"wrong_path.csv\")      pickle_dn_cfg = Config.configure_pickle_data_node(\"wrong_pickle_file_path\", default_data=\"value\")      parquet_dn_cfg = Config.configure_parquet_data_node(\"wrong_parquet_file_path\", default_path=\"wrong_path.parquet\")      json_dn_cfg = Config.configure_parquet_data_node(\"wrong_json_file_path\", default_path=\"wrong_path.json\")      task_cfg = Config.configure_task(\"task\", my_print, [csv_dn_cfg, pickle_dn_cfg], parquet_dn_cfg)      task_2_cfg = Config.configure_task(\"task2\", my_print, [csv_dn_cfg, parquet_dn_cfg], json_dn_cfg)      scenario_cfg = Config.configure_scenario(\"scenario\", [task_cfg, task_2_cfg])      sce_manager = _ScenarioManagerFactory._build_manager()      scenario = sce_manager._create(scenario_cfg)      sce_manager._submit(scenario)        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 scenario.get_inputs()          if input_dn.config_id == \"wrong_csv_file_path\"      ]      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 scenario.data_nodes.values()          if input_dn.config_id != \"wrong_csv_file_path\"      ]      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 subtraction(n1, n2):      return n1 - n2      def addition(n1, n2):      return n1 + n2      def test_scenarios_comparison_development_mode():      Config.configure_job_executions(mode=JobConfig._DEVELOPMENT_MODE)        scenario_config = Config.configure_scenario(          \"Awesome_scenario\",          [              Config.configure_task(                  \"mult_by_2\",                  mult_by_2,                  [Config.configure_data_node(\"foo\", \"in_memory\", Scope.SCENARIO, default_data=1)],                  Config.configure_data_node(\"bar\", \"in_memory\", Scope.SCENARIO, default_data=0),              )          ],          comparators={\"bar\": [subtraction], \"foo\": [subtraction, addition]},      )        _OrchestratorFactory._build_dispatcher()        assert scenario_config.comparators is not None      scenario_1 = _ScenarioManager._create(scenario_config)      scenario_2 = _ScenarioManager._create(scenario_config)        with pytest.raises(InsufficientScenarioToCompare):          _ScenarioManager._compare(scenario_1, data_node_config_id=\"bar\")        scenario_3 = Scenario(\"awesome_scenario_config\", [], {})      with pytest.raises(DifferentScenarioConfigs):          _ScenarioManager._compare(scenario_1, scenario_3, data_node_config_id=\"bar\")        _ScenarioManager._submit(scenario_1.id)      _ScenarioManager._submit(scenario_2.id)        bar_comparison = _ScenarioManager._compare(scenario_1, scenario_2, data_node_config_id=\"bar\")[\"bar\"]      assert bar_comparison[\"subtraction\"] == 0        foo_comparison = _ScenarioManager._compare(scenario_1, scenario_2, data_node_config_id=\"foo\")[\"foo\"]      assert len(foo_comparison.keys()) == 2      assert foo_comparison[\"addition\"] == 2      assert foo_comparison[\"subtraction\"] == 0        assert len(_ScenarioManager._compare(scenario_1, scenario_2).keys()) == 2        with pytest.raises(NonExistingScenarioConfig):          _ScenarioManager._compare(scenario_3, scenario_3)        with pytest.raises(NonExistingComparator):          _ScenarioManager._compare(scenario_1, scenario_2, data_node_config_id=\"abc\")      def test_scenarios_comparison_standalone_mode():      Config.configure_job_executions(mode=JobConfig._STANDALONE_MODE)        scenario_config = Config.configure_scenario(          \"Awesome_scenario\",          [              Config.configure_task(                  \"mult_by_2\",                  mult_by_2,                  [Config.configure_data_node(\"foo\", \"in_memory\", Scope.SCENARIO, default_data=1)],                  Config.configure_data_node(\"bar\", \"in_memory\", Scope.SCENARIO, default_data=0),              )          ],          comparators={\"bar\": [subtraction], \"foo\": [subtraction, addition]},      )        _OrchestratorFactory._build_dispatcher()        assert scenario_config.comparators is not None      scenario_1 = _ScenarioManager._create(scenario_config)      scenario_2 = _ScenarioManager._create(scenario_config)        with pytest.raises(InsufficientScenarioToCompare):          _ScenarioManager._compare(scenario_1, data_node_config_id=\"bar\")        scenario_3 = Scenario(\"awesome_scenario_config\", [], {})      with pytest.raises(DifferentScenarioConfigs):          _ScenarioManager._compare(scenario_1, scenario_3, data_node_config_id=\"bar\")        _ScenarioManager._submit(scenario_1.id)      _ScenarioManager._submit(scenario_2.id)        bar_comparison = _ScenarioManager._compare(scenario_1, scenario_2, data_node_config_id=\"bar\")[\"bar\"]      assert_true_after_time(lambda: bar_comparison[\"subtraction\"] == 0)        foo_comparison = _ScenarioManager._compare(scenario_1, scenario_2, data_node_config_id=\"foo\")[\"foo\"]      assert_true_after_time(lambda: len(foo_comparison.keys()) == 2)      assert_true_after_time(lambda: foo_comparison[\"addition\"] == 2)      assert_true_after_time(lambda: foo_comparison[\"subtraction\"] == 0)        assert_true_after_time(lambda: len(_ScenarioManager._compare(scenario_1, scenario_2).keys()) == 2)        with pytest.raises(NonExistingScenarioConfig):          _ScenarioManager._compare(scenario_3, scenario_3)        with pytest.raises(NonExistingComparator):          _ScenarioManager._compare(scenario_1, scenario_2, data_node_config_id=\"abc\")      def test_tags():      Config.configure_job_executions(mode=JobConfig._DEVELOPMENT_MODE)      _OrchestratorFactory._build_dispatcher()        cycle_1 = _CycleManager._create(Frequency.DAILY, name=\"today\", creation_date=datetime.now())      cycle_2 = _CycleManager._create(          Frequency.DAILY,          name=\"tomorrow\",          creation_date=datetime.now() + timedelta(days=1),      )      cycle_3 = _CycleManager._create(          Frequency.DAILY,          name=\"yesterday\",          creation_date=datetime.now() + timedelta(days=-1),      )        scenario_no_tag = Scenario(\"scenario_no_tag\", [], {}, [], ScenarioId(\"scenario_no_tag\"), cycle=cycle_1)      scenario_1_tag = Scenario(          \"scenario_1_tag\",          [],          {},          [],          ScenarioId(\"scenario_1_tag\"),          cycle=cycle_1,          tags={\"fst\"},      )      scenario_2_tags = Scenario(          \"scenario_2_tags\",          [],          {},          [],          ScenarioId(\"scenario_2_tags\"),          cycle=cycle_2,          tags={\"fst\", \"scd\"},      )        # Test has_tag      assert len(scenario_no_tag.tags) == 0      assert not scenario_no_tag.has_tag(\"fst\")      assert not scenario_no_tag.has_tag(\"scd\")        assert len(scenario_1_tag.tags) == 1      assert scenario_1_tag.has_tag(\"fst\")      assert not scenario_1_tag.has_tag(\"scd\")        assert len(scenario_2_tags.tags) == 2      assert scenario_2_tags.has_tag(\"fst\")      assert scenario_2_tags.has_tag(\"scd\")        # test get and set serialize/deserialize tags      _CycleManager._set(cycle_1)      _CycleManager._set(cycle_2)      _CycleManager._set(cycle_3)      _ScenarioManager._set(scenario_no_tag)      _ScenarioManager._set(scenario_1_tag)      _ScenarioManager._set(scenario_2_tags)        assert len(_ScenarioManager._get(ScenarioId(\"scenario_no_tag\")).tags) == 0      assert not _ScenarioManager._get(ScenarioId(\"scenario_no_tag\")).has_tag(\"fst\")      assert not _ScenarioManager._get(ScenarioId(\"scenario_no_tag\")).has_tag(\"scd\")        assert len(_ScenarioManager._get(ScenarioId(\"scenario_1_tag\")).tags) == 1      assert \"fst\" in _ScenarioManager._get(ScenarioId(\"scenario_1_tag\")).tags      assert \"scd\" not in _ScenarioManager._get(ScenarioId(\"scenario_1_tag\")).tags        assert len(_ScenarioManager._get(ScenarioId(\"scenario_2_tags\")).tags) == 2      assert \"fst\" in _ScenarioManager._get(ScenarioId(\"scenario_2_tags\")).tags      assert \"scd\" in _ScenarioManager._get(ScenarioId(\"scenario_2_tags\")).tags        # Test tag & untag        _ScenarioManager._tag(scenario_no_tag, \"thd\")  # add new tag      _ScenarioManager._untag(scenario_1_tag, \"NOT_EXISTING_TAG\")  # remove not existing tag does nothing      _ScenarioManager._untag(scenario_1_tag, \"fst\")  # remove `fst` tag        assert len(scenario_no_tag.tags) == 1      assert not scenario_no_tag.has_tag(\"fst\")      assert not scenario_no_tag.has_tag(\"scd\")      assert scenario_no_tag.has_tag(\"thd\")        assert len(scenario_1_tag.tags) == 0      assert not scenario_1_tag.has_tag(\"fst\")      assert not scenario_1_tag.has_tag(\"scd\")      assert not scenario_1_tag.has_tag(\"thd\")        assert len(scenario_2_tags.tags) == 2      assert scenario_2_tags.has_tag(\"fst\")      assert scenario_2_tags.has_tag(\"scd\")      assert not scenario_2_tags.has_tag(\"thd\")        _ScenarioManager._untag(scenario_no_tag, \"thd\")      _ScenarioManager._set(scenario_no_tag)      _ScenarioManager._tag(scenario_1_tag, \"fst\")      _ScenarioManager._set(scenario_1_tag)        # test getters      assert not _ScenarioManager._get_by_tag(cycle_3, \"fst\")      assert not _ScenarioManager._get_by_tag(cycle_3, \"scd\")      assert not _ScenarioManager._get_by_tag(cycle_3, \"thd\")        assert _ScenarioManager._get_by_tag(cycle_2, \"fst\") == scenario_2_tags      assert _ScenarioManager._get_by_tag(cycle_2, \"scd\") == scenario_2_tags      assert not _ScenarioManager._get_by_tag(cycle_2, \"thd\")        assert _ScenarioManager._get_by_tag(cycle_1, \"fst\") == scenario_1_tag      assert not _ScenarioManager._get_by_tag(cycle_1, \"scd\")      assert not _ScenarioManager._get_by_tag(cycle_1, \"thd\")        assert len(_ScenarioManager._get_all_by_tag(\"NOT_EXISTING\")) == 0      assert scenario_1_tag in _ScenarioManager._get_all_by_tag(\"fst\")      assert scenario_2_tags in _ScenarioManager._get_all_by_tag(\"fst\")      assert _ScenarioManager._get_all_by_tag(\"scd\") == [scenario_2_tags]      assert len(_ScenarioManager._get_all_by_tag(\"thd\")) == 0        # test tag cycle mgt        _ScenarioManager._tag(          scenario_no_tag, \"fst\"      )  # tag sc_no_tag should untag sc_1_tag with same cycle but not sc_2_tags        assert not _ScenarioManager._get_by_tag(cycle_3, \"fst\")      assert not _ScenarioManager._get_by_tag(cycle_3, \"scd\")      assert not _ScenarioManager._get_by_tag(cycle_3, \"thd\")        assert _ScenarioManager._get_by_tag(cycle_2, \"fst\") == scenario_2_tags      assert _ScenarioManager._get_by_tag(cycle_2, \"scd\") == scenario_2_tags      assert not _ScenarioManager._get_by_tag(cycle_2, \"thd\")        assert _ScenarioManager._get_by_tag(cycle_1, \"fst\") == scenario_no_tag      assert not _ScenarioManager._get_by_tag(cycle_1, \"scd\")      assert not _ScenarioManager._get_by_tag(cycle_1, \"thd\")        assert len(_ScenarioManager._get_all_by_tag(\"NOT_EXISTING\")) == 0      assert len(_ScenarioManager._get_all_by_tag(\"fst\")) == 2      assert scenario_2_tags in _ScenarioManager._get_all_by_tag(\"fst\")      assert scenario_no_tag in _ScenarioManager._get_all_by_tag(\"fst\")      assert _ScenarioManager._get_all_by_tag(\"scd\") == [scenario_2_tags]      assert len(_ScenarioManager._get_all_by_tag(\"thd\")) == 0      def test_authorized_tags():      Config.configure_job_executions(mode=JobConfig._DEVELOPMENT_MODE)        scenario = Scenario(\"scenario_1\", [], {\"authorized_tags\": [\"foo\", \"bar\"]}, [], ScenarioId(\"scenario_1\"))      scenario_2_cfg = Config.configure_scenario(\"scenario_2\", [], [], Frequency.DAILY, authorized_tags=[\"foo\", \"bar\"])        _OrchestratorFactory._build_dispatcher()        scenario_2 = _ScenarioManager._create(scenario_2_cfg)      _ScenarioManager._set(scenario)        assert len(scenario.tags) == 0      assert len(scenario_2.tags) == 0        with pytest.raises(UnauthorizedTagError):          _ScenarioManager._tag(scenario, \"baz\")          _ScenarioManager._tag(scenario_2, \"baz\")      assert len(scenario.tags) == 0      assert len(scenario_2.tags) == 0        _ScenarioManager._tag(scenario, \"foo\")      _ScenarioManager._tag(scenario_2, \"foo\")      assert len(scenario.tags) == 1      assert len(scenario_2.tags) == 1        _ScenarioManager._tag(scenario, \"bar\")      _ScenarioManager._tag(scenario_2, \"bar\")      assert len(scenario.tags) == 2      assert len(scenario_2.tags) == 2        _ScenarioManager._tag(scenario, \"foo\")      _ScenarioManager._tag(scenario_2, \"foo\")      assert len(scenario.tags) == 2      assert len(scenario_2.tags) == 2        _ScenarioManager._untag(scenario, \"foo\")      _ScenarioManager._untag(scenario_2, \"foo\")      assert len(scenario.tags) == 1      assert len(scenario_2.tags) == 1      def test_get_scenarios_by_config_id():      scenario_config_1 = Config.configure_scenario(\"s1\", sequence_configs=[])      scenario_config_2 = Config.configure_scenario(\"s2\", sequence_configs=[])      scenario_config_3 = Config.configure_scenario(\"s3\", sequence_configs=[])        s_1_1 = _ScenarioManager._create(scenario_config_1)      s_1_2 = _ScenarioManager._create(scenario_config_1)      s_1_3 = _ScenarioManager._create(scenario_config_1)      assert len(_ScenarioManager._get_all()) == 3        s_2_1 = _ScenarioManager._create(scenario_config_2)      s_2_2 = _ScenarioManager._create(scenario_config_2)      assert len(_ScenarioManager._get_all()) == 5        s_3_1 = _ScenarioManager._create(scenario_config_3)      assert len(_ScenarioManager._get_all()) == 6        s1_scenarios = _ScenarioManager._get_by_config_id(scenario_config_1.id)      assert len(s1_scenarios) == 3      assert sorted([s_1_1.id, s_1_2.id, s_1_3.id]) == sorted([scenario.id for scenario in s1_scenarios])        s2_scenarios = _ScenarioManager._get_by_config_id(scenario_config_2.id)      assert len(s2_scenarios) == 2      assert sorted([s_2_1.id, s_2_2.id]) == sorted([scenario.id for scenario in s2_scenarios])        s3_scenarios = _ScenarioManager._get_by_config_id(scenario_config_3.id)      assert len(s3_scenarios) == 1      assert sorted([s_3_1.id]) == sorted([scenario.id for scenario in s3_scenarios])      def test_get_scenarios_by_config_id_in_multiple_versions_environment():      scenario_config_1 = Config.configure_scenario(\"s1\", sequence_configs=[])      scenario_config_2 = Config.configure_scenario(\"s2\", sequence_configs=[])        _VersionManager._set_experiment_version(\"1.0\")      _ScenarioManager._create(scenario_config_1)      _ScenarioManager._create(scenario_config_1)      _ScenarioManager._create(scenario_config_1)      _ScenarioManager._create(scenario_config_2)      _ScenarioManager._create(scenario_config_2)        assert len(_ScenarioManager._get_by_config_id(scenario_config_1.id)) == 3      assert len(_ScenarioManager._get_by_config_id(scenario_config_2.id)) == 2        _VersionManager._set_experiment_version(\"2.0\")      _ScenarioManager._create(scenario_config_1)      _ScenarioManager._create(scenario_config_1)      _ScenarioManager._create(scenario_config_1)      _ScenarioManager._create(scenario_config_2)      _ScenarioManager._create(scenario_config_2)        assert len(_ScenarioManager._get_by_config_id(scenario_config_1.id)) == 3      assert len(_ScenarioManager._get_by_config_id(scenario_config_2.id)) == 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": "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 datetime import datetime, timedelta    import pytest    from src.taipy.core._orchestrator._orchestrator_factory import _OrchestratorFactory  from src.taipy.core._version._version_manager import _VersionManager  from src.taipy.core.config.job_config import JobConfig  from src.taipy.core.cycle._cycle_manager import _CycleManager  from src.taipy.core.cycle._cycle_manager_factory import _CycleManagerFactory  from src.taipy.core.data._data_manager import _DataManager  from src.taipy.core.data._data_manager_factory import _DataManagerFactory  from src.taipy.core.data.in_memory import InMemoryDataNode  from src.taipy.core.exceptions.exceptions import DeletingPrimaryScenario  from src.taipy.core.scenario._scenario_manager import _ScenarioManager  from src.taipy.core.scenario._scenario_manager_factory import _ScenarioManagerFactory  from src.taipy.core.scenario.scenario import Scenario  from src.taipy.core.scenario.scenario_id import ScenarioId  from src.taipy.core.sequence._sequence_manager import _SequenceManager  from src.taipy.core.sequence._sequence_manager_factory import _SequenceManagerFactory  from src.taipy.core.sequence.sequence import Sequence  from src.taipy.core.sequence.sequence_id import SequenceId  from src.taipy.core.task._task_manager import _TaskManager  from src.taipy.core.task._task_manager_factory import _TaskManagerFactory  from src.taipy.core.task.task import Task  from src.taipy.core.task.task_id import TaskId  from taipy.config.common.frequency import Frequency  from taipy.config.common.scope import Scope  from taipy.config.config import Config  from tests.conftest import init_managers      def test_set_and_get_scenario(cycle, init_sql_repo):      Config.configure_job_executions(mode=JobConfig._DEVELOPMENT_MODE)        init_managers()      _OrchestratorFactory._build_dispatcher()        scenario_id_1 = ScenarioId(\"scenario_id_1\")      scenario_1 = Scenario(\"scenario_name_1\", [], {}, [], scenario_id_1)        input_dn_2 = InMemoryDataNode(\"foo\", Scope.SCENARIO)      output_dn_2 = InMemoryDataNode(\"bar\", Scope.SCENARIO)      additional_dn_2 = InMemoryDataNode(\"zyx\", Scope.SCENARIO)      task_name_2 = \"task_2\"      task_2 = Task(task_name_2, {}, print, [input_dn_2], [output_dn_2], TaskId(\"task_id_2\"))      scenario_id_2 = ScenarioId(\"scenario_id_2\")      scenario_2 = Scenario(          \"scenario_name_2\",          [task_2],          {},          [additional_dn_2],          scenario_id_2,          datetime.now(),          True,          cycle,          sequences={\"sequence_2\": {\"tasks\": [task_2]}},      )        additional_dn_3 = InMemoryDataNode(\"baz\", Scope.SCENARIO)      task_name_3 = \"task_3\"      task_3 = Task(task_name_3, {}, print, id=TaskId(\"task_id_3\"))      scenario_3_with_same_id = Scenario(          \"scenario_name_3\",          [task_3],          {},          [additional_dn_3],          scenario_id_1,          datetime.now(),          False,          cycle,          sequences={\"sequence_3\": {}},      )        # No existing scenario      assert len(_ScenarioManager._get_all()) == 0      assert _ScenarioManager._get(scenario_id_1) is None      assert _ScenarioManager._get(scenario_1) is None      assert _ScenarioManager._get(scenario_id_2) is None      assert _ScenarioManager._get(scenario_2) is None        # Save one scenario. We expect to have only one scenario stored      _ScenarioManager._set(scenario_1)      assert len(_ScenarioManager._get_all()) == 1      assert _ScenarioManager._get(scenario_id_1).id == scenario_1.id      assert _ScenarioManager._get(scenario_id_1).config_id == scenario_1.config_id      assert len(_ScenarioManager._get(scenario_id_1).tasks) == 0      assert len(_ScenarioManager._get(scenario_id_1).additional_data_nodes) == 0      assert len(_ScenarioManager._get(scenario_id_1).data_nodes) == 0      assert len(_ScenarioManager._get(scenario_id_1).sequences) == 0      assert _ScenarioManager._get(scenario_1).id == scenario_1.id      assert _ScenarioManager._get(scenario_1).config_id == scenario_1.config_id      assert len(_ScenarioManager._get(scenario_1).tasks) == 0      assert len(_ScenarioManager._get(scenario_1).additional_data_nodes) == 0      assert len(_ScenarioManager._get(scenario_1).data_nodes) == 0      assert len(_ScenarioManager._get(scenario_1).sequences) == 0      assert _ScenarioManager._get(scenario_id_2) is None      assert _ScenarioManager._get(scenario_2) is None        # Save a second scenario. Now, we expect to have a total of two scenarios stored      _TaskManager._set(task_2)      _CycleManager._set(cycle)      _ScenarioManager._set(scenario_2)      _DataManager._set(additional_dn_2)      assert len(_ScenarioManager._get_all()) == 2      assert _ScenarioManager._get(scenario_id_1).id == scenario_1.id      assert _ScenarioManager._get(scenario_id_1).config_id == scenario_1.config_id      assert len(_ScenarioManager._get(scenario_id_1).tasks) == 0      assert len(_ScenarioManager._get(scenario_id_1).additional_data_nodes) == 0      assert len(_ScenarioManager._get(scenario_id_1).data_nodes) == 0      assert len(_ScenarioManager._get(scenario_id_1).sequences) == 0      assert _ScenarioManager._get(scenario_1).id == scenario_1.id      assert _ScenarioManager._get(scenario_1).config_id == scenario_1.config_id      assert len(_ScenarioManager._get(scenario_1).tasks) == 0      assert len(_ScenarioManager._get(scenario_1).additional_data_nodes) == 0      assert len(_ScenarioManager._get(scenario_1).data_nodes) == 0      assert len(_ScenarioManager._get(scenario_1).sequences) == 0      assert _ScenarioManager._get(scenario_id_2).id == scenario_2.id      assert _ScenarioManager._get(scenario_id_2).config_id == scenario_2.config_id      assert len(_ScenarioManager._get(scenario_id_2).tasks) == 1      assert len(_ScenarioManager._get(scenario_id_2).additional_data_nodes) == 1      assert len(_ScenarioManager._get(scenario_id_2).data_nodes) == 3      assert len(_ScenarioManager._get(scenario_id_2).sequences) == 1      assert _ScenarioManager._get(scenario_2).id == scenario_2.id      assert _ScenarioManager._get(scenario_2).config_id == scenario_2.config_id      assert len(_ScenarioManager._get(scenario_2).tasks) == 1      assert len(_ScenarioManager._get(scenario_2).additional_data_nodes) == 1      assert len(_ScenarioManager._get(scenario_2).data_nodes) == 3      assert len(_ScenarioManager._get(scenario_2).sequences) == 1      assert _TaskManager._get(task_2.id).id == task_2.id      assert _ScenarioManager._get(scenario_id_2).cycle == cycle      assert _ScenarioManager._get(scenario_2).cycle == cycle      assert _CycleManager._get(cycle.id).id == cycle.id        # We save the first scenario again. We expect nothing to change      _ScenarioManager._set(scenario_1)      assert len(_ScenarioManager._get_all()) == 2      assert _ScenarioManager._get(scenario_id_1).id == scenario_1.id      assert _ScenarioManager._get(scenario_id_1).config_id == scenario_1.config_id      assert len(_ScenarioManager._get(scenario_id_1).tasks) == 0      assert len(_ScenarioManager._get(scenario_id_1).additional_data_nodes) == 0      assert len(_ScenarioManager._get(scenario_id_1).data_nodes) == 0      assert len(_ScenarioManager._get(scenario_id_1).sequences) == 0      assert _ScenarioManager._get(scenario_1).id == scenario_1.id      assert _ScenarioManager._get(scenario_1).config_id == scenario_1.config_id      assert len(_ScenarioManager._get(scenario_1).tasks) == 0      assert len(_ScenarioManager._get(scenario_1).additional_data_nodes) == 0      assert len(_ScenarioManager._get(scenario_1).data_nodes) == 0      assert len(_ScenarioManager._get(scenario_1).sequences) == 0      assert _ScenarioManager._get(scenario_id_2).id == scenario_2.id      assert _ScenarioManager._get(scenario_id_2).config_id == scenario_2.config_id      assert len(_ScenarioManager._get(scenario_id_2).tasks) == 1      assert len(_ScenarioManager._get(scenario_id_2).additional_data_nodes) == 1      assert len(_ScenarioManager._get(scenario_id_2).data_nodes) == 3      assert len(_ScenarioManager._get(scenario_id_2).sequences) == 1      assert _ScenarioManager._get(scenario_2).id == scenario_2.id      assert _ScenarioManager._get(scenario_2).config_id == scenario_2.config_id      assert len(_ScenarioManager._get(scenario_2).tasks) == 1      assert len(_ScenarioManager._get(scenario_2).additional_data_nodes) == 1      assert len(_ScenarioManager._get(scenario_2).data_nodes) == 3      assert len(_ScenarioManager._get(scenario_2).sequences) == 1      assert _TaskManager._get(task_2.id).id == task_2.id      assert _CycleManager._get(cycle.id).id == cycle.id        # We save a third scenario with same id as the first one.      # We expect the first scenario to be updated      _DataManager._set(additional_dn_3)      _TaskManager._set(task_3)      _TaskManager._set(scenario_2.tasks[task_name_2])      _ScenarioManager._set(scenario_3_with_same_id)      assert len(_ScenarioManager._get_all()) == 2      assert _ScenarioManager._get(scenario_id_1).id == scenario_1.id      assert _ScenarioManager._get(scenario_id_1).config_id == scenario_3_with_same_id.config_id      assert len(_ScenarioManager._get(scenario_id_1).tasks) == 1      assert len(_ScenarioManager._get(scenario_id_1).additional_data_nodes) == 1      assert len(_ScenarioManager._get(scenario_id_1).data_nodes) == 1      assert len(_ScenarioManager._get(scenario_id_1).sequences) == 1      assert _ScenarioManager._get(scenario_id_1).cycle == cycle      assert _ScenarioManager._get(scenario_1).id == scenario_1.id      assert _ScenarioManager._get(scenario_1).config_id == scenario_3_with_same_id.config_id      assert len(_ScenarioManager._get(scenario_1).tasks) == 1      assert len(_ScenarioManager._get(scenario_1).additional_data_nodes) == 1      assert len(_ScenarioManager._get(scenario_1).data_nodes) == 1      assert len(_ScenarioManager._get(scenario_1).sequences) == 1      assert _ScenarioManager._get(scenario_1).cycle == cycle      assert _ScenarioManager._get(scenario_id_2).id == scenario_2.id      assert _ScenarioManager._get(scenario_id_2).config_id == scenario_2.config_id      assert len(_ScenarioManager._get(scenario_id_2).tasks) == 1      assert len(_ScenarioManager._get(scenario_id_2).additional_data_nodes) == 1      assert len(_ScenarioManager._get(scenario_id_2).data_nodes) == 3      assert len(_ScenarioManager._get(scenario_id_2).sequences) == 1      assert _ScenarioManager._get(scenario_2).id == scenario_2.id      assert _ScenarioManager._get(scenario_2).config_id == scenario_2.config_id      assert len(_ScenarioManager._get(scenario_2).tasks) == 1      assert len(_ScenarioManager._get(scenario_2).additional_data_nodes) == 1      assert len(_ScenarioManager._get(scenario_2).data_nodes) == 3      assert len(_ScenarioManager._get(scenario_2).sequences) == 1      assert _TaskManager._get(task_2.id).id == task_2.id      def test_get_all_on_multiple_versions_environment(init_sql_repo):      init_managers()        # Create 5 scenarios with 2 versions each      # Only version 1.0 has the scenario with config_id = \"config_id_1\"      # Only version 2.0 has the scenario with config_id = \"config_id_6\"      for version in range(1, 3):          for i in range(5):              _ScenarioManager._set(                  Scenario(f\"config_id_{i+version}\", [], {}, ScenarioId(f\"id{i}_v{version}\"), version=f\"{version}.0\")              )        _VersionManager._set_experiment_version(\"1.0\")      assert len(_ScenarioManager._get_all()) == 5      assert len(_ScenarioManager._get_all_by(filters=[{\"version\": \"1.0\", \"config_id\": \"config_id_1\"}])) == 1      assert len(_ScenarioManager._get_all_by(filters=[{\"version\": \"1.0\", \"config_id\": \"config_id_6\"}])) == 0        _VersionManager._set_experiment_version(\"2.0\")      assert len(_ScenarioManager._get_all()) == 5      assert len(_ScenarioManager._get_all_by(filters=[{\"version\": \"2.0\", \"config_id\": \"config_id_1\"}])) == 0      assert len(_ScenarioManager._get_all_by(filters=[{\"version\": \"2.0\", \"config_id\": \"config_id_6\"}])) == 1        _VersionManager._set_development_version(\"1.0\")      assert len(_ScenarioManager._get_all()) == 5      assert len(_ScenarioManager._get_all_by(filters=[{\"version\": \"1.0\", \"config_id\": \"config_id_1\"}])) == 1      assert len(_ScenarioManager._get_all_by(filters=[{\"version\": \"1.0\", \"config_id\": \"config_id_6\"}])) == 0        _VersionManager._set_development_version(\"2.0\")      assert len(_ScenarioManager._get_all()) == 5      assert len(_ScenarioManager._get_all_by(filters=[{\"version\": \"2.0\", \"config_id\": \"config_id_1\"}])) == 0      assert len(_ScenarioManager._get_all_by(filters=[{\"version\": \"2.0\", \"config_id\": \"config_id_6\"}])) == 1      def test_create_scenario_does_not_modify_config(init_sql_repo):      Config.configure_job_executions(mode=JobConfig._DEVELOPMENT_MODE)        init_managers()        creation_date_1 = datetime.now()      name_1 = \"name_1\"      scenario_config = Config.configure_scenario(\"sc\", None, None, Frequency.DAILY)        _OrchestratorFactory._build_dispatcher()        assert scenario_config.properties.get(\"name\") is None      assert len(scenario_config.properties) == 0        scenario = _ScenarioManager._create(scenario_config, creation_date=creation_date_1, name=name_1)      assert len(scenario_config.properties) == 0      assert len(scenario.properties) == 1      assert scenario.properties.get(\"name\") == name_1      assert scenario.name == name_1        scenario.properties[\"foo\"] = \"bar\"      _ScenarioManager._set(scenario)      assert len(scenario_config.properties) == 0      assert len(scenario.properties) == 2      assert scenario.properties.get(\"foo\") == \"bar\"      assert scenario.properties.get(\"name\") == name_1      assert scenario.name == name_1        scenario_2 = _ScenarioManager._create(scenario_config, creation_date=creation_date_1)      assert scenario_2.name is None      def test_create_and_delete_scenario(init_sql_repo):      Config.configure_job_executions(mode=JobConfig._DEVELOPMENT_MODE)        init_managers()        creation_date_1 = datetime.now()      creation_date_2 = creation_date_1 + timedelta(minutes=10)        name_1 = \"name_1\"        _ScenarioManager._delete_all()      assert len(_ScenarioManager._get_all()) == 0        scenario_config = Config.configure_scenario(\"sc\", None, None, Frequency.DAILY)        _OrchestratorFactory._build_dispatcher()        scenario_1 = _ScenarioManager._create(scenario_config, creation_date=creation_date_1, name=name_1)      assert scenario_1.config_id == \"sc\"      assert scenario_1.sequences == {}      assert scenario_1.tasks == {}      assert scenario_1.additional_data_nodes == {}      assert scenario_1.data_nodes == {}      assert scenario_1.cycle.frequency == Frequency.DAILY      assert scenario_1.is_primary      assert scenario_1.cycle.creation_date == creation_date_1      assert scenario_1.cycle.start_date.date() == creation_date_1.date()      assert scenario_1.cycle.end_date.date() == creation_date_1.date()      assert scenario_1.creation_date == creation_date_1      assert scenario_1.name == name_1      assert scenario_1.properties[\"name\"] == name_1      assert scenario_1.tags == set()        cycle_id_1 = scenario_1.cycle.id      assert _CycleManager._get(cycle_id_1).id == cycle_id_1      _ScenarioManager._delete(scenario_1.id)      assert _ScenarioManager._get(scenario_1.id) is None      assert _CycleManager._get(cycle_id_1) is None        # Recreate scenario_1      scenario_1 = _ScenarioManager._create(scenario_config, creation_date=creation_date_1, name=name_1)        scenario_2 = _ScenarioManager._create(scenario_config, creation_date=creation_date_2)      assert scenario_2.config_id == \"sc\"      assert scenario_2.sequences == {}      assert scenario_2.tasks == {}      assert scenario_2.additional_data_nodes == {}      assert scenario_2.data_nodes == {}      assert scenario_2.cycle.frequency == Frequency.DAILY      assert not scenario_2.is_primary      assert scenario_2.cycle.creation_date == creation_date_1      assert scenario_2.cycle.start_date.date() == creation_date_2.date()      assert scenario_2.cycle.end_date.date() == creation_date_2.date()      assert scenario_2.properties.get(\"name\") is None      assert scenario_2.tags == set()        assert scenario_1 != scenario_2      assert scenario_1.cycle == scenario_2.cycle        assert len(_ScenarioManager._get_all()) == 2      with pytest.raises(DeletingPrimaryScenario):          _ScenarioManager._delete(              scenario_1.id,          )        _ScenarioManager._delete(          scenario_2.id,      )      assert len(_ScenarioManager._get_all()) == 1      _ScenarioManager._delete(scenario_1.id)      assert len(_ScenarioManager._get_all()) == 0      def mult_by_2(nb: int):      return nb * 2      def mult_by_3(nb: int):      return nb * 3      def mult_by_4(nb: int):      return nb * 4      def test_scenario_manager_only_creates_data_node_once(init_sql_repo):      Config.configure_job_executions(mode=JobConfig._DEVELOPMENT_MODE)        init_managers()        # dn_1 ---> mult_by_2 ---> dn_2 ---> mult_by_3 ---> dn_6      # dn_1 ---> mult_by_4 ---> dn_4        dn_config_1 = Config.configure_data_node(\"foo\", \"in_memory\", Scope.GLOBAL, default_data=1)      dn_config_2 = Config.configure_data_node(\"bar\", \"in_memory\", Scope.CYCLE, default_data=0)      dn_config_6 = Config.configure_data_node(\"baz\", \"in_memory\", Scope.CYCLE, default_data=0)      dn_config_4 = Config.configure_data_node(\"qux\", \"in_memory\", Scope.SCENARIO, default_data=0)      task_mult_by_2_config = Config.configure_task(\"mult_by_2\", mult_by_2, [dn_config_1], dn_config_2)      task_mult_by_3_config = Config.configure_task(\"mult_by_3\", mult_by_3, [dn_config_2], dn_config_6)      task_mult_by_4_config = Config.configure_task(\"mult_by_4\", mult_by_4, [dn_config_1], dn_config_4)      scenario_config = Config.configure_scenario(          \"awesome_scenario\", [task_mult_by_2_config, task_mult_by_3_config, task_mult_by_4_config], None, Frequency.DAILY      )      scenario_config.add_sequences(          {\"by_6\": [task_mult_by_2_config, task_mult_by_3_config], \"by_4\": [task_mult_by_4_config]}      )        _OrchestratorFactory._build_dispatcher()        assert len(_DataManager._get_all()) == 0      assert len(_TaskManager._get_all()) == 0      assert len(_SequenceManager._get_all()) == 0      assert len(_ScenarioManager._get_all()) == 0      assert len(_CycleManager._get_all()) == 0        scenario_1 = _ScenarioManager._create(scenario_config)        assert len(_DataManager._get_all()) == 4      assert len(_TaskManager._get_all()) == 3      assert len(_SequenceManager._get_all()) == 2      assert len(_ScenarioManager._get_all()) == 1      assert scenario_1.foo.read() == 1      assert scenario_1.bar.read() == 0      assert scenario_1.baz.read() == 0      assert scenario_1.qux.read() == 0      assert scenario_1.by_6._get_sorted_tasks()[0][0].config_id == task_mult_by_2_config.id      assert scenario_1.by_6._get_sorted_tasks()[1][0].config_id == task_mult_by_3_config.id      assert scenario_1.by_4._get_sorted_tasks()[0][0].config_id == task_mult_by_4_config.id      assert scenario_1.tasks.keys() == {task_mult_by_2_config.id, task_mult_by_3_config.id, task_mult_by_4_config.id}        scenario_1_sorted_tasks = scenario_1._get_sorted_tasks()      expected = [{task_mult_by_2_config.id, task_mult_by_4_config.id}, {task_mult_by_3_config.id}]      for i, list_tasks_by_level in enumerate(scenario_1_sorted_tasks):          assert set([t.config_id for t in list_tasks_by_level]) == expected[i]      assert scenario_1.cycle.frequency == Frequency.DAILY        _ScenarioManager._create(scenario_config)        assert len(_DataManager._get_all()) == 5      assert len(_TaskManager._get_all()) == 4      assert len(_SequenceManager._get_all()) == 4      assert len(_ScenarioManager._get_all()) == 2      def test_get_scenarios_by_config_id(init_sql_repo):      init_managers()        scenario_config_1 = Config.configure_scenario(\"s1\", sequence_configs=[])      scenario_config_2 = Config.configure_scenario(\"s2\", sequence_configs=[])      scenario_config_3 = Config.configure_scenario(\"s3\", sequence_configs=[])        s_1_1 = _ScenarioManager._create(scenario_config_1)      s_1_2 = _ScenarioManager._create(scenario_config_1)      s_1_3 = _ScenarioManager._create(scenario_config_1)      assert len(_ScenarioManager._get_all()) == 3        s_2_1 = _ScenarioManager._create(scenario_config_2)      s_2_2 = _ScenarioManager._create(scenario_config_2)      assert len(_ScenarioManager._get_all()) == 5        s_3_1 = _ScenarioManager._create(scenario_config_3)      assert len(_ScenarioManager._get_all()) == 6        s1_scenarios = _ScenarioManager._get_by_config_id(scenario_config_1.id)      assert len(s1_scenarios) == 3      assert sorted([s_1_1.id, s_1_2.id, s_1_3.id]) == sorted([scenario.id for scenario in s1_scenarios])        s2_scenarios = _ScenarioManager._get_by_config_id(scenario_config_2.id)      assert len(s2_scenarios) == 2      assert sorted([s_2_1.id, s_2_2.id]) == sorted([scenario.id for scenario in s2_scenarios])        s3_scenarios = _ScenarioManager._get_by_config_id(scenario_config_3.id)      assert len(s3_scenarios) == 1      assert sorted([s_3_1.id]) == sorted([scenario.id for scenario in s3_scenarios])      def test_get_scenarios_by_config_id_in_multiple_versions_environment(init_sql_repo):      init_managers()        scenario_config_1 = Config.configure_scenario(\"s1\", sequence_configs=[])      scenario_config_2 = Config.configure_scenario(\"s2\", sequence_configs=[])        _VersionManager._set_experiment_version(\"1.0\")      _ScenarioManager._create(scenario_config_1)      _ScenarioManager._create(scenario_config_1)      _ScenarioManager._create(scenario_config_1)      _ScenarioManager._create(scenario_config_2)      _ScenarioManager._create(scenario_config_2)        assert len(_ScenarioManager._get_by_config_id(scenario_config_1.id)) == 3      assert len(_ScenarioManager._get_by_config_id(scenario_config_2.id)) == 2        _VersionManager._set_experiment_version(\"2.0\")      _ScenarioManager._create(scenario_config_1)      _ScenarioManager._create(scenario_config_1)      _ScenarioManager._create(scenario_config_1)      _ScenarioManager._create(scenario_config_2)      _ScenarioManager._create(scenario_config_2)        assert len(_ScenarioManager._get_by_config_id(scenario_config_1.id)) == 3      assert len(_ScenarioManager._get_by_config_id(scenario_config_2.id)) == 2 "}
{"text": "from datetime import datetime, timedelta  from unittest import mock    import pytest    from src.taipy.core.common._utils import _Subscriber  from src.taipy.core.cycle._cycle_manager_factory import _CycleManagerFactory  from src.taipy.core.cycle.cycle import Cycle, CycleId  from src.taipy.core.data._data_manager_factory import _DataManagerFactory  from src.taipy.core.data.in_memory import DataNode, InMemoryDataNode  from src.taipy.core.data.pickle import PickleDataNode  from src.taipy.core.exceptions.exceptions import SequenceTaskDoesNotExistInScenario  from src.taipy.core.scenario._scenario_manager_factory import _ScenarioManagerFactory  from src.taipy.core.scenario.scenario import Scenario  from src.taipy.core.scenario.scenario_id import ScenarioId  from src.taipy.core.sequence.sequence import Sequence  from src.taipy.core.sequence.sequence_id import SequenceId  from src.taipy.core.task._task_manager_factory import _TaskManagerFactory  from src.taipy.core.task.task import Task, TaskId  from taipy.config import Frequency  from taipy.config.common.scope import Scope  from taipy.config.exceptions.exceptions import InvalidConfigurationId      def test_create_primary_scenario(cycle):      scenario = Scenario(\"foo\", set(), {\"key\": \"value\"}, is_primary=True, cycle=cycle)      assert scenario.id is not None      assert scenario.config_id == \"foo\"      assert scenario.tasks == {}      assert scenario.additional_data_nodes == {}      assert scenario.data_nodes == {}      assert scenario.sequences == {}      assert scenario.properties == {\"key\": \"value\"}      assert scenario.key == \"value\"      assert scenario.creation_date is not None      assert scenario.is_primary      assert scenario.cycle == cycle      assert scenario.tags == set()      assert scenario.get_simple_label() == scenario.config_id        with mock.patch(\"src.taipy.core.get\") as get_mck:            class MockOwner:              label = \"owner_label\"                def get_label(self):                  return self.label            get_mck.return_value = MockOwner()          assert scenario.get_label() == \"owner_label > \" + scenario.config_id      def test_create_scenario_at_time(current_datetime):      scenario = Scenario(\"bar\", set(), {}, set(), ScenarioId(\"baz\"), creation_date=current_datetime)      assert scenario.id == \"baz\"      assert scenario.config_id == \"bar\"      assert scenario.tasks == {}      assert scenario.additional_data_nodes == {}      assert scenario.data_nodes == {}      assert scenario.sequences == {}      assert scenario.properties == {}      assert scenario.creation_date == current_datetime      assert not scenario.is_primary      assert scenario.cycle is None      assert scenario.tags == set()      assert scenario.get_simple_label() == scenario.config_id      assert scenario.get_label() == scenario.config_id      def test_create_scenario_with_task_and_additional_dn_and_sequence():      dn_1 = PickleDataNode(\"xyz\", Scope.SCENARIO)      dn_2 = PickleDataNode(\"abc\", Scope.SCENARIO)      task = Task(\"qux\", {}, print, [dn_1])        scenario = Scenario(\"quux\", set([task]), {}, set([dn_2]), sequences={\"acb\": {\"tasks\": [task]}})      sequence = scenario.sequences[\"acb\"]      assert scenario.id is not None      assert scenario.config_id == \"quux\"      assert len(scenario.tasks) == 1      assert len(scenario.additional_data_nodes) == 1      assert len(scenario.data_nodes) == 2      assert len(scenario.sequences) == 1      assert scenario.qux == task      assert scenario.xyz == dn_1      assert scenario.abc == dn_2      assert scenario.acb == sequence      assert scenario.properties == {}      assert scenario.tags == set()      def test_create_scenario_invalid_config_id():      with pytest.raises(InvalidConfigurationId):          Scenario(\"foo bar\", [], {})      def test_create_scenario_and_add_sequences():      input_1 = PickleDataNode(\"input_1\", Scope.SCENARIO)      output_1 = PickleDataNode(\"output_1\", Scope.SCENARIO)      output_2 = PickleDataNode(\"output_2\", Scope.SCENARIO)      additional_dn_1 = PickleDataNode(\"additional_1\", Scope.SCENARIO)      additional_dn_2 = PickleDataNode(\"additional_2\", Scope.SCENARIO)      task_1 = Task(\"task_1\", {}, print, [input_1], [output_1], TaskId(\"task_id_1\"))      task_2 = Task(\"task_2\", {}, print, [output_1], [output_2], TaskId(\"task_id_2\"))        data_manager = _DataManagerFactory._build_manager()      task_manager = _TaskManagerFactory._build_manager()      data_manager._set(input_1)      data_manager._set(output_1)      data_manager._set(output_2)      data_manager._set(additional_dn_1)      data_manager._set(additional_dn_2)      task_manager._set(task_1)      task_manager._set(task_2)        scenario = Scenario(\"scenario\", set([task_1]), {})      scenario.sequences = {\"sequence_1\": {\"tasks\": [task_1]}, \"sequence_2\": {\"tasks\": []}}      assert scenario.id is not None      assert scenario.config_id == \"scenario\"      assert len(scenario.tasks) == 1      assert scenario.tasks.keys() == {task_1.config_id}      assert len(scenario.additional_data_nodes) == 0      assert scenario.additional_data_nodes == {}      assert len(scenario.data_nodes) == 2      assert scenario.data_nodes == {          input_1.config_id: input_1,          output_1.config_id: output_1,      }      assert len(scenario.sequences) == 2      assert scenario.sequence_1 == scenario.sequences[\"sequence_1\"]      assert scenario.sequence_2 == scenario.sequences[\"sequence_2\"]      assert scenario.sequences == {\"sequence_1\": scenario.sequence_1, \"sequence_2\": scenario.sequence_2}      def test_create_scenario_overlapping_sequences():      input_1 = PickleDataNode(\"input_1\", Scope.SCENARIO)      output_1 = PickleDataNode(\"output_1\", Scope.SCENARIO)      output_2 = PickleDataNode(\"output_2\", Scope.SCENARIO)      additional_dn_1 = PickleDataNode(\"additional_1\", Scope.SCENARIO)      additional_dn_2 = PickleDataNode(\"additional_2\", Scope.SCENARIO)      task_1 = Task(\"task_1\", {}, print, [input_1], [output_1], TaskId(\"task_id_1\"))      task_2 = Task(\"task_2\", {}, print, [output_1], [output_2], TaskId(\"task_id_2\"))      data_manager = _DataManagerFactory._build_manager()      task_manager = _TaskManagerFactory._build_manager()      data_manager._set(input_1)      data_manager._set(output_1)      data_manager._set(output_2)      data_manager._set(additional_dn_1)      data_manager._set(additional_dn_2)      task_manager._set(task_1)      task_manager._set(task_2)        scenario = Scenario(\"scenario\", set([task_1, task_2]), {})      scenario.add_sequence(\"sequence_1\", [task_1])      scenario.add_sequence(\"sequence_2\", [task_1, task_2])      assert scenario.id is not None      assert scenario.config_id == \"scenario\"      assert len(scenario.tasks) == 2      assert scenario.tasks.keys() == {task_1.config_id, task_2.config_id}      assert len(scenario.additional_data_nodes) == 0      assert scenario.additional_data_nodes == {}      assert len(scenario.data_nodes) == 3      assert scenario.data_nodes == {          input_1.config_id: input_1,          output_1.config_id: output_1,          output_2.config_id: output_2,      }      sequence_1 = scenario.sequences[\"sequence_1\"]      sequence_2 = scenario.sequences[\"sequence_2\"]      assert scenario.sequences == {\"sequence_1\": sequence_1, \"sequence_2\": sequence_2}      scenario.remove_sequences([\"sequence_2\"])      assert scenario.sequences == {\"sequence_1\": sequence_1}      scenario.remove_sequences([\"sequence_1\"])      assert scenario.sequences == {}      def test_create_scenario_one_additional_dn():      input_1 = PickleDataNode(\"input_1\", Scope.SCENARIO)      input_2 = PickleDataNode(\"input_2\", Scope.SCENARIO)      output_1 = PickleDataNode(\"output_1\", Scope.SCENARIO)      output_2 = PickleDataNode(\"output_2\", Scope.SCENARIO)      additional_dn_1 = PickleDataNode(\"additional_1\", Scope.SCENARIO)      additional_dn_2 = PickleDataNode(\"additional_2\", Scope.SCENARIO)      task_1 = Task(\"task_1\", {}, print, [input_1], [output_1], TaskId(\"task_id_1\"))      task_2 = Task(\"task_2\", {}, print, [input_2], [output_2], TaskId(\"task_id_2\"))      data_manager = _DataManagerFactory._build_manager()      task_manager = _TaskManagerFactory._build_manager()      data_manager._set(input_1)      data_manager._set(output_1)      data_manager._set(input_2)      data_manager._set(output_2)      data_manager._set(additional_dn_1)      data_manager._set(additional_dn_2)      task_manager._set(task_1)      task_manager._set(task_2)        scenario = Scenario(\"scenario\", set(), {}, set([additional_dn_1]))      assert scenario.id is not None      assert scenario.config_id == \"scenario\"      assert len(scenario.tasks) == 0      assert len(scenario.additional_data_nodes) == 1      assert len(scenario.data_nodes) == 1      assert scenario.tasks == {}      assert scenario.additional_data_nodes == {additional_dn_1.config_id: additional_dn_1}      assert scenario.data_nodes == {additional_dn_1.config_id: additional_dn_1}      def test_create_scenario_wth_additional_dns():      input_1 = PickleDataNode(\"input_1\", Scope.SCENARIO)      input_2 = PickleDataNode(\"input_2\", Scope.SCENARIO)      output_1 = PickleDataNode(\"output_1\", Scope.SCENARIO)      output_2 = PickleDataNode(\"output_2\", Scope.SCENARIO)      additional_dn_1 = PickleDataNode(\"additional_1\", Scope.SCENARIO)      additional_dn_2 = PickleDataNode(\"additional_2\", Scope.SCENARIO)      task_1 = Task(\"task_1\", {}, print, [input_1], [output_1], TaskId(\"task_id_1\"))      task_2 = Task(\"task_2\", {}, print, [input_2], [output_2], TaskId(\"task_id_2\"))      data_manager = _DataManagerFactory._build_manager()      task_manager = _TaskManagerFactory._build_manager()      data_manager._set(input_1)      data_manager._set(output_1)      data_manager._set(input_2)      data_manager._set(output_2)      data_manager._set(additional_dn_1)      data_manager._set(additional_dn_2)      task_manager._set(task_1)      task_manager._set(task_2)        scenario = Scenario(\"scenario\", set(), {}, set([additional_dn_1, additional_dn_2]))      assert scenario.id is not None      assert scenario.config_id == \"scenario\"      assert len(scenario.tasks) == 0      assert len(scenario.additional_data_nodes) == 2      assert len(scenario.data_nodes) == 2      assert scenario.tasks == {}      assert scenario.additional_data_nodes == {          additional_dn_1.config_id: additional_dn_1,          additional_dn_2.config_id: additional_dn_2,      }      assert scenario.data_nodes == {          additional_dn_1.config_id: additional_dn_1,          additional_dn_2.config_id: additional_dn_2,      }        scenario_1 = Scenario(\"scenario_1\", set([task_1]), {}, set([additional_dn_1]))      assert scenario_1.id is not None      assert scenario_1.config_id == \"scenario_1\"      assert len(scenario_1.tasks) == 1      assert len(scenario_1.additional_data_nodes) == 1      assert len(scenario_1.data_nodes) == 3      assert scenario_1.tasks.keys() == {task_1.config_id}      assert scenario_1.additional_data_nodes == {          additional_dn_1.config_id: additional_dn_1,      }      assert scenario_1.data_nodes == {          input_1.config_id: input_1,          output_1.config_id: output_1,          additional_dn_1.config_id: additional_dn_1,      }        scenario_2 = Scenario(\"scenario_2\", set([task_1, task_2]), {}, set([additional_dn_1, additional_dn_2]))      assert scenario_2.id is not None      assert scenario_2.config_id == \"scenario_2\"      assert len(scenario_2.tasks) == 2      assert len(scenario_2.additional_data_nodes) == 2      assert len(scenario_2.data_nodes) == 6      assert scenario_2.tasks.keys() == {task_1.config_id, task_2.config_id}      assert scenario_2.additional_data_nodes == {          additional_dn_1.config_id: additional_dn_1,          additional_dn_2.config_id: additional_dn_2,      }      assert {dn_config_id: dn.id for dn_config_id, dn in scenario_2.data_nodes.items()} == {          input_1.config_id: input_1.id,          output_1.config_id: output_1.id,          input_2.config_id: input_2.id,          output_2.config_id: output_2.id,          additional_dn_1.config_id: additional_dn_1.id,          additional_dn_2.config_id: additional_dn_2.id,      }      def test_raise_sequence_tasks_not_in_scenario(data_node):      task_1 = Task(\"task_1\", {}, print, output=[data_node])      task_2 = Task(\"task_2\", {}, print, input=[data_node])        with pytest.raises(SequenceTaskDoesNotExistInScenario) as err:          Scenario(\"scenario\", [], {}, sequences={\"sequence\": {\"tasks\": [task_1]}}, scenario_id=\"SCENARIO_scenario\")      assert err.value.args == ([task_1.id], \"sequence\", \"SCENARIO_scenario\")        with pytest.raises(SequenceTaskDoesNotExistInScenario) as err:          Scenario(              \"scenario\",              [task_1],              {},              sequences={\"sequence\": {\"tasks\": [task_1, task_2]}},              scenario_id=\"SCENARIO_scenario\",          )      assert err.value.args == ([task_2.id], \"sequence\", \"SCENARIO_scenario\")        Scenario(\"scenario\", [task_1], {}, sequences={\"sequence\": {\"tasks\": [task_1]}})      Scenario(          \"scenario\",          [task_1, task_2],          {},          sequences={\"sequence_1\": {\"tasks\": [task_1]}, \"sequence_2\": {\"tasks\": [task_1, task_2]}},      )      def test_raise_tasks_not_in_scenario_with_add_sequence_api(data_node):      task_1 = Task(\"task_1\", {}, print, output=[data_node])      task_2 = Task(\"task_2\", {}, print, input=[data_node])      scenario = Scenario(\"scenario\", [task_1], {})      scenario_manager = _ScenarioManagerFactory._build_manager()      task_manager = _TaskManagerFactory._build_manager()      scenario_manager._set(scenario)      task_manager._set(task_1)      task_manager._set(task_2)        scenario.add_sequences({\"sequence_1\": {}})        with pytest.raises(SequenceTaskDoesNotExistInScenario) as err:          scenario.add_sequence(\"sequence_2\", [task_2])      assert err.value.args == ([task_2.id], \"sequence_2\", scenario.id)        scenario.add_sequence(\"sequence_3\", [task_1])        with pytest.raises(SequenceTaskDoesNotExistInScenario) as err:          scenario.add_sequences({\"sequence_4\": [task_2]})      assert err.value.args == ([task_2.id], \"sequence_4\", scenario.id)        with pytest.raises(SequenceTaskDoesNotExistInScenario) as err:          scenario.add_sequences({\"sequence_5\": [task_1, task_2]})      assert err.value.args == ([task_2.id], \"sequence_5\", scenario.id)        scenario.tasks = [task_1, task_2]      scenario.add_sequence(\"sequence_6\", [task_1, task_2])      def test_add_property_to_scenario():      scenario = Scenario(\"foo\", [], {\"key\": \"value\"})      assert scenario.properties == {\"key\": \"value\"}      assert scenario.key == \"value\"        scenario.properties[\"new_key\"] = \"new_value\"        assert scenario.properties == {\"key\": \"value\", \"new_key\": \"new_value\"}      assert scenario.key == \"value\"      assert scenario.new_key == \"new_value\"      def test_add_cycle_to_scenario(cycle):      scenario = Scenario(\"foo\", [], {})      assert scenario.cycle is None      _CycleManagerFactory._build_manager()._set(cycle)      scenario.cycle = cycle        assert scenario.cycle == cycle      def test_add_and_remove_subscriber():      scenario = Scenario(\"foo\", [], {})        scenario._add_subscriber(print)      assert len(scenario.subscribers) == 1        scenario._remove_subscriber(print)      assert len(scenario.subscribers) == 0      def test_add_and_remove_tag():      scenario = Scenario(\"foo\", [], {})        assert len(scenario.tags) == 0      scenario._add_tag(\"tag\")      assert len(scenario.tags) == 1        scenario._remove_tag(\"tag\")      assert len(scenario.tags) == 0      def test_auto_set_and_reload(cycle, current_datetime, task, data_node):      scenario_1 = Scenario(          \"foo\",          set(),          {\"name\": \"bar\"},          set(),          creation_date=current_datetime,          is_primary=True,          cycle=None,      )      additional_dn = InMemoryDataNode(\"additional_dn\", Scope.SCENARIO)      example_date = datetime.fromisoformat(\"2021-11-11T11:11:01.000001\")      tmp_cycle = Cycle(          Frequency.WEEKLY,          {},          creation_date=example_date,          start_date=example_date,          end_date=example_date,          name=\"cc\",          id=CycleId(\"tmp_cc_id\"),      )        sequence_1_name = \"sequence_1\"      sequence_1 = Sequence({}, [], SequenceId(f\"SEQUENCE_{sequence_1_name}_{scenario_1.id}\"))        tmp_sequence_name = \"tmp_sequence\"      tmp_sequence = Sequence(          {},          [],          SequenceId(f\"SEQUENCE_{tmp_sequence_name}_{scenario_1.id}\"),      )        _TaskManagerFactory._build_manager()._set(task)      _DataManagerFactory._build_manager()._set(data_node)      _DataManagerFactory._build_manager()._set(additional_dn)      _CycleManagerFactory._build_manager()._set(cycle)      scenario_manager = _ScenarioManagerFactory._build_manager()      cycle_manager = _CycleManagerFactory._build_manager()      cycle_manager._set(cycle)      cycle_manager._set(tmp_cycle)      scenario_manager._set(scenario_1)        scenario_2 = scenario_manager._get(scenario_1)      assert scenario_1.config_id == \"foo\"      assert scenario_2.config_id == \"foo\"        # auto set & reload on name attribute      assert scenario_1.name == \"bar\"      assert scenario_2.name == \"bar\"      scenario_1.name = \"zab\"      assert scenario_1.name == \"zab\"      assert scenario_2.name == \"zab\"      scenario_2.name = \"baz\"      assert scenario_1.name == \"baz\"      assert scenario_2.name == \"baz\"        # auto set & reload on sequences attribute      assert len(scenario_1.sequences) == 0      assert len(scenario_2.sequences) == 0      scenario_1.sequences = {tmp_sequence_name: {}}      assert len(scenario_1.sequences) == 1      assert scenario_1.sequences[tmp_sequence_name] == tmp_sequence      assert len(scenario_2.sequences) == 1      assert scenario_2.sequences[tmp_sequence_name] == tmp_sequence      scenario_2.add_sequences({sequence_1_name: []})      assert len(scenario_1.sequences) == 2      assert scenario_1.sequences == {sequence_1_name: sequence_1, tmp_sequence_name: tmp_sequence}      assert len(scenario_2.sequences) == 2      assert scenario_2.sequences == {sequence_1_name: sequence_1, tmp_sequence_name: tmp_sequence}      scenario_2.remove_sequences([tmp_sequence_name])      assert len(scenario_1.sequences) == 1      assert scenario_1.sequences == {sequence_1_name: sequence_1}      assert len(scenario_2.sequences) == 1      assert scenario_2.sequences == {sequence_1_name: sequence_1}        assert len(scenario_1.tasks) == 0      assert len(scenario_1.data_nodes) == 0      scenario_1.tasks = {task}      assert len(scenario_1.tasks) == 1      assert scenario_1.tasks[task.config_id] == task      assert len(scenario_1.data_nodes) == 2      assert len(scenario_2.tasks) == 1      assert scenario_2.tasks[task.config_id] == task      assert len(scenario_2.data_nodes) == 2        assert len(scenario_1.additional_data_nodes) == 0      scenario_1.additional_data_nodes = {additional_dn}      assert len(scenario_1.additional_data_nodes) == 1      assert scenario_1.additional_data_nodes[additional_dn.config_id] == additional_dn      assert len(scenario_1.data_nodes) == 3      assert len(scenario_2.additional_data_nodes) == 1      assert scenario_2.additional_data_nodes[additional_dn.config_id] == additional_dn      assert len(scenario_2.data_nodes) == 3        new_datetime = current_datetime + timedelta(1)      new_datetime_1 = current_datetime + timedelta(2)        # auto set & reload on name attribute      assert scenario_1.creation_date == current_datetime      assert scenario_2.creation_date == current_datetime      scenario_1.creation_date = new_datetime_1      assert scenario_1.creation_date == new_datetime_1      assert scenario_2.creation_date == new_datetime_1      scenario_2.creation_date = new_datetime      assert scenario_1.creation_date == new_datetime      assert scenario_2.creation_date == new_datetime        # auto set & reload on cycle attribute      assert scenario_1.cycle is None      assert scenario_2.cycle is None      scenario_1.cycle = tmp_cycle      assert scenario_1.cycle == tmp_cycle      assert scenario_2.cycle == tmp_cycle      scenario_2.cycle = cycle      assert scenario_1.cycle == cycle      assert scenario_2.cycle == cycle        # auto set & reload on is_primary attribute      assert scenario_1.is_primary      assert scenario_2.is_primary      scenario_1.is_primary = False      assert not scenario_1.is_primary      assert not scenario_2.is_primary      scenario_2.is_primary = True      assert scenario_1.is_primary      assert scenario_2.is_primary        # auto set & reload on subscribers attribute      assert len(scenario_1.subscribers) == 0      assert len(scenario_2.subscribers) == 0      scenario_1.subscribers.append(_Subscriber(print, []))      assert len(scenario_1.subscribers) == 1      assert len(scenario_2.subscribers) == 1      scenario_2.subscribers.append(_Subscriber(print, []))      assert len(scenario_1.subscribers) == 2      assert len(scenario_2.subscribers) == 2        scenario_1.subscribers.clear()      assert len(scenario_1.subscribers) == 0      assert len(scenario_2.subscribers) == 0        scenario_1.subscribers.extend([_Subscriber(print, []), _Subscriber(map, [])])      assert len(scenario_1.subscribers) == 2      assert len(scenario_2.subscribers) == 2        scenario_1.subscribers.remove(_Subscriber(print, []))      assert len(scenario_1.subscribers) == 1      assert len(scenario_2.subscribers) == 1        scenario_1.subscribers + print + len      assert len(scenario_1.subscribers) == 3      assert len(scenario_2.subscribers) == 3        scenario_1.subscribers = []      assert len(scenario_1.subscribers) == 0      assert len(scenario_2.subscribers) == 0        assert len(scenario_1.tags) == 0      scenario_1.tags = {\"hi\"}      assert len(scenario_1.tags) == 1      assert len(scenario_2.tags) == 1        # auto set & reload on properties attribute      assert scenario_1.properties == {\"name\": \"baz\"}      assert scenario_2.properties == {\"name\": \"baz\"}      scenario_1._properties[\"qux\"] = 4      assert scenario_1.properties[\"qux\"] == 4      assert scenario_2.properties[\"qux\"] == 4        assert scenario_1.properties == {\"name\": \"baz\", \"qux\": 4}      assert scenario_2.properties == {\"name\": \"baz\", \"qux\": 4}      scenario_2._properties[\"qux\"] = 5      assert scenario_1.properties[\"qux\"] == 5      assert scenario_2.properties[\"qux\"] == 5        scenario_1.properties[\"temp_key_1\"] = \"temp_value_1\"      scenario_1.properties[\"temp_key_2\"] = \"temp_value_2\"      assert scenario_1.properties == {          \"name\": \"baz\",          \"qux\": 5,          \"temp_key_1\": \"temp_value_1\",          \"temp_key_2\": \"temp_value_2\",      }      assert scenario_2.properties == {          \"name\": \"baz\",          \"qux\": 5,          \"temp_key_1\": \"temp_value_1\",          \"temp_key_2\": \"temp_value_2\",      }      scenario_1.properties.pop(\"temp_key_1\")      assert \"temp_key_1\" not in scenario_1.properties.keys()      assert \"temp_key_1\" not in scenario_1.properties.keys()      assert scenario_1.properties == {          \"name\": \"baz\",          \"qux\": 5,          \"temp_key_2\": \"temp_value_2\",      }      assert scenario_2.properties == {          \"name\": \"baz\",          \"qux\": 5,          \"temp_key_2\": \"temp_value_2\",      }      scenario_2.properties.pop(\"temp_key_2\")      assert scenario_1.properties == {\"name\": \"baz\", \"qux\": 5}      assert scenario_2.properties == {\"name\": \"baz\", \"qux\": 5}      assert \"temp_key_2\" not in scenario_1.properties.keys()      assert \"temp_key_2\" not in scenario_2.properties.keys()        scenario_1.properties[\"temp_key_3\"] = 0      assert scenario_1.properties == {\"name\": \"baz\", \"qux\": 5, \"temp_key_3\": 0}      assert scenario_2.properties == {\"name\": \"baz\", \"qux\": 5, \"temp_key_3\": 0}      scenario_1.properties.update({\"temp_key_3\": 1})      assert scenario_1.properties == {\"name\": \"baz\", \"qux\": 5, \"temp_key_3\": 1}      assert scenario_2.properties == {\"name\": \"baz\", \"qux\": 5, \"temp_key_3\": 1}      scenario_1.properties.update(dict())      assert scenario_1.properties == {\"name\": \"baz\", \"qux\": 5, \"temp_key_3\": 1}      assert scenario_2.properties == {\"name\": \"baz\", \"qux\": 5, \"temp_key_3\": 1}      scenario_1.properties[\"temp_key_4\"] = 0      scenario_1.properties[\"temp_key_5\"] = 0        with scenario_1 as scenario:          assert scenario.config_id == \"foo\"          assert len(scenario.tasks) == 1          assert len(scenario.sequences) == 1          assert scenario.sequences[\"sequence_1\"] == sequence_1          assert scenario.tasks[task.config_id] == task          assert len(scenario.additional_data_nodes) == 1          assert scenario.additional_data_nodes[additional_dn.config_id] == additional_dn          assert scenario.creation_date == new_datetime          assert scenario.cycle == cycle          assert scenario.is_primary          assert len(scenario.subscribers) == 0          assert len(scenario.tags) == 1          assert scenario._is_in_context          assert scenario.name == \"baz\"          assert scenario.properties[\"qux\"] == 5          assert scenario.properties[\"temp_key_3\"] == 1          assert scenario.properties[\"temp_key_4\"] == 0          assert scenario.properties[\"temp_key_5\"] == 0            new_datetime_2 = new_datetime + timedelta(5)          scenario.config_id = \"foo\"          scenario.tasks = set()          scenario.additional_data_nodes = set()          scenario.remove_sequences([sequence_1_name])          scenario.creation_date = new_datetime_2          scenario.cycle = None          scenario.is_primary = False          scenario.subscribers = [print]          scenario.tags = None          scenario.name = \"qux\"          scenario.properties[\"qux\"] = 9          scenario.properties.pop(\"temp_key_3\")          scenario.properties.pop(\"temp_key_4\")          scenario.properties.update({\"temp_key_4\": 1})          scenario.properties.update({\"temp_key_5\": 2})          scenario.properties.pop(\"temp_key_5\")          scenario.properties.update(dict())            assert scenario.config_id == \"foo\"          assert len(scenario.sequences) == 1          assert scenario.sequences[sequence_1_name] == sequence_1          assert len(scenario.tasks) == 1          assert scenario.tasks[task.config_id] == task          assert len(scenario.additional_data_nodes) == 1          assert scenario.additional_data_nodes[additional_dn.config_id] == additional_dn          assert scenario.creation_date == new_datetime          assert scenario.cycle == cycle          assert scenario.is_primary          assert len(scenario.subscribers) == 0          assert len(scenario.tags) == 1          assert scenario._is_in_context          assert scenario.name == \"baz\"          assert scenario.properties[\"qux\"] == 5          assert scenario.properties[\"temp_key_3\"] == 1          assert scenario.properties[\"temp_key_4\"] == 0          assert scenario.properties[\"temp_key_5\"] == 0        assert scenario_1.config_id == \"foo\"      assert len(scenario_1.sequences) == 0      assert len(scenario_1.tasks) == 0      assert len(scenario_1.additional_data_nodes) == 0      assert scenario_1.tasks == {}      assert scenario_1.additional_data_nodes == {}      assert scenario_1.creation_date == new_datetime_2      assert scenario_1.cycle is None      assert not scenario_1.is_primary      assert len(scenario_1.subscribers) == 1      assert len(scenario_1.tags) == 0      assert not scenario_1._is_in_context      assert scenario_1.properties[\"qux\"] == 9      assert \"temp_key_3\" not in scenario_1.properties.keys()      assert scenario_1.properties[\"temp_key_4\"] == 1      assert \"temp_key_5\" not in scenario_1.properties.keys()      def test_is_deletable():      with mock.patch(\"src.taipy.core.scenario._scenario_manager._ScenarioManager._is_deletable\") as mock_submit:          scenario = Scenario(\"foo\", [], {})          scenario.is_deletable()          mock_submit.assert_called_once_with(scenario)      def test_submit_scenario():      with mock.patch(\"src.taipy.core.scenario._scenario_manager._ScenarioManager._submit\") as mock_submit:          scenario = Scenario(\"foo\", [], {})          scenario.submit(force=False)          mock_submit.assert_called_once_with(scenario, None, False, False, None)      def test_subscribe_scenario():      with mock.patch(\"src.taipy.core.subscribe_scenario\") as mock_subscribe:          scenario = Scenario(\"foo\", [], {})          scenario.subscribe(None)          mock_subscribe.assert_called_once_with(None, None, scenario)      def test_unsubscribe_scenario():      with mock.patch(\"src.taipy.core.unsubscribe_scenario\") as mock_unsubscribe:          scenario = Scenario(\"foo\", [], {})          scenario.unsubscribe(None)          mock_unsubscribe.assert_called_once_with(None, None, scenario)      def test_add_tag_scenario():      with mock.patch(\"src.taipy.core.tag\") as mock_add_tag:          scenario = Scenario(\"foo\", [], {})          scenario.add_tag(\"tag\")          mock_add_tag.assert_called_once_with(scenario, \"tag\")      def test_remove_tag_scenario():      with mock.patch(\"src.taipy.core.untag\") as mock_remove_tag:          scenario = Scenario(\"foo\", [], {})          scenario.remove_tag(\"tag\")          mock_remove_tag.assert_called_once_with(scenario, \"tag\")      def test_get_inputs_outputs_intermediate_data_nodes():      data_node_1 = DataNode(\"foo\", Scope.SCENARIO, \"s1\")      data_node_2 = DataNode(\"bar\", Scope.SCENARIO, \"s2\")      data_node_3 = DataNode(\"baz\", Scope.SCENARIO, \"s3\")      data_node_4 = DataNode(\"qux\", Scope.SCENARIO, \"s4\")      data_node_5 = DataNode(\"quux\", Scope.SCENARIO, \"s5\")      data_node_6 = DataNode(\"quuz\", Scope.SCENARIO, \"s6\")      data_node_7 = DataNode(\"corge\", Scope.SCENARIO, \"s7\")      task_1 = Task(\"grault\", {}, print, [data_node_1, data_node_2], [data_node_3, data_node_4], TaskId(\"t1\"))      task_2 = Task(\"garply\", {}, print, [data_node_3], [data_node_5], TaskId(\"t2\"))      task_3 = Task(\"waldo\", {}, print, [data_node_5, data_node_4], [data_node_6], TaskId(\"t3\"))      task_4 = Task(\"fred\", {}, print, [data_node_4], [data_node_7], TaskId(\"t4\"))      scenario = Scenario(\"scenario\", {task_1, task_2, task_3, task_4}, {}, set(), ScenarioId(\"s1\"))      # s1 ---             ---> s3 ---> t2 ---> s5 ----      #       |           |                           |      #       |---> t1 ---|      -------------------------> t3 ---> s6      #       |           |      |      # s2 ---             ---> s4 ---> t4 ---> s7      assert scenario.get_inputs() == {data_node_1, data_node_2}      assert scenario.get_outputs() == {data_node_6, data_node_7}      assert scenario.get_intermediate() == {data_node_3, data_node_4, data_node_5}        data_node_1 = DataNode(\"foo\", Scope.SCENARIO, \"s1\")      data_node_2 = DataNode(\"bar\", Scope.SCENARIO, \"s2\")      data_node_4 = DataNode(\"qux\", Scope.SCENARIO, \"s4\")      data_node_5 = DataNode(\"quux\", Scope.SCENARIO, \"s5\")      data_node_6 = DataNode(\"quuz\", Scope.SCENARIO, \"s6\")      data_node_7 = DataNode(\"corge\", Scope.SCENARIO, \"s7\")      task_1 = Task(\"grault\", {}, print, [data_node_1, data_node_2], [data_node_4], TaskId(\"t1\"))      task_2 = Task(\"garply\", {}, print, None, [data_node_5], TaskId(\"t2\"))      task_3 = Task(\"waldo\", {}, print, [data_node_5, data_node_4], [data_node_6], TaskId(\"t3\"))      task_4 = Task(\"fred\", {}, print, [data_node_4], [data_node_7], TaskId(\"t4\"))      scenario = Scenario(\"scenario\", {task_1, task_2, task_3, task_4}, {}, set(), ScenarioId(\"s1\"))      # s1 ---      t2 ---> s5 ------      #       |                     |      #       |---> t1 ---|      -----> t3 ---> s6      #       |           |      |      # s2 ---             ---> s4 ---> t4 ---> s7      assert scenario.get_inputs() == {data_node_1, data_node_2}      assert scenario.get_outputs() == {data_node_6, data_node_7}      assert scenario.get_intermediate() == {data_node_4, data_node_5}        data_node_1 = DataNode(\"foo\", Scope.SCENARIO, \"s1\")      data_node_2 = DataNode(\"bar\", Scope.SCENARIO, \"s2\")      data_node_4 = DataNode(\"qux\", Scope.SCENARIO, \"s4\")      data_node_5 = DataNode(\"quux\", Scope.SCENARIO, \"s5\")      data_node_6 = DataNode(\"quuz\", Scope.SCENARIO, \"s6\")      data_node_7 = DataNode(\"corge\", Scope.SCENARIO, \"s7\")      data_node_8 = DataNode(\"d8\", Scope.SCENARIO, \"s8\")      data_node_9 = DataNode(\"d9\", Scope.SCENARIO, \"s9\")      task_1 = Task(\"grault\", {}, print, [data_node_1, data_node_2], [data_node_4], TaskId(\"t1\"))      task_2 = Task(\"garply\", {}, print, [data_node_6], [data_node_5], TaskId(\"t2\"))      task_3 = Task(\"waldo\", {}, print, [data_node_5, data_node_4], id=TaskId(\"t3\"))      task_4 = Task(\"fred\", {}, print, [data_node_4], [data_node_7], TaskId(\"t4\"))      task_5 = Task(\"t5\", {}, print, [data_node_8], [data_node_9], TaskId(\"t5\"))      task_6 = Task(\"t6\", {}, print, [data_node_7, data_node_9], id=TaskId(\"t6\"))      scenario = Scenario(\"scenario\", {task_1, task_2, task_3, task_4, task_5, task_6}, {}, set(), ScenarioId(\"s1\"))      # s1 ---      s6 ---> t2 ---> s5      #       |                     |      #       |---> t1 ---|      -----> t3      #       |           |      |      # s2 ---             ---> s4 ---> t4 ---> s7 ---> t6      #                                              |      # s8 -------> t5 -------> s9 ------------------      assert scenario.get_inputs() == {data_node_1, data_node_2, data_node_6, data_node_8}      assert scenario.get_outputs() == set()      assert scenario.get_intermediate() == {data_node_5, data_node_4, data_node_7, data_node_9}        data_node_1 = DataNode(\"foo\", Scope.SCENARIO, \"s1\")      data_node_2 = DataNode(\"bar\", Scope.SCENARIO, \"s2\")      data_node_4 = DataNode(\"qux\", Scope.SCENARIO, \"s4\")      data_node_5 = DataNode(\"quux\", Scope.SCENARIO, \"s5\")      data_node_6 = DataNode(\"quuz\", Scope.SCENARIO, \"s6\")      data_node_7 = DataNode(\"corge\", Scope.SCENARIO, \"s7\")      data_node_8 = DataNode(\"hugh\", Scope.SCENARIO, \"s8\")      task_1 = Task(\"grault\", {}, print, [data_node_1, data_node_2], [data_node_4], TaskId(\"t1\"))      task_2 = Task(\"garply\", {}, print, output=[data_node_5], id=TaskId(\"t2\"))      task_3 = Task(\"waldo\", {}, print, [data_node_4], None, id=TaskId(\"t3\"))      task_4 = Task(\"fred\", {}, print, [data_node_4, data_node_6], [data_node_7], TaskId(\"t4\"))      task_5 = Task(\"bob\", {}, print, [data_node_8], None, TaskId(\"t5\"))      scenario = Scenario(\"scenario\", {task_1, task_2, task_3, task_4, task_5}, {}, set(), ScenarioId(\"sc1\"))      # s1 ---      #       |      #       |---> t1 ---|      -----> t3      #       |           |      |      # s2 ---             ---> s4 ---> t4 ---> s7      # t2 ---> s5                   |      # s8 ---> t5              s6 --|      assert scenario.get_inputs() == {data_node_1, data_node_2, data_node_8, data_node_6}      assert scenario.get_outputs() == {data_node_5, data_node_7}      assert scenario.get_intermediate() == {data_node_4}      def test_is_ready_to_run():      data_node_1 = PickleDataNode(\"foo\", Scope.SCENARIO, \"s1\", properties={\"default_data\": 1})      data_node_2 = PickleDataNode(\"bar\", Scope.SCENARIO, \"s2\", properties={\"default_data\": 2})      data_node_4 = PickleDataNode(\"qux\", Scope.SCENARIO, \"s4\", properties={\"default_data\": 4})      data_node_5 = PickleDataNode(\"quux\", Scope.SCENARIO, \"s5\", properties={\"default_data\": 5})      data_node_6 = PickleDataNode(\"quuz\", Scope.SCENARIO, \"s6\", properties={\"default_data\": 6})      data_node_7 = PickleDataNode(\"corge\", Scope.SCENARIO, \"s7\", properties={\"default_data\": 7})      data_node_8 = PickleDataNode(\"d8\", Scope.SCENARIO, \"s8\", properties={\"default_data\": 8})      data_node_9 = PickleDataNode(\"d9\", Scope.SCENARIO, \"s9\", properties={\"default_data\": 9})      task_1 = Task(\"grault\", {}, print, [data_node_1, data_node_2], [data_node_4], TaskId(\"t1\"))      task_2 = Task(\"garply\", {}, print, [data_node_6], [data_node_5], TaskId(\"t2\"))      task_3 = Task(\"waldo\", {}, print, [data_node_5, data_node_4], id=TaskId(\"t3\"))      task_4 = Task(\"fred\", {}, print, [data_node_4], [data_node_7], TaskId(\"t4\"))      task_5 = Task(\"t5\", {}, print, [data_node_8], [data_node_9], TaskId(\"t5\"))      task_6 = Task(\"t6\", {}, print, [data_node_7, data_node_9], id=TaskId(\"t6\"))      scenario = Scenario(\"scenario\", {task_1, task_2, task_3, task_4, task_5, task_6}, {}, set(), ScenarioId(\"s1\"))      # s1 ---      s6 ---> t2 ---> s5      #       |                     |      #       |---> t1 ---|      -----> t3      #       |           |      |      # s2 ---             ---> s4 ---> t4 ---> s7 ---> t6      #                                              |      # s8 -------> t5 -------> s9 ------------------      assert scenario.get_inputs() == {data_node_1, data_node_2, data_node_6, data_node_8}        data_manager = _DataManagerFactory._build_manager()      data_manager._delete_all()      for dn in [data_node_1, data_node_2, data_node_4, data_node_5, data_node_6, data_node_7, data_node_8, data_node_9]:          data_manager._set(dn)        assert scenario.is_ready_to_run()        data_node_1.edit_in_progress = True      assert not scenario.is_ready_to_run()        data_node_2.edit_in_progress = True      assert not scenario.is_ready_to_run()        data_node_6.edit_in_progress = True      data_node_8.edit_in_progress = True      assert not scenario.is_ready_to_run()        data_node_1.edit_in_progress = False      data_node_2.edit_in_progress = False      data_node_6.edit_in_progress = False      data_node_8.edit_in_progress = False      assert scenario.is_ready_to_run()      def test_data_nodes_being_edited():      data_node_1 = PickleDataNode(\"foo\", Scope.SCENARIO, \"s1\", properties={\"default_data\": 1})      data_node_2 = PickleDataNode(\"bar\", Scope.SCENARIO, \"s2\", properties={\"default_data\": 2})      data_node_4 = PickleDataNode(\"qux\", Scope.SCENARIO, \"s4\", properties={\"default_data\": 4})      data_node_5 = PickleDataNode(\"quux\", Scope.SCENARIO, \"s5\", properties={\"default_data\": 5})      data_node_6 = PickleDataNode(\"quuz\", Scope.SCENARIO, \"s6\", properties={\"default_data\": 6})      data_node_7 = PickleDataNode(\"corge\", Scope.SCENARIO, \"s7\", properties={\"default_data\": 7})      data_node_8 = PickleDataNode(\"d8\", Scope.SCENARIO, \"s8\", properties={\"default_data\": 8})      data_node_9 = PickleDataNode(\"d9\", Scope.SCENARIO, \"s9\", properties={\"default_data\": 9})      task_1 = Task(\"grault\", {}, print, [data_node_1, data_node_2], [data_node_4], TaskId(\"t1\"))      task_2 = Task(\"garply\", {}, print, [data_node_6], [data_node_5], TaskId(\"t2\"))      task_3 = Task(\"waldo\", {}, print, [data_node_5, data_node_4], id=TaskId(\"t3\"))      task_4 = Task(\"fred\", {}, print, [data_node_4], [data_node_7], TaskId(\"t4\"))      task_5 = Task(\"t5\", {}, print, [data_node_8], [data_node_9], TaskId(\"t5\"))      task_6 = Task(\"t6\", {}, print, [data_node_7, data_node_9], id=TaskId(\"t6\"))      scenario = Scenario(\"scenario\", {task_1, task_2, task_3, task_4, task_5, task_6}, {}, set(), ScenarioId(\"s1\"))      # s1 ---      s6 ---> t2 ---> s5      #       |                     |      #       |---> t1 ---|      -----> t3      #       |           |      |      # s2 ---             ---> s4 ---> t4 ---> s7 ---> t6      #                                              |      # s8 -------> t5 -------> s9 ------------------        data_manager = _DataManagerFactory._build_manager()      for dn in [data_node_1, data_node_2, data_node_4, data_node_5, data_node_6, data_node_7, data_node_8, data_node_9]:          data_manager._set(dn)        assert len(scenario.data_nodes_being_edited()) == 0      assert scenario.data_nodes_being_edited() == set()        data_node_1.edit_in_progress = True      assert len(scenario.data_nodes_being_edited()) == 1      assert scenario.data_nodes_being_edited() == {data_node_1}        data_node_2.edit_in_progress = True      data_node_6.edit_in_progress = True      data_node_8.edit_in_progress = True      assert len(scenario.data_nodes_being_edited()) == 4      assert scenario.data_nodes_being_edited() == {data_node_1, data_node_2, data_node_6, data_node_8}        data_node_4.edit_in_progress = True      data_node_5.edit_in_progress = True      data_node_9.edit_in_progress = True      assert len(scenario.data_nodes_being_edited()) == 7      assert scenario.data_nodes_being_edited() == {          data_node_1,          data_node_2,          data_node_4,          data_node_5,          data_node_6,          data_node_8,          data_node_9,      }        data_node_1.edit_in_progress = False      data_node_2.edit_in_progress = False      data_node_6.edit_in_progress = False      data_node_8.edit_in_progress = False      assert len(scenario.data_nodes_being_edited()) == 3      assert scenario.data_nodes_being_edited() == {data_node_4, data_node_5, data_node_9}        data_node_4.edit_in_progress = False      data_node_5.edit_in_progress = False      data_node_7.edit_in_progress = True      assert len(scenario.data_nodes_being_edited()) == 2      assert scenario.data_nodes_being_edited() == {data_node_7, data_node_9}        data_node_7.edit_in_progress = False      data_node_9.edit_in_progress = False      assert len(scenario.data_nodes_being_edited()) == 0      assert scenario.data_nodes_being_edited() == set()      def test_get_tasks():      task_1 = Task(\"grault\", {}, print, id=TaskId(\"t1\"))      task_2 = Task(\"garply\", {}, print, id=TaskId(\"t2\"))      task_3 = Task(\"waldo\", {}, print, id=TaskId(\"t3\"))      task_4 = Task(\"fred\", {}, print, id=TaskId(\"t4\"))      scenario_1 = Scenario(\"scenario_1\", {task_1, task_2, task_3, task_4}, {}, set(), ScenarioId(\"s1\"))      assert scenario_1.tasks == {\"grault\": task_1, \"garply\": task_2, \"waldo\": task_3, \"fred\": task_4}        task_5 = Task(\"wallo\", {}, print, id=TaskId(\"t5\"))      scenario_2 = Scenario(\"scenario_2\", {task_1, task_2, task_3, task_4, task_5}, {}, set(), ScenarioId(\"s2\"))      assert scenario_2.tasks == {\"grault\": task_1, \"garply\": task_2, \"waldo\": task_3, \"fred\": task_4, \"wallo\": task_5}      def test_get_set_of_tasks():      task_1 = Task(\"grault\", {}, print, id=TaskId(\"t1\"))      task_2 = Task(\"garply\", {}, print, id=TaskId(\"t2\"))      task_3 = Task(\"waldo\", {}, print, id=TaskId(\"t3\"))      task_4 = Task(\"fred\", {}, print, id=TaskId(\"t4\"))      scenario_1 = Scenario(\"scenario_1\", {task_1, task_2, task_3, task_4}, {}, set(), ScenarioId(\"s1\"))      assert scenario_1._get_set_of_tasks() == {task_1, task_2, task_3, task_4}        task_5 = Task(\"wallo\", {}, print, id=TaskId(\"t5\"))      scenario_2 = Scenario(\"scenario_2\", {task_1, task_2, task_3, task_4, task_5}, {}, set(), ScenarioId(\"s2\"))      assert scenario_2._get_set_of_tasks() == {task_1, task_2, task_3, task_4, task_5}      def test_get_sorted_tasks():      def _assert_equal(tasks_a, tasks_b) -> bool:          if len(tasks_a) != len(tasks_b):              return False          for i in range(len(tasks_a)):              task_a, task_b = tasks_a[i], tasks_b[i]              if isinstance(task_a, list) and isinstance(task_b, list):                  if not _assert_equal(task_a, task_b):                      return False              elif isinstance(task_a, list) or isinstance(task_b, list):                  return False              else:                  index_task_b = tasks_b.index(task_a)                  if any([isinstance(task_b, list) for task_b in tasks_b[i : index_task_b + 1]]):                      return False          return True        # s1 ---             ---> s3 ---> t2 ---> s5 ----      #       |           |                           |      #       |---> t1 ---|      -------------------------> t3 ---> s6      #       |           |      |      # s2 ---             ---> s4 ---> t4 ---> s7        data_node_1 = InMemoryDataNode(\"foo\", Scope.SCENARIO, \"s1\")      data_node_2 = InMemoryDataNode(\"bar\", Scope.SCENARIO, \"s2\")      data_node_3 = InMemoryDataNode(\"baz\", Scope.SCENARIO, \"s3\")      data_node_4 = InMemoryDataNode(\"qux\", Scope.SCENARIO, \"s4\")      data_node_5 = InMemoryDataNode(\"quux\", Scope.SCENARIO, \"s5\")      data_node_6 = InMemoryDataNode(\"quuz\", Scope.SCENARIO, \"s6\")      data_node_7 = InMemoryDataNode(\"corge\", Scope.SCENARIO, \"s7\")      task_1 = Task(\"grault\", {}, print, [data_node_1, data_node_2], [data_node_3, data_node_4], TaskId(\"t1\"))      task_2 = Task(\"garply\", {}, print, [data_node_3], [data_node_5], TaskId(\"t2\"))      task_3 = Task(\"waldo\", {}, print, [data_node_5, data_node_4], [data_node_6], TaskId(\"t3\"))      task_4 = Task(\"fred\", {}, print, [data_node_4], [data_node_7], TaskId(\"t4\"))      scenario_1 = Scenario(\"scenario_1\", {task_1, task_2, task_3, task_4}, {}, [], ScenarioId(\"s1\"))        assert scenario_1.get_inputs() == {data_node_1, data_node_2}      assert scenario_1._get_set_of_tasks() == {task_1, task_2, task_3, task_4}      _assert_equal(scenario_1._get_sorted_tasks(), [[task_1], [task_2, task_4], [task_3]])        # s1 ---              t2 ---> s5      #       |                     |      #       |---> t1 ---|      -----> t3 ---> s6      #       |           |      |      # s2 ---             ---> s4 ---> t4 ---> s7        data_node_1 = InMemoryDataNode(\"foo\", Scope.SCENARIO, \"s1\")      data_node_2 = InMemoryDataNode(\"bar\", Scope.SCENARIO, \"s2\")      data_node_4 = InMemoryDataNode(\"qux\", Scope.SCENARIO, \"s4\")      data_node_5 = InMemoryDataNode(\"quux\", Scope.SCENARIO, \"s5\")      data_node_6 = InMemoryDataNode(\"quuz\", Scope.SCENARIO, \"s6\")      data_node_7 = InMemoryDataNode(\"corge\", Scope.SCENARIO, \"s7\")      task_1 = Task(\"grault\", {}, print, [data_node_1, data_node_2], [data_node_4], TaskId(\"t1\"))      task_2 = Task(\"garply\", {}, print, None, [data_node_5], TaskId(\"t2\"))      task_3 = Task(\"waldo\", {}, print, [data_node_5, data_node_4], [data_node_6], TaskId(\"t3\"))      task_4 = Task(\"fred\", {}, print, [data_node_4], [data_node_7], TaskId(\"t4\"))      scenario_2 = Scenario(\"scenario_2\", {task_1, task_2, task_3, task_4}, {}, [], ScenarioId(\"s2\"))        assert scenario_2.get_inputs() == {data_node_1, data_node_2}      assert scenario_2._get_set_of_tasks() == {task_1, task_2, task_3, task_4}      _assert_equal(scenario_2._get_sorted_tasks(), [[task_1, task_2], [task_3, task_4]])        # s1 ---      s6 ---> t2 ---> s5      #       |                     |      #       |---> t1 ---|      -----> t3      #       |           |      |      # s2 ---             ---> s4 ---> t4 ---> s7        data_node_1 = DataNode(\"foo\", Scope.SCENARIO, \"s1\")      data_node_2 = DataNode(\"bar\", Scope.SCENARIO, \"s2\")      data_node_4 = DataNode(\"qux\", Scope.SCENARIO, \"s4\")      data_node_5 = DataNode(\"quux\", Scope.SCENARIO, \"s5\")      data_node_6 = DataNode(\"quuz\", Scope.SCENARIO, \"s6\")      data_node_7 = DataNode(\"corge\", Scope.SCENARIO, \"s7\")      task_1 = Task(          \"grault\",          {},          print,          [data_node_1, data_node_2],          [data_node_4],          TaskId(\"t1\"),      )      task_2 = Task(\"garply\", {}, print, [data_node_6], [data_node_5], TaskId(\"t2\"))      task_3 = Task(\"waldo\", {}, print, [data_node_5, data_node_4], id=TaskId(\"t3\"))      task_4 = Task(\"fred\", {}, print, [data_node_4], [data_node_7], TaskId(\"t4\"))      scenario_3 = Scenario(\"quest\", [task_4, task_2, task_1, task_3], {}, [], scenario_id=ScenarioId(\"s3\"))        assert scenario_3.get_inputs() == {data_node_1, data_node_2, data_node_6}      assert scenario_3._get_set_of_tasks() == {task_1, task_2, task_3, task_4}      assert _assert_equal(scenario_3._get_sorted_tasks(), [[task_2, task_1], [task_4, task_3]])        # s1 ---      s6 ---> t2 ---> s5      #       |                     |      #       |---> t1 ---|      -----> t3      #       |           |      |      # s2 ---             ---> s4 ---> t4 ---> s7 ---> t6      #                                              |      # s8 -------> t5 -------> s9 ------------------        data_node_1 = InMemoryDataNode(\"foo\", Scope.SCENARIO, \"s1\")      data_node_2 = InMemoryDataNode(\"bar\", Scope.SCENARIO, \"s2\")      data_node_4 = InMemoryDataNode(\"qux\", Scope.SCENARIO, \"s4\")      data_node_5 = InMemoryDataNode(\"quux\", Scope.SCENARIO, \"s5\")      data_node_6 = InMemoryDataNode(\"quuz\", Scope.SCENARIO, \"s6\")      data_node_7 = InMemoryDataNode(\"corge\", Scope.SCENARIO, \"s7\")      data_node_8 = InMemoryDataNode(\"d8\", Scope.SCENARIO, \"s8\")      data_node_9 = InMemoryDataNode(\"d9\", Scope.SCENARIO, \"s9\")      task_1 = Task(\"grault\", {}, print, [data_node_1, data_node_2], [data_node_4], TaskId(\"t1\"))      task_2 = Task(\"garply\", {}, print, [data_node_6], [data_node_5], TaskId(\"t2\"))      task_3 = Task(\"waldo\", {}, print, [data_node_5, data_node_4], id=TaskId(\"t3\"))      task_4 = Task(\"fred\", {}, print, [data_node_4], [data_node_7], TaskId(\"t4\"))      task_5 = Task(\"t5\", {}, print, [data_node_8], [data_node_9], TaskId(\"t5\"))      task_6 = Task(\"t6\", {}, print, [data_node_7, data_node_9], id=TaskId(\"t6\"))      scenario_4 = Scenario(\"scenario_3\", [task_1, task_2, task_3, task_4, task_5, task_6], {}, [], ScenarioId(\"s4\"))        assert scenario_4.get_inputs() == {data_node_1, data_node_2, data_node_6, data_node_8}      assert scenario_4._get_set_of_tasks() == {task_1, task_2, task_3, task_4, task_5, task_6}      _assert_equal(scenario_4._get_sorted_tasks(), [[task_1, task_2, task_5], [task_3, task_4], [task_6]])        # s1 ---      #       |      #       |---> t1 ---|      -----> t3      #       |           |      |      # s2 ---             ---> s4 ---> t4 ---> s7      # t2 ---> s5                      |      # s8 ---> t5                 s6 --|        data_node_1 = InMemoryDataNode(\"foo\", Scope.SCENARIO, \"s1\")      data_node_2 = InMemoryDataNode(\"bar\", Scope.SCENARIO, \"s2\")      data_node_4 = InMemoryDataNode(\"qux\", Scope.SCENARIO, \"s4\")      data_node_5 = InMemoryDataNode(\"quux\", Scope.SCENARIO, \"s5\")      data_node_6 = InMemoryDataNode(\"quuz\", Scope.SCENARIO, \"s6\")      data_node_7 = InMemoryDataNode(\"corge\", Scope.SCENARIO, \"s7\")      data_node_8 = InMemoryDataNode(\"hugh\", Scope.SCENARIO, \"s8\")      task_1 = Task(\"grault\", {}, print, [data_node_1, data_node_2], [data_node_4], TaskId(\"t1\"))      task_2 = Task(\"garply\", {}, print, output=[data_node_5], id=TaskId(\"t2\"))      task_3 = Task(\"waldo\", {}, print, [data_node_4], None, id=TaskId(\"t3\"))      task_4 = Task(\"fred\", {}, print, [data_node_4, data_node_6], [data_node_7], TaskId(\"t4\"))      task_5 = Task(\"bob\", {}, print, [data_node_8], None, TaskId(\"t5\"))      scenario_5 = Scenario(\"scenario_4\", [task_1, task_2, task_3, task_4, task_5], {}, [], ScenarioId(\"s5\"))        assert scenario_5.get_inputs() == {data_node_1, data_node_2, data_node_8, data_node_6}      assert scenario_5._get_set_of_tasks() == {task_1, task_2, task_3, task_4, task_5}      _assert_equal(scenario_5._get_sorted_tasks(), [[task_1, task_2, task_5], [task_3, task_4]])        #  p1  s1 ---      #            |      #            |---> t1 ---|      -----> t3      #            |           |      |      #      s2 ---             ---> s4 ---> t4 ---> s5      #  p2  t2 ---> s4 ---> t3      #  p3  s6 ---> t5        data_node_1 = DataNode(\"foo\", Scope.SCENARIO, \"s1\")      data_node_2 = DataNode(\"bar\", Scope.SCENARIO, \"s2\")      data_node_4 = DataNode(\"qux\", Scope.SCENARIO, \"s4\")      data_node_5 = DataNode(\"quux\", Scope.SCENARIO, \"s5\")      data_node_6 = DataNode(\"quuz\", Scope.SCENARIO, \"s6\")      task_1 = Task(          \"grault\",          {},          print,          [data_node_1, data_node_2],          [data_node_4],          TaskId(\"t1\"),      )      task_2 = Task(\"garply\", {}, print, output=[data_node_4], id=TaskId(\"t2\"))      task_3 = Task(\"waldo\", {}, print, [data_node_4], None, id=TaskId(\"t3\"))      task_4 = Task(\"fred\", {}, print, [data_node_4], [data_node_5], TaskId(\"t4\"))      task_5 = Task(\"bob\", {}, print, [data_node_6], None, TaskId(\"t5\"))      scenario_6 = Scenario(\"quest\", [task_1, task_2, task_3, task_4, task_5], {}, [], ScenarioId(\"s6\"))        assert scenario_6.get_inputs() == {data_node_1, data_node_2, data_node_6}      assert scenario_6._get_set_of_tasks() == {task_1, task_2, task_3, task_4, task_5}      _assert_equal(scenario_6._get_sorted_tasks(), [[task_5, task_2, task_1], [task_4, task_3]])        #  p1  s1 ---      #            |      #            |---> t1 ---|      -----> t3      #            |           |      |      #      s2 ---             ---> s4 ---> t4 ---> s5      #  p2  t2 ---> s4 ---> t3      #  p3  s6 ---> t5 ---> s4 ---> t4 ---> s5        data_node_1 = DataNode(\"foo\", Scope.SCENARIO, \"s1\")      data_node_2 = DataNode(\"bar\", Scope.SCENARIO, \"s2\")      data_node_4 = DataNode(\"qux\", Scope.SCENARIO, \"s4\")      data_node_5 = DataNode(\"quux\", Scope.SCENARIO, \"s5\")      data_node_6 = DataNode(\"quuz\", Scope.SCENARIO, \"s6\")      task_1 = Task(          \"grault\",          {},          print,          [data_node_1, data_node_2],          [data_node_4],          TaskId(\"t1\"),      )      task_2 = Task(\"garply\", {}, print, output=[data_node_4], id=TaskId(\"t2\"))      task_3 = Task(\"waldo\", {}, print, [data_node_4], None, id=TaskId(\"t3\"))      task_4 = Task(\"fred\", {}, print, [data_node_4], [data_node_5], TaskId(\"t4\"))      task_5 = Task(\"bob\", {}, print, [data_node_6], [data_node_4], None, TaskId(\"t5\"))      scenario_7 = Scenario(\"quest\", [task_4, task_1, task_2, task_3, task_5], {}, [], scenario_id=ScenarioId(\"s7\"))        assert scenario_7.get_inputs() == {data_node_1, data_node_2, data_node_6}      assert scenario_7._get_set_of_tasks() == {task_1, task_2, task_3, task_4, task_5}      _assert_equal(scenario_7._get_sorted_tasks(), [[task_5, task_2, task_1], [task_4, task_3]])        #  p1  s1 ---      #            |      #            |---> t1 ---|      -----> t3      #            |           |      |      #      s2 ---             ---> s3 ---> t4 ---> s4      #  p2  t2 ---> s3 ---> t3      #  p3  s5 ---> t5 ---> s3 ---> t4 ---> s4      #  p4  s3 ---> t4 ---> s4        data_node_1 = DataNode(\"foo\", Scope.SCENARIO, \"s1\")      data_node_2 = DataNode(\"bar\", Scope.SCENARIO, \"s2\")      data_node_3 = DataNode(\"qux\", Scope.SCENARIO, \"s3\")      data_node_4 = DataNode(\"quux\", Scope.SCENARIO, \"s4\")      data_node_5 = DataNode(\"quuz\", Scope.SCENARIO, \"s5\")      task_1 = Task(          \"grault\",          {},          print,          [data_node_1, data_node_2],          [data_node_3],          TaskId(\"t1\"),      )      task_2 = Task(\"garply\", {}, print, output=[data_node_3], id=TaskId(\"t2\"))      task_3 = Task(\"waldo\", {}, print, [data_node_3], None, id=TaskId(\"t3\"))      task_4 = Task(\"fred\", {}, print, [data_node_3], [data_node_4], TaskId(\"t4\"))      task_5 = Task(\"bob\", {}, print, [data_node_5], [data_node_3], TaskId(\"t5\"))      scenario_8 = Scenario(\"quest\", [task_1, task_2, task_3, task_4, task_5], {}, [], scenario_id=ScenarioId(\"s8\"))        assert scenario_8.get_inputs() == {data_node_1, data_node_2, data_node_5}      assert scenario_8._get_set_of_tasks() == {task_1, task_2, task_3, task_4, task_5}      _assert_equal(scenario_8._get_sorted_tasks(), [[task_5, task_2, task_1], [task_3, task_4]])      def test_add_and_remove_sequences():      data_node_1 = InMemoryDataNode(\"foo\", Scope.SCENARIO, \"s1\")      data_node_2 = InMemoryDataNode(\"bar\", Scope.SCENARIO, \"s2\")      data_node_3 = InMemoryDataNode(\"qux\", Scope.SCENARIO, \"s3\")      data_node_4 = InMemoryDataNode(\"quux\", Scope.SCENARIO, \"s4\")      data_node_5 = InMemoryDataNode(\"quuz\", Scope.SCENARIO, \"s5\")      task_1 = Task(          \"grault\",          {},          print,          [data_node_1, data_node_2],          [data_node_3],          TaskId(\"t1\"),      )      task_2 = Task(\"garply\", {}, print, [data_node_3], id=TaskId(\"t2\"))      task_3 = Task(\"waldo\", {}, print, [data_node_3], None, id=TaskId(\"t3\"))      task_4 = Task(\"fred\", {}, print, [data_node_3], [data_node_4], TaskId(\"t4\"))      task_5 = Task(\"bob\", {}, print, [data_node_5], [data_node_3], TaskId(\"t5\"))      scenario_1 = Scenario(\"quest\", [task_1, task_2, task_3, task_4, task_5], {}, [], scenario_id=ScenarioId(\"s1\"))        sequence_1 = Sequence({\"name\": \"sequence_1\"}, [task_1], SequenceId(f\"SEQUENCE_sequence_1_{scenario_1.id}\"))      sequence_2 = Sequence({\"name\": \"sequence_2\"}, [task_1, task_2], SequenceId(f\"SEQUENCE_sequence_2_{scenario_1.id}\"))      sequence_3 = Sequence(          {\"name\": \"sequence_3\"}, [task_1, task_5, task_3], SequenceId(f\"SEQUENCE_sequence_3_{scenario_1.id}\")      )        task_manager = _TaskManagerFactory._build_manager()      data_manager = _DataManagerFactory._build_manager()      scenario_manager = _ScenarioManagerFactory._build_manager()      for dn in [data_node_1, data_node_2, data_node_3, data_node_4, data_node_5]:          data_manager._set(dn)      for t in [task_1, task_2, task_3, task_4, task_5]:          task_manager._set(t)      scenario_manager._set(scenario_1)        assert scenario_1.get_inputs() == {data_node_1, data_node_2, data_node_5}      assert scenario_1._get_set_of_tasks() == {task_1, task_2, task_3, task_4, task_5}      assert len(scenario_1.sequences) == 0        scenario_1.sequences = {\"sequence_1\": {\"tasks\": [task_1]}}      assert scenario_1.sequences == {\"sequence_1\": sequence_1}        scenario_1.add_sequences({\"sequence_2\": [task_1, task_2]})      assert scenario_1.sequences == {\"sequence_1\": sequence_1, \"sequence_2\": sequence_2}        scenario_1.remove_sequences([\"sequence_1\"])      assert scenario_1.sequences == {\"sequence_2\": sequence_2}        scenario_1.add_sequences({\"sequence_1\": [task_1], \"sequence_3\": [task_1, task_5, task_3]})      assert scenario_1.sequences == {          \"sequence_2\": sequence_2,          \"sequence_1\": sequence_1,          \"sequence_3\": sequence_3,      }        scenario_1.remove_sequences([\"sequence_2\", \"sequence_3\"])      assert scenario_1.sequences == {\"sequence_1\": sequence_1}      def test_check_consistency():      data_node_1 = InMemoryDataNode(\"foo\", Scope.SCENARIO, \"s1\")      data_node_2 = InMemoryDataNode(\"bar\", Scope.SCENARIO, \"s2\")      data_node_3 = InMemoryDataNode(\"bar\", Scope.SCENARIO, \"s3\")      data_node_4 = InMemoryDataNode(\"qux\", Scope.SCENARIO, \"s4\")      data_node_5 = InMemoryDataNode(\"quux\", Scope.SCENARIO, \"s5\")      data_node_6 = InMemoryDataNode(\"quuz\", Scope.SCENARIO, \"s6\")      data_node_7 = InMemoryDataNode(\"corge\", Scope.SCENARIO, \"s7\")      data_node_8 = InMemoryDataNode(\"d8\", Scope.SCENARIO, \"s8\")      data_node_9 = InMemoryDataNode(\"d9\", Scope.SCENARIO, \"s9\")        scenario_0 = Scenario(\"scenario_0\", [], {})      assert scenario_0._is_consistent()        task_1 = Task(\"foo\", {}, print, [data_node_1], [data_node_2], TaskId(\"t1\"))      scenario_1 = Scenario(\"scenario_1\", [task_1], {})      assert scenario_1._is_consistent()        # s1 ---             ---> s3 ---> t2 ---> s5 ----      #       |           |                           |      #       |---> t1 ---|      -------------------------> t3 ---> s6      #       |           |      |      # s2 ---             ---> s4 ---> t4 ---> s7      task_1 = Task(\"grault\", {}, print, [data_node_1, data_node_2], [data_node_3, data_node_4], TaskId(\"t1\"))      task_2 = Task(\"garply\", {}, print, [data_node_3], [data_node_5], TaskId(\"t2\"))      task_3 = Task(\"waldo\", {}, print, [data_node_5, data_node_4], [data_node_6], TaskId(\"t3\"))      task_4 = Task(\"fred\", {}, print, [data_node_4], [data_node_7], TaskId(\"t4\"))      scenario_2 = Scenario(\"scenario_2\", {task_1, task_2, task_3, task_4}, {}, [], ScenarioId(\"s1\"))      assert scenario_2._is_consistent()        # s1 ---              t2 ---> s5      #       |                     |      #       |---> t1 ---|      -----> t3 ---> s6      #       |           |      |      # s2 ---             ---> s4 ---> t4 ---> s7      task_1 = Task(\"grault\", {}, print, [data_node_1, data_node_2], [data_node_4], TaskId(\"t1\"))      task_2 = Task(\"garply\", {}, print, None, [data_node_5], TaskId(\"t2\"))      task_3 = Task(\"waldo\", {}, print, [data_node_5, data_node_4], [data_node_6], TaskId(\"t3\"))      task_4 = Task(\"fred\", {}, print, [data_node_4], [data_node_7], TaskId(\"t4\"))      scenario_3 = Scenario(\"scenario_3\", {task_1, task_2, task_3, task_4}, {}, [], ScenarioId(\"s2\"))      assert scenario_3._is_consistent()        # s1 ---      s6 ---> t2 ---> s5      #       |                     |      #       |---> t1 ---|      -----> t3      #       |           |      |      # s2 ---             ---> s4 ---> t4 ---> s7      task_1 = Task(\"grault\", {}, print, [data_node_1, data_node_2], [data_node_4], TaskId(\"t1\"))      task_2 = Task(\"garply\", {}, print, [data_node_6], [data_node_5], TaskId(\"t2\"))      task_3 = Task(\"waldo\", {}, print, [data_node_5, data_node_4], id=TaskId(\"t3\"))      task_4 = Task(\"fred\", {}, print, [data_node_4], [data_node_7], TaskId(\"t4\"))      scenario_4 = Scenario(\"scenario_4\", [task_4, task_2, task_1, task_3], {}, [], scenario_id=ScenarioId(\"s3\"))      assert scenario_4._is_consistent()        # s1 ---      s6 ---> t2 ---> s5      #       |                     |      #       |---> t1 ---|      -----> t3      #       |           |      |      # s2 ---             ---> s4 ---> t4 ---> s7 ---> t6      #                                              |      # s8 -------> t5 -------> s9 ------------------      task_1 = Task(\"grault\", {}, print, [data_node_1, data_node_2], [data_node_4], TaskId(\"t1\"))      task_2 = Task(\"garply\", {}, print, [data_node_6], [data_node_5], TaskId(\"t2\"))      task_3 = Task(\"waldo\", {}, print, [data_node_5, data_node_4], id=TaskId(\"t3\"))      task_4 = Task(\"fred\", {}, print, [data_node_4], [data_node_7], TaskId(\"t4\"))      task_5 = Task(\"t5\", {}, print, [data_node_8], [data_node_9], TaskId(\"t5\"))      task_6 = Task(\"t6\", {}, print, [data_node_7, data_node_9], id=TaskId(\"t6\"))      scenario_5 = Scenario(\"scenario_5\", [task_1, task_2, task_3, task_4, task_5, task_6], {}, [], ScenarioId(\"s4\"))      assert scenario_5._is_consistent()        # s1 ---      #       |      #       |---> t1 ---|      -----> t3      #       |           |      |      # s2 ---             ---> s4 ---> t4 ---> s7      # t2 ---> s5                      |      # s8 ---> t5                 s6 --|      task_1 = Task(\"grault\", {}, print, [data_node_1, data_node_2], [data_node_4], TaskId(\"t1\"))      task_2 = Task(\"garply\", {}, print, output=[data_node_5], id=TaskId(\"t2\"))      task_3 = Task(\"waldo\", {}, print, [data_node_4], None, id=TaskId(\"t3\"))      task_4 = Task(\"fred\", {}, print, [data_node_4, data_node_6], [data_node_7], TaskId(\"t4\"))      task_5 = Task(\"bob\", {}, print, [data_node_8], None, TaskId(\"t5\"))      scenario_6 = Scenario(\"scenario_6\", [task_1, task_2, task_3, task_4, task_5], {}, [], ScenarioId(\"s5\"))      assert scenario_6._is_consistent()        #  p1  s1 ---      #            |      #            |---> t1 ---|      -----> t3      #            |           |      |      #      s2 ---             ---> s4 ---> t4 ---> s5      #  p2  t2 ---> s4 ---> t3      #  p3  s6 ---> t5      task_1 = Task(\"grault\", {}, print, [data_node_1, data_node_2], [data_node_4], TaskId(\"t1\"))      task_2 = Task(\"garply\", {}, print, output=[data_node_4], id=TaskId(\"t2\"))      task_3 = Task(\"waldo\", {}, print, [data_node_4], None, id=TaskId(\"t3\"))      task_4 = Task(\"fred\", {}, print, [data_node_4], [data_node_5], TaskId(\"t4\"))      task_5 = Task(\"bob\", {}, print, [data_node_6], None, TaskId(\"t5\"))      scenario_7 = Scenario(\"scenario_7\", [task_1, task_2, task_3, task_4, task_5], {}, [], ScenarioId(\"s6\"))      assert scenario_7._is_consistent()        #  p1  s1 ---      #            |      #            |---> t1 ---|      -----> t3      #            |           |      |      #      s2 ---             ---> s4 ---> t4 ---> s5      #  p2  t2 ---> s4 ---> t3      #  p3  s6 ---> t5 ---> s4 ---> t4 ---> s5      task_1 = Task(\"grault\", {}, print, [data_node_1, data_node_2], [data_node_4], TaskId(\"t1\"))      task_2 = Task(\"garply\", {}, print, output=[data_node_4], id=TaskId(\"t2\"))      task_3 = Task(\"waldo\", {}, print, [data_node_4], None, id=TaskId(\"t3\"))      task_4 = Task(\"fred\", {}, print, [data_node_4], [data_node_5], TaskId(\"t4\"))      task_5 = Task(\"bob\", {}, print, [data_node_6], [data_node_4], None, TaskId(\"t5\"))      scenario_8 = Scenario(\"scenario_8\", [task_4, task_1, task_2, task_3, task_5], {}, [], scenario_id=ScenarioId(\"s7\"))      assert scenario_8._is_consistent()        #  p1  s1 ---      #            |      #            |---> t1 ---|      -----> t3      #            |           |      |      #      s2 ---             ---> s3 ---> t4 ---> s4      #  p2  t2 ---> s3 ---> t3      #  p3  s5 ---> t5 ---> s3 ---> t4 ---> s4      #  p4  s3 ---> t4 ---> s4      task_1 = Task(\"grault\", {}, print, [data_node_1, data_node_2], [data_node_3], TaskId(\"t1\"))      task_2 = Task(\"garply\", {}, print, output=[data_node_3], id=TaskId(\"t2\"))      task_3 = Task(\"waldo\", {}, print, [data_node_3], None, id=TaskId(\"t3\"))      task_4 = Task(\"fred\", {}, print, [data_node_3], [data_node_4], TaskId(\"t4\"))      task_5 = Task(\"bob\", {}, print, [data_node_5], [data_node_3], TaskId(\"t5\"))      scenario_9 = Scenario(\"scenario_9\", [task_1, task_2, task_3, task_4, task_5], {}, [], scenario_id=ScenarioId(\"s8\"))      assert scenario_9._is_consistent() "}
{"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 multiprocessing  from unittest.mock import patch    from src.taipy.core import Core, taipy  from src.taipy.core.data._data_manager import _DataManager  from src.taipy.core.scenario._scenario_manager import _ScenarioManager  from taipy.config.config import Config  from tests.core.utils import assert_true_after_time    from ...conftest import init_config    m = multiprocessing.Manager()      def twice(a):      return a * 2      def triple(a):      return a * 3      def migrate_pickle_path(dn):      dn.path = \"bar.pkl\"      return dn      def migrate_skippable_task(task):      task.skippable = True      return task      def migrate_foo_scenario(scenario):      scenario.properties[\"foo\"] = \"bar\"      return scenario      def test_migrate_datanode():      scenario_v1 = submit_v1()        init_config()      Config.add_migration_function(\"2.0\", \"d1\", migrate_pickle_path)        submit_v2()      v1 = taipy.get(scenario_v1.id)      assert v1.d1.version == \"2.0\"      assert v1.d1.path == \"bar.pkl\"      def test_migrate_datanode_in_standalone_mode():      scenario_v1 = submit_v1()        init_config()      Config.configure_job_executions(mode=\"standalone\", max_nb_of_workers=2)      Config.add_migration_function(\"2.0\", \"d1\", migrate_pickle_path)        scenario_cfg_v2 = config_scenario_v2()      with patch(\"sys.argv\", [\"prog\", \"--production\", \"2.0\"]):          core = Core()          core.run()          scenario_v2 = _ScenarioManager._create(scenario_cfg_v2)          jobs = _ScenarioManager._submit(scenario_v2)          v1 = taipy.get(scenario_v1.id)          assert v1.d1.version == \"2.0\"          assert v1.d1.path == \"bar.pkl\"          assert_true_after_time(jobs[0].is_completed)          core.stop()      def test_migrate_task():      scenario_v1 = submit_v1()        init_config()      Config.add_migration_function(\"2.0\", \"my_task\", migrate_skippable_task)        submit_v2()      v1 = taipy.get(scenario_v1.id)      assert v1.my_task.version == \"2.0\"      assert v1.my_task.skippable is True      def test_migrate_task_in_standalone_mode():      scenario_v1 = submit_v1()        init_config()      Config.configure_job_executions(mode=\"standalone\", max_nb_of_workers=2)      Config.add_migration_function(\"2.0\", \"my_task\", migrate_skippable_task)        scenario_cfg_v2 = config_scenario_v2()      with patch(\"sys.argv\", [\"prog\", \"--production\", \"2.0\"]):          core = Core()          core.run()          scenario_v2 = _ScenarioManager._create(scenario_cfg_v2)          jobs = _ScenarioManager._submit(scenario_v2)          v1 = taipy.get(scenario_v1.id)          assert v1.my_task.version == \"2.0\"          assert v1.my_task.skippable is True          assert_true_after_time(jobs[0].is_completed)          core.stop()      def test_migrate_scenario():      scenario_v1 = submit_v1()        init_config()      Config.add_migration_function(\"2.0\", \"my_scenario\", migrate_foo_scenario)        submit_v2()      v1 = taipy.get(scenario_v1.id)      assert v1.version == \"2.0\"      assert v1.properties[\"foo\"] == \"bar\"      def test_migrate_scenario_in_standalone_mode():      scenario_v1 = submit_v1()        init_config()      Config.configure_job_executions(mode=\"standalone\", max_nb_of_workers=2)      Config.add_migration_function(\"2.0\", \"my_scenario\", migrate_foo_scenario)        scenario_cfg_v2 = config_scenario_v2()      with patch(\"sys.argv\", [\"prog\", \"--production\", \"2.0\"]):          core = Core()          core.run()          scenario_v2 = _ScenarioManager._create(scenario_cfg_v2)          jobs = _ScenarioManager._submit(scenario_v2)          v1 = taipy.get(scenario_v1.id)          assert v1.version == \"2.0\"          assert v1.properties[\"foo\"] == \"bar\"          assert_true_after_time(jobs[0].is_completed)          core.stop()      def test_migrate_all_entities():      scenario_v1 = submit_v1()        init_config()      Config.add_migration_function(\"2.0\", \"d1\", migrate_pickle_path)      Config.add_migration_function(\"2.0\", \"my_task\", migrate_skippable_task)      Config.add_migration_function(\"2.0\", \"my_scenario\", migrate_foo_scenario)        submit_v2()      v1 = taipy.get(scenario_v1.id)        assert v1.d1.version == \"2.0\"      assert v1.my_task.version == \"2.0\"        assert v1.d1.path == \"bar.pkl\"      assert v1.my_task.skippable is True      assert v1.properties[\"foo\"] == \"bar\"      def test_migrate_all_entities_in_standalone_mode():      scenario_v1 = submit_v1()        init_config()      Config.configure_job_executions(mode=\"standalone\", max_nb_of_workers=2)      Config.add_migration_function(\"2.0\", \"my_scenario\", migrate_foo_scenario)        scenario_cfg_v2 = config_scenario_v2()      with patch(\"sys.argv\", [\"prog\", \"--production\", \"2.0\"]):          core = Core()          core.run()          scenario_v2 = _ScenarioManager._create(scenario_cfg_v2)          jobs = _ScenarioManager._submit(scenario_v2)          v1 = taipy.get(scenario_v1.id)          assert v1.version == \"2.0\"          assert v1.properties[\"foo\"] == \"bar\"          assert_true_after_time(jobs[0].is_completed)          core.stop()      def test_migrate_compatible_version():      scenario_cfg = config_scenario_v1()      # Production 1.0      with patch(\"sys.argv\", [\"prog\", \"--production\", \"1.0\"]):          core = Core()          core.run()            scenario_v1 = _ScenarioManager._create(scenario_cfg)          _ScenarioManager._submit(scenario_v1)            assert scenario_v1.d2.read() == 2          assert len(_DataManager._get_all(version_number=\"all\")) == 2          core.stop()        init_config()      scenario_cfg = config_scenario_v1()        # Production 2.0 is a compatible version      with patch(\"sys.argv\", [\"prog\", \"--production\", \"2.0\"]):          core = Core()          core.run()            scenario_v2 = _ScenarioManager._create(scenario_cfg)          _ScenarioManager._submit(scenario_v2)            assert scenario_v2.d2.read() == 2          assert len(_DataManager._get_all(version_number=\"all\")) == 4          core.stop()        init_config()        # Production 2.1      Config.add_migration_function(          target_version=\"2.1\",          config=\"d1\",          migration_fct=migrate_pickle_path,      )      scenario_cfg_v2_1 = config_scenario_v2()        with patch(\"sys.argv\", [\"prog\", \"--production\", \"2.1\"]):          core = Core()          core.run()          scenario_v2_1 = _ScenarioManager._create(scenario_cfg_v2_1)          _ScenarioManager._submit(scenario_v2_1)          core.stop()        assert scenario_v2_1.d2.read() == 6      assert len(_DataManager._get_all(version_number=\"all\")) == 6        v1 = taipy.get(scenario_v1.id)      assert v1.d1.version == \"2.1\"      assert v1.d1.path == \"bar.pkl\"        v2 = taipy.get(scenario_v2.id)      assert v2.d1.version == \"2.1\"      assert v2.d1.path == \"bar.pkl\"      def submit_v1():      scenario_cfg_v1 = config_scenario_v1()      with patch(\"sys.argv\", [\"prog\", \"--production\", \"1.0\"]):          core = Core()          core.run()          scenario_v1 = _ScenarioManager._create(scenario_cfg_v1)          _ScenarioManager._submit(scenario_v1)          core.stop()      return scenario_v1      def submit_v2():      scenario_cfg_v2 = config_scenario_v2()      with patch(\"sys.argv\", [\"prog\", \"--production\", \"2.0\"]):          core = Core()          core.run()          scenario_v2 = _ScenarioManager._create(scenario_cfg_v2)          _ScenarioManager._submit(scenario_v2)          core.stop()      return scenario_v2      def config_scenario_v1():      dn1 = Config.configure_pickle_data_node(id=\"d1\", default_data=1)      dn2 = Config.configure_pickle_data_node(id=\"d2\")      task_cfg = Config.configure_task(\"my_task\", twice, dn1, dn2)      scenario_cfg = Config.configure_scenario(\"my_scenario\", [task_cfg])      scenario_cfg.add_sequences({\"my_sequence\": [task_cfg]})      return scenario_cfg      def config_scenario_v2():      dn1 = Config.configure_pickle_data_node(id=\"d1\", default_data=2)      dn2 = Config.configure_pickle_data_node(id=\"d2\")      task_cfg = Config.configure_task(\"my_task\", triple, dn1, dn2)      scenario_cfg = Config.configure_scenario(\"my_scenario\", [task_cfg])      scenario_cfg.add_sequences({\"my_scenario\": [task_cfg]})      return scenario_cfg "}
{"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": "from time import sleep  from unittest.mock import patch    import pytest    from src.taipy.core import Core  from src.taipy.core._version._cli._version_cli import _VersionCLI  from src.taipy.core._version._version_manager import _VersionManager  from src.taipy.core.data._data_manager import _DataManager  from src.taipy.core.job._job_manager import _JobManager  from src.taipy.core.scenario._scenario_manager import _ScenarioManager  from src.taipy.core.sequence._sequence_manager import _SequenceManager  from src.taipy.core.task._task_manager import _TaskManager  from taipy.config.common.frequency import Frequency  from taipy.config.common.scope import Scope  from taipy.config.config import Config    from ...conftest import init_config      def test_delete_version(caplog):      scenario_config = config_scenario()        with patch(\"sys.argv\", [\"prog\", \"--development\"]):          core = Core()          core.run()          scenario = _ScenarioManager._create(scenario_config)          _ScenarioManager._submit(scenario)          core.stop()        with patch(\"sys.argv\", [\"prog\", \"--experiment\", \"1.0\"]):          core = Core()          core.run()          scenario = _ScenarioManager._create(scenario_config)          _ScenarioManager._submit(scenario)          core.stop()        with patch(\"sys.argv\", [\"prog\", \"--experiment\", \"1.1\"]):          core = Core()          core.run()          scenario = _ScenarioManager._create(scenario_config)          _ScenarioManager._submit(scenario)          core.stop()        with patch(\"sys.argv\", [\"prog\", \"--production\", \"1.1\"]):          core = Core()          core.run()          core.stop()        with patch(\"sys.argv\", [\"prog\", \"--experiment\", \"2.0\"]):          core = Core()          core.run()          scenario = _ScenarioManager._create(scenario_config)          _ScenarioManager._submit(scenario)          core.stop()        with patch(\"sys.argv\", [\"prog\", \"--experiment\", \"2.1\"]):          core = Core()          core.run()          scenario = _ScenarioManager._create(scenario_config)          _ScenarioManager._submit(scenario)          core.stop()        with patch(\"sys.argv\", [\"prog\", \"--production\", \"2.1\"]):          core = Core()          core.run()          core.stop()        all_versions = [version.id for version in _VersionManager._get_all()]      production_version = _VersionManager._get_production_versions()      assert len(all_versions) == 5      assert len(production_version) == 2      assert \"1.0\" in all_versions      assert \"1.1\" in all_versions and \"1.1\" in production_version      assert \"2.0\" in all_versions      assert \"2.1\" in all_versions and \"2.1\" in production_version        _VersionCLI.create_parser()      with pytest.raises(SystemExit):          with patch(\"sys.argv\", [\"prog\", \"manage-versions\", \"--delete\", \"1.0\"]):              _VersionCLI.parse_arguments()        assert \"Successfully delete version 1.0.\" in caplog.text      all_versions = [version.id for version in _VersionManager._get_all()]      assert len(all_versions) == 4      assert \"1.0\" not in all_versions        # Test delete a non-existed version      with pytest.raises(SystemExit):          with patch(\"sys.argv\", [\"prog\", \"manage-versions\", \"--delete\", \"non_exist_version\"]):              _VersionCLI.parse_arguments()      assert \"Version 'non_exist_version' does not exist.\" in caplog.text        # Test delete production version will change the version from production to experiment      with pytest.raises(SystemExit):          with patch(\"sys.argv\", [\"prog\", \"manage-versions\", \"--delete-production\", \"1.1\"]):              _VersionCLI.parse_arguments()        assert \"Successfully delete version 1.1 from the production version list.\" in caplog.text      all_versions = [version.id for version in _VersionManager._get_all()]      production_version = _VersionManager._get_production_versions()      assert len(all_versions) == 4      assert \"1.1\" in all_versions and \"1.1\" not in production_version        # Test delete a non-existed production version      with pytest.raises(SystemExit) as e:          with patch(\"sys.argv\", [\"prog\", \"manage-versions\", \"--delete-production\", \"non_exist_version\"]):              _VersionCLI.parse_arguments()        assert str(e.value) == \"Version 'non_exist_version' is not a production version.\"      def test_list_versions(capsys):      with patch(\"sys.argv\", [\"prog\", \"--development\"]):          core = Core()          core.run()          core.stop()      sleep(0.05)      with patch(\"sys.argv\", [\"prog\", \"--experiment\", \"1.0\"]):          core = Core()          core.run()          core.stop()      sleep(0.05)      with patch(\"sys.argv\", [\"prog\", \"--experiment\", \"1.1\"]):          core = Core()          core.run()          core.stop()      sleep(0.05)      with patch(\"sys.argv\", [\"prog\", \"--production\", \"1.1\"]):          core = Core()          core.run()          core.stop()      sleep(0.05)      with patch(\"sys.argv\", [\"prog\", \"--experiment\", \"2.0\"]):          core = Core()          core.run()          core.stop()      sleep(0.05)      with patch(\"sys.argv\", [\"prog\", \"--experiment\", \"2.1\"]):          core = Core()          core.run()          core.stop()      sleep(0.05)      with patch(\"sys.argv\", [\"prog\", \"--production\", \"2.1\"]):          core = Core()          core.run()          core.stop()        _VersionCLI.create_parser()      with pytest.raises(SystemExit):          with patch(\"sys.argv\", [\"prog\", \"manage-versions\", \"--list\"]):              _VersionCLI.parse_arguments()        out, _ = capsys.readouterr()      version_list = str(out).strip().split(\"\\n\")      assert len(version_list) == 6  # 5 versions with the header      assert all(column in version_list[0] for column in [\"Version number\", \"Mode\", \"Creation date\"])      assert all(column in version_list[1] for column in [\"2.1\", \"Production\", \"latest\"])      assert all(column in version_list[2] for column in [\"2.0\", \"Experiment\"]) and \"latest\" not in version_list[2]      assert all(column in version_list[3] for column in [\"1.1\", \"Production\"]) and \"latest\" not in version_list[3]      assert all(column in version_list[4] for column in [\"1.0\", \"Experiment\"]) and \"latest\" not in version_list[4]      assert \"Development\" in version_list[5] and \"latest\" not in version_list[5]      def test_rename_version(caplog):      scenario_config = config_scenario()        with patch(\"sys.argv\", [\"prog\", \"--experiment\", \"1.0\"]):          core = Core()          core.run()          scenario = _ScenarioManager._create(scenario_config)          _ScenarioManager._submit(scenario)          core.stop()        with patch(\"sys.argv\", [\"prog\", \"--production\", \"2.0\"]):          core = Core()          core.run()          scenario = _ScenarioManager._create(scenario_config)          _ScenarioManager._submit(scenario)          core.stop()        dev_ver = _VersionManager._get_development_version()        _VersionCLI.create_parser()      with pytest.raises(SystemExit):          with patch(\"sys.argv\", [\"prog\", \"manage-versions\", \"--rename\", \"non_exist_version\", \"1.1\"]):              # This should raise an exception since version \"non_exist_version\" does not exist              _VersionCLI.parse_arguments()      assert \"Version 'non_exist_version' does not exist.\" in caplog.text        _VersionCLI.create_parser()      with pytest.raises(SystemExit):          with patch(\"sys.argv\", [\"prog\", \"manage-versions\", \"--rename\", \"1.0\", \"2.0\"]):              # This should raise an exception since 2.0 already exists              _VersionCLI.parse_arguments()      assert \"Version name '2.0' is already used.\" in caplog.text        _VersionCLI.create_parser()      with pytest.raises(SystemExit):          with patch(\"sys.argv\", [\"prog\", \"manage-versions\", \"--rename\", \"1.0\", \"1.1\"]):              _VersionCLI.parse_arguments()      assert _VersionManager._get(\"1.0\") is None      assert [version.id for version in _VersionManager._get_all()].sort() == [dev_ver, \"1.1\", \"2.0\"].sort()      # All entities are assigned to the new version      assert len(_DataManager._get_all(\"1.1\")) == 2      assert len(_TaskManager._get_all(\"1.1\")) == 1      assert len(_SequenceManager._get_all(\"1.1\")) == 1      assert len(_ScenarioManager._get_all(\"1.1\")) == 1      assert len(_JobManager._get_all(\"1.1\")) == 1        _VersionCLI.create_parser()      with pytest.raises(SystemExit):          with patch(\"sys.argv\", [\"prog\", \"manage-versions\", \"--rename\", \"2.0\", \"2.1\"]):              _VersionCLI.parse_arguments()      assert _VersionManager._get(\"2.0\") is None      assert [version.id for version in _VersionManager._get_all()].sort() == [dev_ver, \"1.1\", \"2.1\"].sort()      assert _VersionManager._get_production_versions() == [\"2.1\"]      # All entities are assigned to the new version      assert len(_DataManager._get_all(\"2.1\")) == 2      assert len(_TaskManager._get_all(\"2.1\")) == 1      assert len(_SequenceManager._get_all(\"2.1\")) == 1      assert len(_ScenarioManager._get_all(\"2.1\")) == 1      assert len(_JobManager._get_all(\"2.1\")) == 1      def test_compare_version_config(caplog):      scenario_config_1 = config_scenario()        with patch(\"sys.argv\", [\"prog\", \"--experiment\", \"1.0\"]):          core = Core()          core.run()          scenario = _ScenarioManager._create(scenario_config_1)          _ScenarioManager._submit(scenario)          core.stop()        init_config()        scenario_config_2 = config_scenario()      Config.configure_data_node(id=\"d2\", storage_type=\"csv\", default_path=\"bar.csv\")        with patch(\"sys.argv\", [\"prog\", \"--experiment\", \"2.0\"]):          core = Core()          core.run()          scenario = _ScenarioManager._create(scenario_config_2)          _ScenarioManager._submit(scenario)          core.stop()        _VersionCLI.create_parser()      with pytest.raises(SystemExit):          with patch(\"sys.argv\", [\"prog\", \"manage-versions\", \"--compare-config\", \"non_exist_version\", \"2.0\"]):              # This should raise an exception since version \"non_exist_version\" does not exist              _VersionCLI.parse_arguments()      assert \"Version 'non_exist_version' does not exist.\" in caplog.text        with pytest.raises(SystemExit):          with patch(\"sys.argv\", [\"prog\", \"manage-versions\", \"--compare-config\", \"1.0\", \"non_exist_version\"]):              # This should raise an exception since 2.0 already exists              _VersionCLI.parse_arguments()      assert \"Version 'non_exist_version' does not exist.\" in caplog.text        with pytest.raises(SystemExit):          with patch(\"sys.argv\", [\"prog\", \"manage-versions\", \"--compare-config\", \"1.0\", \"1.0\"]):              _VersionCLI.parse_arguments()      assert \"There is no difference between version 1.0 Configuration and version 1.0 Configuration.\" in caplog.text        with pytest.raises(SystemExit):          with patch(\"sys.argv\", [\"prog\", \"manage-versions\", \"--compare-config\", \"1.0\", \"2.0\"]):              _VersionCLI.parse_arguments()      expected_message = \"\"\"Differences between version 1.0 Configuration and version 2.0 Configuration:  \\tDATA_NODE \"d2\" has attribute \"default_path\" modified: foo.csv -> bar.csv\"\"\"      assert expected_message in caplog.text      def twice(a):      return a * 2      def config_scenario():      data_node_1_config = Config.configure_data_node(          id=\"d1\", storage_type=\"pickle\", default_data=\"abc\", scope=Scope.SCENARIO      )      data_node_2_config = Config.configure_data_node(id=\"d2\", storage_type=\"csv\", default_path=\"foo.csv\")      task_config = Config.configure_task(\"my_task\", twice, data_node_1_config, data_node_2_config)      scenario_config = Config.configure_scenario(\"my_scenario\", [task_config], frequency=Frequency.DAILY)      scenario_config.add_sequences({\"my_sequence\": [task_config]})        return scenario_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": "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": "from time import sleep  from unittest.mock import patch    import pytest    from src.taipy.core import Core  from src.taipy.core._version._cli._version_cli import _VersionCLI  from src.taipy.core._version._version_manager import _VersionManager  from src.taipy.core.data._data_manager import _DataManager  from src.taipy.core.job._job_manager import _JobManager  from src.taipy.core.scenario._scenario_manager import _ScenarioManager  from src.taipy.core.scenario._scenario_manager_factory import _ScenarioManagerFactory  from src.taipy.core.sequence._sequence_manager import _SequenceManager  from src.taipy.core.task._task_manager import _TaskManager  from taipy.config.common.frequency import Frequency  from taipy.config.common.scope import Scope  from taipy.config.config import Config    from ...conftest import init_config      def test_delete_version(caplog, init_sql_repo):      _ScenarioManagerFactory._build_manager()        scenario_config = config_scenario()        with patch(\"sys.argv\", [\"prog\", \"--development\"]):          core = Core()          core.run()          scenario = _ScenarioManager._create(scenario_config)          _ScenarioManager._submit(scenario)          core.stop()        with patch(\"sys.argv\", [\"prog\", \"--experiment\", \"1.0\"]):          core = Core()          core.run()          scenario = _ScenarioManager._create(scenario_config)          _ScenarioManager._submit(scenario)          core.stop()        with patch(\"sys.argv\", [\"prog\", \"--experiment\", \"1.1\"]):          core = Core()          core.run()          scenario = _ScenarioManager._create(scenario_config)          _ScenarioManager._submit(scenario)          core.stop()        with patch(\"sys.argv\", [\"prog\", \"--production\", \"1.1\"]):          core = Core()          core.run()          core.stop()        with patch(\"sys.argv\", [\"prog\", \"--experiment\", \"2.0\"]):          core = Core()          core.run()          scenario = _ScenarioManager._create(scenario_config)          _ScenarioManager._submit(scenario)          core.stop()        with patch(\"sys.argv\", [\"prog\", \"--experiment\", \"2.1\"]):          core = Core()          core.run()          scenario = _ScenarioManager._create(scenario_config)          _ScenarioManager._submit(scenario)          core.stop()        with patch(\"sys.argv\", [\"prog\", \"--production\", \"2.1\"]):          core = Core()          core.run()          core.stop()        all_versions = [version.id for version in _VersionManager._get_all()]      production_version = _VersionManager._get_production_versions()      assert len(all_versions) == 5      assert len(production_version) == 2      assert \"1.0\" in all_versions      assert \"1.1\" in all_versions and \"1.1\" in production_version      assert \"2.0\" in all_versions      assert \"2.1\" in all_versions and \"2.1\" in production_version        _VersionCLI.create_parser()      with pytest.raises(SystemExit):          with patch(\"sys.argv\", [\"prog\", \"manage-versions\", \"--delete\", \"1.0\"]):              _VersionCLI.parse_arguments()        assert \"Successfully delete version 1.0.\" in caplog.text      all_versions = [version.id for version in _VersionManager._get_all()]      assert len(all_versions) == 4      assert \"1.0\" not in all_versions        # Test delete a non-existed version      with pytest.raises(SystemExit):          with patch(\"sys.argv\", [\"prog\", \"manage-versions\", \"--delete\", \"non_exist_version\"]):              _VersionCLI.parse_arguments()      assert \"Version 'non_exist_version' does not exist.\" in caplog.text        # Test delete production version will change the version from production to experiment      with pytest.raises(SystemExit):          with patch(\"sys.argv\", [\"prog\", \"manage-versions\", \"--delete-production\", \"1.1\"]):              _VersionCLI.parse_arguments()        assert \"Successfully delete version 1.1 from the production version list.\" in caplog.text      all_versions = [version.id for version in _VersionManager._get_all()]      production_version = _VersionManager._get_production_versions()      assert len(all_versions) == 4      assert \"1.1\" in all_versions and \"1.1\" not in production_version        # Test delete a non-existed production version      with pytest.raises(SystemExit) as e:          with patch(\"sys.argv\", [\"prog\", \"manage-versions\", \"--delete-production\", \"non_exist_version\"]):              _VersionCLI.parse_arguments()        assert str(e.value) == \"Version 'non_exist_version' is not a production version.\"      def test_list_versions(capsys, init_sql_repo):      _ScenarioManagerFactory._build_manager()        with patch(\"sys.argv\", [\"prog\", \"--development\"]):          core = Core()          core.run()          core.stop()      sleep(0.05)      with patch(\"sys.argv\", [\"prog\", \"--experiment\", \"1.0\"]):          core = Core()          core.run()          core.stop()      sleep(0.05)      with patch(\"sys.argv\", [\"prog\", \"--experiment\", \"1.1\"]):          core = Core()          core.run()          core.stop()      sleep(0.05)      with patch(\"sys.argv\", [\"prog\", \"--production\", \"1.1\"]):          core = Core()          core.run()          core.stop()      sleep(0.05)      with patch(\"sys.argv\", [\"prog\", \"--experiment\", \"2.0\"]):          core = Core()          core.run()          core.stop()      sleep(0.05)      with patch(\"sys.argv\", [\"prog\", \"--experiment\", \"2.1\"]):          core = Core()          core.run()          core.stop()      sleep(0.05)      with patch(\"sys.argv\", [\"prog\", \"--production\", \"2.1\"]):          core = Core()          core.run()          core.stop()        _VersionCLI.create_parser()      with pytest.raises(SystemExit):          with patch(\"sys.argv\", [\"prog\", \"manage-versions\", \"--list\"]):              _VersionCLI.parse_arguments()        out, _ = capsys.readouterr()      version_list = str(out).strip().split(\"\\n\")      assert len(version_list) == 6  # 5 versions with the header      assert all(column in version_list[0] for column in [\"Version number\", \"Mode\", \"Creation date\"])      assert all(column in version_list[1] for column in [\"2.1\", \"Production\", \"latest\"])      assert all(column in version_list[2] for column in [\"2.0\", \"Experiment\"]) and \"latest\" not in version_list[2]      assert all(column in version_list[3] for column in [\"1.1\", \"Production\"]) and \"latest\" not in version_list[3]      assert all(column in version_list[4] for column in [\"1.0\", \"Experiment\"]) and \"latest\" not in version_list[4]      assert \"Development\" in version_list[5] and \"latest\" not in version_list[5]      def test_rename_version(caplog, init_sql_repo):      _ScenarioManagerFactory._build_manager()        scenario_config = config_scenario()        with patch(\"sys.argv\", [\"prog\", \"--experiment\", \"1.0\"]):          core = Core()          core.run()          scenario = _ScenarioManager._create(scenario_config)          _ScenarioManager._submit(scenario)          core.stop()        with patch(\"sys.argv\", [\"prog\", \"--production\", \"2.0\"]):          core = Core()          core.run()          scenario = _ScenarioManager._create(scenario_config)          _ScenarioManager._submit(scenario)          core.stop()        dev_ver = _VersionManager._get_development_version()        _VersionCLI.create_parser()      with pytest.raises(SystemExit):          with patch(\"sys.argv\", [\"prog\", \"manage-versions\", \"--rename\", \"non_exist_version\", \"1.1\"]):              # This should raise an exception since version \"non_exist_version\" does not exist              _VersionCLI.parse_arguments()      assert \"Version 'non_exist_version' does not exist.\" in caplog.text        _VersionCLI.create_parser()      with pytest.raises(SystemExit):          with patch(\"sys.argv\", [\"prog\", \"manage-versions\", \"--rename\", \"1.0\", \"2.0\"]):              # This should raise an exception since 2.0 already exists              _VersionCLI.parse_arguments()      assert \"Version name '2.0' is already used.\" in caplog.text        _VersionCLI.create_parser()      with pytest.raises(SystemExit):          with patch(\"sys.argv\", [\"prog\", \"manage-versions\", \"--rename\", \"1.0\", \"1.1\"]):              _VersionCLI.parse_arguments()      assert _VersionManager._get(\"1.0\") is None      assert [version.id for version in _VersionManager._get_all()].sort() == [dev_ver, \"1.1\", \"2.0\"].sort()      # All entities are assigned to the new version      assert len(_DataManager._get_all(\"1.1\")) == 2      assert len(_TaskManager._get_all(\"1.1\")) == 1      assert len(_SequenceManager._get_all(\"1.1\")) == 0      assert len(_ScenarioManager._get_all(\"1.1\")) == 1      assert len(_JobManager._get_all(\"1.1\")) == 1        _VersionCLI.create_parser()      with pytest.raises(SystemExit):          with patch(\"sys.argv\", [\"prog\", \"manage-versions\", \"--rename\", \"2.0\", \"2.1\"]):              _VersionCLI.parse_arguments()      assert _VersionManager._get(\"2.0\") is None      assert [version.id for version in _VersionManager._get_all()].sort() == [dev_ver, \"1.1\", \"2.1\"].sort()      assert _VersionManager._get_production_versions() == [\"2.1\"]      # All entities are assigned to the new version      assert len(_DataManager._get_all(\"2.1\")) == 2      assert len(_TaskManager._get_all(\"2.1\")) == 1      assert len(_SequenceManager._get_all(\"2.1\")) == 0      assert len(_ScenarioManager._get_all(\"2.1\")) == 1      assert len(_JobManager._get_all(\"2.1\")) == 1      def test_compare_version_config(caplog, init_sql_repo):      _ScenarioManagerFactory._build_manager()        scenario_config_1 = config_scenario()        with patch(\"sys.argv\", [\"prog\", \"--experiment\", \"1.0\"]):          core = Core()          core.run()          scenario = _ScenarioManager._create(scenario_config_1)          _ScenarioManager._submit(scenario)          core.stop()        init_config()      Config.configure_core(repository_type=\"sql\", repository_properties={\"db_location\": init_sql_repo})      _ScenarioManagerFactory._build_manager()        scenario_config_2 = config_scenario()      Config.configure_data_node(id=\"d2\", storage_type=\"csv\", default_path=\"bar.csv\")        with patch(\"sys.argv\", [\"prog\", \"--experiment\", \"2.0\"]):          core = Core()          core.run()          scenario = _ScenarioManager._create(scenario_config_2)          _ScenarioManager._submit(scenario)          core.stop()        _VersionCLI.create_parser()      with pytest.raises(SystemExit):          with patch(\"sys.argv\", [\"prog\", \"manage-versions\", \"--compare-config\", \"non_exist_version\", \"2.0\"]):              # This should raise an exception since version \"non_exist_version\" does not exist              _VersionCLI.parse_arguments()      assert \"Version 'non_exist_version' does not exist.\" in caplog.text        with pytest.raises(SystemExit):          with patch(\"sys.argv\", [\"prog\", \"manage-versions\", \"--compare-config\", \"1.0\", \"non_exist_version\"]):              # This should raise an exception since 2.0 already exists              _VersionCLI.parse_arguments()      assert \"Version 'non_exist_version' does not exist.\" in caplog.text        with pytest.raises(SystemExit):          with patch(\"sys.argv\", [\"prog\", \"manage-versions\", \"--compare-config\", \"1.0\", \"1.0\"]):              _VersionCLI.parse_arguments()      assert \"There is no difference between version 1.0 Configuration and version 1.0 Configuration.\" in caplog.text        with pytest.raises(SystemExit):          with patch(\"sys.argv\", [\"prog\", \"manage-versions\", \"--compare-config\", \"1.0\", \"2.0\"]):              _VersionCLI.parse_arguments()      expected_message = \"\"\"Differences between version 1.0 Configuration and version 2.0 Configuration:  \\tDATA_NODE \"d2\" has attribute \"default_path\" modified: foo.csv -> bar.csv\"\"\"      assert expected_message in caplog.text      def twice(a):      return a * 2      def config_scenario():      data_node_1_config = Config.configure_data_node(          id=\"d1\", storage_type=\"pickle\", default_data=\"abc\", scope=Scope.SCENARIO      )      data_node_2_config = Config.configure_data_node(id=\"d2\", storage_type=\"csv\", default_path=\"foo.csv\")      task_config = Config.configure_task(\"my_task\", twice, data_node_1_config, data_node_2_config)      scenario_config = Config.configure_scenario(\"my_scenario\", [task_config], frequency=Frequency.DAILY)        return scenario_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": "import multiprocessing  import random  import string  from concurrent.futures import ProcessPoolExecutor  from datetime import datetime, timedelta  from functools import partial  from time import sleep    import pytest    from src.taipy.core import taipy  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.data._data_manager import _DataManager  from src.taipy.core.data.in_memory import InMemoryDataNode  from src.taipy.core.scenario._scenario_manager import _ScenarioManager  from src.taipy.core.scenario.scenario import Scenario  from src.taipy.core.sequence._sequence_manager import _SequenceManager  from src.taipy.core.sequence.sequence import Sequence  from src.taipy.core.task._task_manager import _TaskManager  from src.taipy.core.task.task import Task  from taipy.config import Config  from taipy.config.common.scope import Scope  from taipy.config.exceptions.exceptions import ConfigurationUpdateBlocked  from tests.core.utils import assert_true_after_time    # ################################  USER FUNCTIONS  ##################################      def multiply(nb1: float, nb2: float):      sleep(0.1)      return nb1 * nb2      def lock_multiply(lock, nb1: float, nb2: float):      with lock:          return multiply(nb1, nb2)      def mult_by_2(n):      return n * 2      def nothing():      return True      def concat(a, b):      return a + b      def _error():      raise Exception      # ################################  TEST METHODS    ##################################      def test_submit_task():      Config.configure_job_executions(mode=JobConfig._DEVELOPMENT_MODE)        before_creation = datetime.now()      sleep(0.1)      task = _create_task(multiply)      output_dn_id = task.output[f\"{task.config_id}_output0\"].id        _OrchestratorFactory._build_dispatcher()        assert _DataManager._get(output_dn_id).last_edit_date > before_creation      assert _DataManager._get(output_dn_id).job_ids == []      assert _DataManager._get(output_dn_id).is_ready_for_reading        before_submission_creation = datetime.now()      sleep(0.1)      job = _Orchestrator.submit_task(task)      sleep(0.1)      after_submission_creation = datetime.now()      assert _DataManager._get(output_dn_id).read() == 42      assert _DataManager._get(output_dn_id).last_edit_date > before_submission_creation      assert _DataManager._get(output_dn_id).last_edit_date < after_submission_creation      assert _DataManager._get(output_dn_id).job_ids == [job.id]      assert _DataManager._get(output_dn_id).is_ready_for_reading      assert job.is_completed()      def test_submit_sequence_generate_unique_submit_id():        dn_1 = InMemoryDataNode(\"dn_config_id_1\", Scope.SCENARIO)      dn_2 = InMemoryDataNode(\"dn_config_id_2\", Scope.SCENARIO)      task_1 = Task(\"task_config_id_1\", {}, print, [dn_1])      task_2 = Task(\"task_config_id_2\", {}, print, [dn_1], [dn_2])        _DataManager._set(dn_1)      _DataManager._set(dn_2)      _TaskManager._set(task_1)      _TaskManager._set(task_2)        scenario = Scenario(\"scenario\", [task_1, task_2], {}, sequences={\"sequence\": {\"tasks\": [task_1, task_2]}})      _ScenarioManager._set(scenario)        sequence = scenario.sequences[\"sequence\"]        jobs_1 = taipy.submit(sequence)      jobs_2 = taipy.submit(sequence)      assert len(jobs_1) == 2      assert len(jobs_2) == 2      submit_ids_1 = [job.submit_id for job in jobs_1]      submit_ids_2 = [job.submit_id for job in jobs_2]      assert len(set(submit_ids_1)) == 1      assert len(set(submit_ids_2)) == 1      assert set(submit_ids_1) != set(submit_ids_2)      def test_submit_scenario_generate_unique_submit_id():      dn_1 = InMemoryDataNode(\"dn_config_id_1\", Scope.SCENARIO)      dn_2 = InMemoryDataNode(\"dn_config_id_2\", Scope.SCENARIO)      dn_3 = InMemoryDataNode(\"dn_config_id_3\", Scope.SCENARIO)      task_1 = Task(\"task_config_id_1\", {}, print, [dn_1])      task_2 = Task(\"task_config_id_2\", {}, print, [dn_2])      task_3 = Task(\"task_config_id_3\", {}, print, [dn_3])      scenario = Scenario(\"scenario_config_id\", [task_1, task_2, task_3], {})        _DataManager._set(dn_1)      _DataManager._set(dn_2)      _TaskManager._set(task_1)      _TaskManager._set(task_2)      _TaskManager._set(task_3)      _ScenarioManager._set(scenario)        jobs_1 = taipy.submit(scenario)      jobs_2 = taipy.submit(scenario)        assert len(jobs_1) == 3      assert len(jobs_2) == 3      def test_submit_entity_store_entity_id_in_job():      dn_1 = InMemoryDataNode(\"dn_config_id_1\", Scope.SCENARIO)      dn_2 = InMemoryDataNode(\"dn_config_id_2\", Scope.SCENARIO)      dn_3 = InMemoryDataNode(\"dn_config_id_3\", Scope.SCENARIO)      task_1 = Task(\"task_config_id_1\", {}, print, [dn_1])      task_2 = Task(\"task_config_id_2\", {}, print, [dn_2])      task_3 = Task(\"task_config_id_3\", {}, print, [dn_3])      scenario = Scenario(\"scenario_config_id\", [task_1, task_2, task_3], {})        _DataManager._set(dn_1)      _DataManager._set(dn_2)      _TaskManager._set(task_1)      _TaskManager._set(task_2)      _TaskManager._set(task_3)      _ScenarioManager._set(scenario)        jobs_1 = taipy.submit(scenario)      assert all(job.submit_entity_id == scenario.id for job in jobs_1)        job_1 = taipy.submit(task_1)      assert job_1.submit_entity_id == task_1.id      def test_submit_task_that_return_multiple_outputs():      Config.configure_job_executions(mode=JobConfig._DEVELOPMENT_MODE)        def return_2tuple(nb1, nb2):          return multiply(nb1, nb2), multiply(nb1, nb2) / 2        def return_list(nb1, nb2):          return [multiply(nb1, nb2), multiply(nb1, nb2) / 2]        with_tuple = _create_task(return_2tuple, 2)      with_list = _create_task(return_list, 2)        _OrchestratorFactory._build_dispatcher()        _Orchestrator.submit_task(with_tuple)      _Orchestrator.submit_task(with_list)        assert (          with_tuple.output[f\"{with_tuple.config_id}_output0\"].read()          == with_list.output[f\"{with_list.config_id}_output0\"].read()          == 42      )      assert (          with_tuple.output[f\"{with_tuple.config_id}_output1\"].read()          == with_list.output[f\"{with_list.config_id}_output1\"].read()          == 21      )      def test_submit_task_returns_single_iterable_output():      Config.configure_job_executions(mode=JobConfig._DEVELOPMENT_MODE)        def return_2tuple(nb1, nb2):          return multiply(nb1, nb2), multiply(nb1, nb2) / 2        def return_list(nb1, nb2):          return [multiply(nb1, nb2), multiply(nb1, nb2) / 2]        task_with_tuple = _create_task(return_2tuple, 1)      task_with_list = _create_task(return_list, 1)        _OrchestratorFactory._build_dispatcher()        _Orchestrator.submit_task(task_with_tuple)      assert task_with_tuple.output[f\"{task_with_tuple.config_id}_output0\"].read() == (42, 21)      assert len(_OrchestratorFactory._dispatcher._dispatched_processes) == 0      _Orchestrator.submit_task(task_with_list)      assert task_with_list.output[f\"{task_with_list.config_id}_output0\"].read() == [42, 21]      assert len(_OrchestratorFactory._dispatcher._dispatched_processes) == 0      def test_data_node_not_written_due_to_wrong_result_nb():      Config.configure_job_executions(mode=JobConfig._DEVELOPMENT_MODE)        def return_2tuple():          return lambda nb1, nb2: (multiply(nb1, nb2), multiply(nb1, nb2) / 2)        task = _create_task(return_2tuple(), 3)        _OrchestratorFactory._build_dispatcher()        job = _Orchestrator.submit_task(task)      assert task.output[f\"{task.config_id}_output0\"].read() == 0      assert job.is_failed()      assert len(_OrchestratorFactory._dispatcher._dispatched_processes) == 0      def test_scenario_only_submit_same_task_once():        Config.configure_job_executions(mode=JobConfig._DEVELOPMENT_MODE)      _OrchestratorFactory._build_dispatcher()        dn_0 = InMemoryDataNode(\"dn_config_0\", Scope.SCENARIO, properties={\"default_data\": 0})      dn_1 = InMemoryDataNode(\"dn_config_1\", Scope.SCENARIO, properties={\"default_data\": 1})      dn_2 = InMemoryDataNode(\"dn_config_2\", Scope.SCENARIO, properties={\"default_data\": 2})      task_1 = Task(\"task_config_1\", {}, print, input=[dn_0], output=[dn_1], id=\"task_1\")      task_2 = Task(\"task_config_2\", {}, print, input=[dn_1], id=\"task_2\")      task_3 = Task(\"task_config_3\", {}, print, input=[dn_1], output=[dn_2], id=\"task_3\")      scenario_1 = Scenario(          \"scenario_config_1\",          [task_1, task_2, task_3],          {},          \"scenario_1\",          sequences={\"sequence_1\": {\"tasks\": [task_1, task_2]}, \"sequence_2\": {\"tasks\": [task_1, task_3]}},      )      sequence_1 = scenario_1.sequences[\"sequence_1\"]      sequence_2 = scenario_1.sequences[\"sequence_2\"]        jobs = _Orchestrator.submit(scenario_1)      assert len(jobs) == 3      assert all([job.is_completed() for job in jobs])      assert all(not _Orchestrator._is_blocked(job) for job in jobs)        jobs = _Orchestrator.submit(sequence_1)      assert len(jobs) == 2      assert all([job.is_completed() for job in jobs])      assert all(not _Orchestrator._is_blocked(job) for job in jobs)        jobs = _Orchestrator.submit(sequence_2)      assert len(jobs) == 2      assert all([job.is_completed() for job in jobs])      assert all(not _Orchestrator._is_blocked(job) for job in jobs)      def test_update_status_fail_job():      Config.configure_job_executions(mode=JobConfig._DEVELOPMENT_MODE)      _OrchestratorFactory._build_dispatcher()        dn_0 = InMemoryDataNode(\"dn_config_0\", Scope.SCENARIO, properties={\"default_data\": 0})      dn_1 = InMemoryDataNode(\"dn_config_1\", Scope.SCENARIO, properties={\"default_data\": 1})      dn_2 = InMemoryDataNode(\"dn_config_2\", Scope.SCENARIO, properties={\"default_data\": 2})      task_0 = Task(\"task_config_0\", {}, _error, output=[dn_0], id=\"task_0\")      task_1 = Task(\"task_config_1\", {}, print, input=[dn_0], output=[dn_1], id=\"task_1\")      task_2 = Task(\"task_config_2\", {}, print, input=[dn_1], id=\"task_2\")      task_3 = Task(\"task_config_3\", {}, print, input=[dn_2], id=\"task_3\")      scenario_1 = Scenario(\"scenario_config_1\", [task_0, task_1, task_2, task_3], {}, \"scenario_1\")      scenario_2 = Scenario(\"scenario_config_2\", [task_0, task_1, task_2, task_3], {}, \"scenario_2\")        _DataManager._set(dn_0)      _DataManager._set(dn_1)      _DataManager._set(dn_2)      _TaskManager._set(task_0)      _TaskManager._set(task_1)      _TaskManager._set(task_2)      _TaskManager._set(task_3)      _ScenarioManager._set(scenario_1)      _ScenarioManager._set(scenario_2)        job = _Orchestrator.submit_task(task_0)      assert job.is_failed()        jobs = _Orchestrator.submit(scenario_1)      tasks_jobs = {job._task.id: job for job in jobs}      assert tasks_jobs[\"task_0\"].is_failed()      assert all([job.is_abandoned() for job in [tasks_jobs[\"task_1\"], tasks_jobs[\"task_2\"]]])      assert tasks_jobs[\"task_3\"].is_completed()      assert all(not _Orchestrator._is_blocked(job) for job in jobs)        jobs = _Orchestrator.submit(scenario_2)      tasks_jobs = {job._task.id: job for job in jobs}      assert tasks_jobs[\"task_0\"].is_failed()      assert all([job.is_abandoned() for job in [tasks_jobs[\"task_1\"], tasks_jobs[\"task_2\"]]])      assert tasks_jobs[\"task_3\"].is_completed()      assert all(not _Orchestrator._is_blocked(job) for job in jobs)      def test_update_status_fail_job_in_parallel():      Config.configure_job_executions(mode=JobConfig._STANDALONE_MODE, max_nb_of_workers=2)      _OrchestratorFactory._build_dispatcher()        dn_0 = InMemoryDataNode(\"dn_config_0\", Scope.SCENARIO, properties={\"default_data\": 0})      dn_1 = InMemoryDataNode(\"dn_config_1\", Scope.SCENARIO, properties={\"default_data\": 1})      dn_2 = InMemoryDataNode(\"dn_config_2\", Scope.SCENARIO, properties={\"default_data\": 2})      task_0 = Task(\"task_config_0\", {}, _error, output=[dn_0], id=\"task_0\")      task_1 = Task(\"task_config_1\", {}, print, input=[dn_0], output=[dn_1], id=\"task_1\")      task_2 = Task(\"task_config_2\", {}, print, input=[dn_1], id=\"task_2\")      task_3 = Task(\"task_config_3\", {}, print, input=[dn_2], id=\"task_3\")      scenario_1 = Scenario(          \"scenario_config_1\",          set([task_0, task_1, task_2, task_3]),          {},          set(),          \"scenario_1\",          sequences={\"sequence_1\": {\"tasks\": [task_0, task_1, task_2]}},      )      scenario_2 = Scenario(          \"scenario_config_2\",          set([task_0, task_1, task_2, task_3]),          {},          set(),          \"scenario_2\",      )        _DataManager._set(dn_0)      _DataManager._set(dn_1)      _DataManager._set(dn_2)      _TaskManager._set(task_0)      _TaskManager._set(task_1)      _TaskManager._set(task_2)      _TaskManager._set(task_3)      _ScenarioManager._set(scenario_1)      _ScenarioManager._set(scenario_2)        sequence_1 = scenario_1.sequences[\"sequence_1\"]        job = _Orchestrator.submit_task(task_0)      assert_true_after_time(job.is_failed)        jobs = _Orchestrator.submit(sequence_1)      tasks_jobs = {job._task.id: job for job in jobs}      assert_true_after_time(tasks_jobs[\"task_0\"].is_failed)      assert_true_after_time(lambda: all([job.is_abandoned() for job in [tasks_jobs[\"task_1\"], tasks_jobs[\"task_2\"]]]))      assert_true_after_time(lambda: all(not _Orchestrator._is_blocked(job) for job in jobs))        jobs = _Orchestrator.submit(scenario_1.sequences[\"sequence_1\"])      tasks_jobs = {job._task.id: job for job in jobs}      assert_true_after_time(tasks_jobs[\"task_0\"].is_failed)      assert_true_after_time(lambda: all([job.is_abandoned() for job in [tasks_jobs[\"task_1\"], tasks_jobs[\"task_2\"]]]))      assert_true_after_time(lambda: all(not _Orchestrator._is_blocked(job) for job in jobs))        jobs = _Orchestrator.submit(scenario_1)      tasks_jobs = {job._task.id: job for job in jobs}      assert_true_after_time(tasks_jobs[\"task_0\"].is_failed)      assert_true_after_time(tasks_jobs[\"task_3\"].is_completed)      assert_true_after_time(lambda: all([job.is_abandoned() for job in [tasks_jobs[\"task_1\"], tasks_jobs[\"task_2\"]]]))      assert_true_after_time(lambda: all(not _Orchestrator._is_blocked(job) for job in jobs))        jobs = _Orchestrator.submit(scenario_2)      tasks_jobs = {job._task.id: job for job in jobs}      assert_true_after_time(tasks_jobs[\"task_0\"].is_failed)      assert_true_after_time(tasks_jobs[\"task_3\"].is_completed)      assert_true_after_time(lambda: all([job.is_abandoned() for job in [tasks_jobs[\"task_1\"], tasks_jobs[\"task_2\"]]]))      assert_true_after_time(lambda: all(not _Orchestrator._is_blocked(job) for job in jobs))      def test_submit_task_in_parallel():      m = multiprocessing.Manager()      lock = m.Lock()        Config.configure_job_executions(mode=JobConfig._STANDALONE_MODE, max_nb_of_workers=2)        task = _create_task(partial(lock_multiply, lock))        _OrchestratorFactory._build_dispatcher()        with lock:          assert task.output[f\"{task.config_id}_output0\"].read() == 0          job = _Orchestrator.submit_task(task)          assert_true_after_time(job.is_running)          assert_true_after_time(lambda: len(_OrchestratorFactory._dispatcher._dispatched_processes) == 1)        assert_true_after_time(lambda: task.output[f\"{task.config_id}_output0\"].read() == 42)      assert_true_after_time(job.is_completed)      assert len(_OrchestratorFactory._dispatcher._dispatched_processes) == 0      def test_submit_sequence_in_parallel():        m = multiprocessing.Manager()      lock = m.Lock()        Config.configure_job_executions(mode=JobConfig._STANDALONE_MODE, max_nb_of_workers=2)        task = _create_task(partial(lock_multiply, lock))      sequence = Sequence({}, [task], \"sequence_id\")        _OrchestratorFactory._build_dispatcher()        with lock:          assert task.output[f\"{task.config_id}_output0\"].read() == 0          job = _Orchestrator.submit(sequence)[0]          assert_true_after_time(job.is_running)          assert_true_after_time(lambda: len(_OrchestratorFactory._dispatcher._dispatched_processes) == 1)        assert_true_after_time(lambda: task.output[f\"{task.config_id}_output0\"].read() == 42)      assert_true_after_time(job.is_completed)      assert len(_OrchestratorFactory._dispatcher._dispatched_processes) == 0      def test_submit_scenario_in_parallel():      m = multiprocessing.Manager()      lock = m.Lock()        Config.configure_job_executions(mode=JobConfig._STANDALONE_MODE, max_nb_of_workers=2)        task = _create_task(partial(lock_multiply, lock))      scenario = Scenario(\"scenario_config\", [task], {}, [], \"scenario_id\")        _OrchestratorFactory._build_dispatcher()        with lock:          assert task.output[f\"{task.config_id}_output0\"].read() == 0          job = _Orchestrator.submit(scenario)[0]          assert_true_after_time(job.is_running)          assert_true_after_time(lambda: len(_OrchestratorFactory._dispatcher._dispatched_processes) == 1)        assert_true_after_time(lambda: task.output[f\"{task.config_id}_output0\"].read() == 42)      assert_true_after_time(job.is_completed)      assert len(_OrchestratorFactory._dispatcher._dispatched_processes) == 0      def sleep_fct(seconds):      sleep(seconds)      def sleep_and_raise_error_fct(seconds):      sleep(seconds)      raise Exception      def test_submit_task_synchronously_in_parallel():      Config.configure_job_executions(mode=JobConfig._STANDALONE_MODE, max_nb_of_workers=2)      _OrchestratorFactory._build_dispatcher()        sleep_period = 1      start_time = datetime.now()      task = Task(\"sleep_task\", {}, function=partial(sleep, sleep_period))      job = _Orchestrator.submit_task(task, wait=True)      assert (datetime.now() - start_time).seconds >= sleep_period      assert_true_after_time(job.is_completed)      def test_submit_sequence_synchronously_in_parallel():      Config.configure_job_executions(mode=JobConfig._STANDALONE_MODE, max_nb_of_workers=2)      _OrchestratorFactory._build_dispatcher()        sleep_period = 1      start_time = datetime.now()      task = Task(\"sleep_task\", {}, function=partial(sleep, sleep_period))      sequence = Sequence({}, [task], \"sequence_id\")        job = _Orchestrator.submit(sequence, wait=True)[0]      assert (datetime.now() - start_time).seconds >= sleep_period      assert_true_after_time(job.is_completed)      def test_submit_scenario_synchronously_in_parallel():      Config.configure_job_executions(mode=JobConfig._STANDALONE_MODE, max_nb_of_workers=2)      _OrchestratorFactory._build_dispatcher()        sleep_period = 1      start_time = datetime.now()      task = Task(\"sleep_task\", {}, function=partial(sleep, sleep_period))      scenario = Scenario(\"scenario_config\", [task], {})        job = _Orchestrator.submit(scenario, wait=True)[0]      assert (datetime.now() - start_time).seconds >= sleep_period      assert_true_after_time(job.is_completed)      def test_submit_fail_task_synchronously_in_parallel():      Config.configure_job_executions(mode=JobConfig._STANDALONE_MODE, max_nb_of_workers=2)      _OrchestratorFactory._build_dispatcher()        sleep_period = 1.0      start_time = datetime.now()      task = Task(\"sleep_task\", {}, function=partial(sleep_and_raise_error_fct, sleep_period))      job = _Orchestrator.submit_task(task, wait=True)      assert (datetime.now() - start_time).seconds >= sleep_period      assert_true_after_time(job.is_failed)      def test_submit_fail_sequence_synchronously_in_parallel():      Config.configure_job_executions(mode=JobConfig._STANDALONE_MODE, max_nb_of_workers=2)      _OrchestratorFactory._build_dispatcher()        sleep_period = 1.0      start_time = datetime.now()      task = Task(\"sleep_task\", {}, function=partial(sleep_and_raise_error_fct, sleep_period))      sequence = Sequence({}, [task], \"sequence_id\")        job = _Orchestrator.submit(sequence, wait=True)[0]      assert (datetime.now() - start_time).seconds >= sleep_period      assert_true_after_time(job.is_failed)      def test_submit_fail_scenario_synchronously_in_parallel():      Config.configure_job_executions(mode=JobConfig._STANDALONE_MODE, max_nb_of_workers=2)      _OrchestratorFactory._build_dispatcher()        sleep_period = 1.0      start_time = datetime.now()      task = Task(\"sleep_task\", {}, function=partial(sleep_and_raise_error_fct, sleep_period))      scenario = Scenario(\"scenario_config\", [task], {})        job = _Orchestrator.submit(scenario, wait=True)[0]      assert (datetime.now() - start_time).seconds >= sleep_period      assert_true_after_time(job.is_failed)      def test_submit_task_synchronously_in_parallel_with_timeout():      Config.configure_job_executions(mode=JobConfig._STANDALONE_MODE, max_nb_of_workers=2)      _OrchestratorFactory._build_dispatcher()        task_duration = 2      timeout_duration = task_duration - 1      task = Task(\"sleep_task\", {}, function=partial(sleep, task_duration))        start_time = datetime.now()      job = _Orchestrator.submit_task(task, wait=True, timeout=timeout_duration)      end_time = datetime.now()        assert timeout_duration <= (end_time - start_time).seconds      assert_true_after_time(job.is_completed)      def test_submit_task_multithreading_multiple_task():      Config.configure_job_executions(mode=JobConfig._STANDALONE_MODE, max_nb_of_workers=2)        m = multiprocessing.Manager()      lock_1 = m.Lock()      lock_2 = m.Lock()        task_1 = _create_task(partial(lock_multiply, lock_1))      task_2 = _create_task(partial(lock_multiply, lock_2))        _OrchestratorFactory._build_dispatcher()        with lock_1:          with lock_2:              job_1 = _Orchestrator.submit_task(task_1)              job_2 = _Orchestrator.submit_task(task_2)                assert task_1.output[f\"{task_1.config_id}_output0\"].read() == 0              assert task_2.output[f\"{task_2.config_id}_output0\"].read() == 0              assert_true_after_time(job_1.is_running)              assert_true_after_time(job_2.is_running)              assert_true_after_time(lambda: len(_OrchestratorFactory._dispatcher._dispatched_processes) == 2)            assert_true_after_time(lambda: task_2.output[f\"{task_2.config_id}_output0\"].read() == 42)          assert task_1.output[f\"{task_1.config_id}_output0\"].read() == 0          assert_true_after_time(job_2.is_completed)          assert_true_after_time(job_1.is_running)          assert_true_after_time(lambda: len(_OrchestratorFactory._dispatcher._dispatched_processes) == 1)        assert_true_after_time(lambda: task_1.output[f\"{task_1.config_id}_output0\"].read() == 42)      assert_true_after_time(job_1.is_completed)      assert_true_after_time(job_2.is_completed)      assert_true_after_time(lambda: len(_OrchestratorFactory._dispatcher._dispatched_processes) == 0)      def test_submit_sequence_multithreading_multiple_task():      Config.configure_job_executions(mode=JobConfig._STANDALONE_MODE, max_nb_of_workers=2)        m = multiprocessing.Manager()      lock_1 = m.Lock()      lock_2 = m.Lock()        task_1 = _create_task(partial(lock_multiply, lock_1))      task_2 = _create_task(partial(lock_multiply, lock_2))        sequence = Sequence({}, [task_1, task_2], \"sequence_id\")        _OrchestratorFactory._build_dispatcher()        with lock_1:          with lock_2:              tasks_jobs = {job._task.id: job for job in _Orchestrator.submit(sequence)}              job_1 = tasks_jobs[task_1.id]              job_2 = tasks_jobs[task_2.id]                assert task_1.output[f\"{task_1.config_id}_output0\"].read() == 0              assert task_2.output[f\"{task_2.config_id}_output0\"].read() == 0              assert_true_after_time(job_1.is_running)              assert_true_after_time(job_2.is_running)              assert_true_after_time(lambda: len(_OrchestratorFactory._dispatcher._dispatched_processes) == 2)            assert_true_after_time(lambda: task_2.output[f\"{task_2.config_id}_output0\"].read() == 42)          assert task_1.output[f\"{task_1.config_id}_output0\"].read() == 0          assert_true_after_time(job_2.is_completed)          assert_true_after_time(job_1.is_running)          assert_true_after_time(lambda: len(_OrchestratorFactory._dispatcher._dispatched_processes) == 1)        assert_true_after_time(lambda: task_1.output[f\"{task_1.config_id}_output0\"].read() == 42)      assert_true_after_time(job_1.is_completed)      assert_true_after_time(job_2.is_completed)      assert_true_after_time(lambda: len(_OrchestratorFactory._dispatcher._dispatched_processes) == 0)      def test_submit_scenario_multithreading_multiple_task():      Config.configure_job_executions(mode=JobConfig._STANDALONE_MODE, max_nb_of_workers=2)        m = multiprocessing.Manager()      lock_1 = m.Lock()      lock_2 = m.Lock()        task_1 = _create_task(partial(lock_multiply, lock_1))      task_2 = _create_task(partial(lock_multiply, lock_2))        scenario = Scenario(\"scenario_config\", [task_1, task_2], {})        _OrchestratorFactory._build_dispatcher()        with lock_1:          with lock_2:              tasks_jobs = {job._task.id: job for job in _Orchestrator.submit(scenario)}              job_1 = tasks_jobs[task_1.id]              job_2 = tasks_jobs[task_2.id]                assert task_1.output[f\"{task_1.config_id}_output0\"].read() == 0              assert task_2.output[f\"{task_2.config_id}_output0\"].read() == 0              assert_true_after_time(job_1.is_running)              assert_true_after_time(job_2.is_running)              assert_true_after_time(lambda: len(_OrchestratorFactory._dispatcher._dispatched_processes) == 2)            assert_true_after_time(lambda: task_2.output[f\"{task_2.config_id}_output0\"].read() == 42)          assert task_1.output[f\"{task_1.config_id}_output0\"].read() == 0          assert_true_after_time(job_2.is_completed)          assert_true_after_time(job_1.is_running)          assert_true_after_time(lambda: len(_OrchestratorFactory._dispatcher._dispatched_processes) == 1)        assert_true_after_time(lambda: task_1.output[f\"{task_1.config_id}_output0\"].read() == 42)      assert_true_after_time(job_1.is_completed)      assert_true_after_time(job_2.is_completed)      assert_true_after_time(lambda: len(_OrchestratorFactory._dispatcher._dispatched_processes) == 0)      def test_submit_task_multithreading_multiple_task_in_sync_way_to_check_job_status():      Config.configure_job_executions(mode=JobConfig._STANDALONE_MODE, max_nb_of_workers=2)        m = multiprocessing.Manager()      lock_0 = m.Lock()      lock_1 = m.Lock()      lock_2 = m.Lock()        task_0 = _create_task(partial(lock_multiply, lock_0))      task_1 = _create_task(partial(lock_multiply, lock_1))      task_2 = _create_task(partial(lock_multiply, lock_2))        _OrchestratorFactory._build_dispatcher()        with lock_0:          job_0 = _Orchestrator.submit_task(task_0)          assert_true_after_time(job_0.is_running)          assert_true_after_time(lambda: len(_OrchestratorFactory._dispatcher._dispatched_processes) == 1)          with lock_1:              with lock_2:                  assert task_1.output[f\"{task_1.config_id}_output0\"].read() == 0                  assert task_2.output[f\"{task_2.config_id}_output0\"].read() == 0                  job_2 = _Orchestrator.submit_task(task_2)                  job_1 = _Orchestrator.submit_task(task_1)                  assert_true_after_time(job_0.is_running)                  assert_true_after_time(job_1.is_pending)                  assert_true_after_time(job_2.is_running)                  assert_true_after_time(lambda: len(_OrchestratorFactory._dispatcher._dispatched_processes) == 2)                assert_true_after_time(lambda: task_2.output[f\"{task_2.config_id}_output0\"].read() == 42)              assert task_1.output[f\"{task_1.config_id}_output0\"].read() == 0              assert_true_after_time(job_0.is_running)              assert_true_after_time(job_1.is_running)              assert_true_after_time(job_2.is_completed)              assert_true_after_time(lambda: len(_OrchestratorFactory._dispatcher._dispatched_processes) == 2)            assert_true_after_time(lambda: task_1.output[f\"{task_1.config_id}_output0\"].read() == 42)          assert task_0.output[f\"{task_0.config_id}_output0\"].read() == 0          assert_true_after_time(job_0.is_running)          assert_true_after_time(job_1.is_completed)          assert job_2.is_completed()          assert_true_after_time(lambda: len(_OrchestratorFactory._dispatcher._dispatched_processes) == 1)        assert_true_after_time(lambda: len(_OrchestratorFactory._dispatcher._dispatched_processes) == 0)      assert task_0.output[f\"{task_0.config_id}_output0\"].read() == 42      assert job_0.is_completed()      assert job_1.is_completed()      assert job_2.is_completed()      def test_blocked_task():      Config.configure_job_executions(mode=JobConfig._STANDALONE_MODE, max_nb_of_workers=2)        m = multiprocessing.Manager()      lock_1 = m.Lock()      lock_2 = m.Lock()        foo_cfg = Config.configure_data_node(\"foo\", default_data=1)      bar_cfg = Config.configure_data_node(\"bar\")      baz_cfg = Config.configure_data_node(\"baz\")        _OrchestratorFactory._build_dispatcher()        dns = _DataManager._bulk_get_or_create([foo_cfg, bar_cfg, baz_cfg])      foo = dns[foo_cfg]      bar = dns[bar_cfg]      baz = dns[baz_cfg]      task_1 = Task(\"by_2\", {}, partial(lock_multiply, lock_1, 2), [foo], [bar])      task_2 = Task(\"by_3\", {}, partial(lock_multiply, lock_2, 3), [bar], [baz])        assert task_1.foo.is_ready_for_reading  # foo is ready      assert not task_1.bar.is_ready_for_reading  # But bar is not ready      assert not task_2.baz.is_ready_for_reading  # neither does baz        assert len(_Orchestrator.blocked_jobs) == 0      job_2 = _Orchestrator.submit_task(task_2)  # job 2 is submitted first      assert job_2.is_blocked()  # since bar is not is_valid the job 2 is blocked      assert_true_after_time(lambda: len(_OrchestratorFactory._dispatcher._dispatched_processes) == 0)      assert len(_Orchestrator.blocked_jobs) == 1      with lock_2:          with lock_1:              job_1 = _Orchestrator.submit_task(                  task_1,              )  # job 1 is submitted and locked              assert_true_after_time(job_1.is_running)  # so it is still running              assert_true_after_time(lambda: len(_OrchestratorFactory._dispatcher._dispatched_processes) == 1)              assert not _DataManager._get(task_1.bar.id).is_ready_for_reading  # And bar still not ready              assert_true_after_time(job_2.is_blocked)  # the job_2 remains blocked          assert_true_after_time(job_1.is_completed)  # job1 unlocked and can complete          assert _DataManager._get(task_1.bar.id).is_ready_for_reading  # bar becomes ready          assert _DataManager._get(task_1.bar.id).read() == 2  # the data is computed and written          assert_true_after_time(job_2.is_running)  # And job 2 can start running          assert_true_after_time(lambda: len(_OrchestratorFactory._dispatcher._dispatched_processes) == 1)          assert len(_Orchestrator.blocked_jobs) == 0      assert_true_after_time(job_2.is_completed)  # job 2 unlocked so it can complete      assert _DataManager._get(task_2.baz.id).is_ready_for_reading  # baz becomes ready      assert _DataManager._get(task_2.baz.id).read() == 6  # the data is computed and written      assert_true_after_time(lambda: len(_OrchestratorFactory._dispatcher._dispatched_processes) == 0)      def test_blocked_sequence():      Config.configure_job_executions(mode=JobConfig._STANDALONE_MODE, max_nb_of_workers=2)        m = multiprocessing.Manager()      lock_1 = m.Lock()      lock_2 = m.Lock()        foo_cfg = Config.configure_data_node(\"foo\", default_data=1)      bar_cfg = Config.configure_data_node(\"bar\")      baz_cfg = Config.configure_data_node(\"baz\")        _OrchestratorFactory._build_dispatcher()        dns = _DataManager._bulk_get_or_create([foo_cfg, bar_cfg, baz_cfg])      foo = dns[foo_cfg]      bar = dns[bar_cfg]      baz = dns[baz_cfg]      task_1 = Task(\"by_2\", {}, partial(lock_multiply, lock_1, 2), [foo], [bar])      task_2 = Task(\"by_3\", {}, partial(lock_multiply, lock_2, 3), [bar], [baz])      sequence = Sequence({}, [task_1, task_2], \"sequence_id\")        assert task_1.foo.is_ready_for_reading  # foo is ready      assert not task_1.bar.is_ready_for_reading  # But bar is not ready      assert not task_2.baz.is_ready_for_reading  # neither does baz        assert len(_Orchestrator.blocked_jobs) == 0      with lock_2:          with lock_1:              jobs = _Orchestrator.submit(sequence)  # sequence is submitted              tasks_jobs = {job._task.id: job for job in jobs}              job_1, job_2 = tasks_jobs[task_1.id], tasks_jobs[task_2.id]              assert_true_after_time(job_1.is_running)  # job 1 is submitted and locked so it is still running              assert_true_after_time(lambda: len(_OrchestratorFactory._dispatcher._dispatched_processes) == 1)              assert not _DataManager._get(task_1.bar.id).is_ready_for_reading  # And bar still not ready              assert_true_after_time(job_2.is_blocked)  # the job_2 remains blocked          assert_true_after_time(job_1.is_completed)  # job1 unlocked and can complete          assert _DataManager._get(task_1.bar.id).is_ready_for_reading  # bar becomes ready          assert _DataManager._get(task_1.bar.id).read() == 2  # the data is computed and written          assert_true_after_time(job_2.is_running)  # And job 2 can start running          assert_true_after_time(lambda: len(_OrchestratorFactory._dispatcher._dispatched_processes) == 1)          assert len(_Orchestrator.blocked_jobs) == 0      assert_true_after_time(job_2.is_completed)  # job 2 unlocked so it can complete      assert _DataManager._get(task_2.baz.id).is_ready_for_reading  # baz becomes ready      assert _DataManager._get(task_2.baz.id).read() == 6  # the data is computed and written      assert_true_after_time(lambda: len(_OrchestratorFactory._dispatcher._dispatched_processes) == 0)      def test_blocked_scenario():      Config.configure_job_executions(mode=JobConfig._STANDALONE_MODE, max_nb_of_workers=2)        m = multiprocessing.Manager()      lock_1 = m.Lock()      lock_2 = m.Lock()        foo_cfg = Config.configure_data_node(\"foo\", default_data=1)      bar_cfg = Config.configure_data_node(\"bar\")      baz_cfg = Config.configure_data_node(\"baz\")        _OrchestratorFactory._build_dispatcher()        dns = _DataManager._bulk_get_or_create([foo_cfg, bar_cfg, baz_cfg])      foo = dns[foo_cfg]      bar = dns[bar_cfg]      baz = dns[baz_cfg]      task_1 = Task(\"by_2\", {}, partial(lock_multiply, lock_1, 2), [foo], [bar])      task_2 = Task(\"by_3\", {}, partial(lock_multiply, lock_2, 3), [bar], [baz])      scenario = Scenario(\"scenario_config\", [task_1, task_2], {})        assert task_1.foo.is_ready_for_reading  # foo is ready      assert not task_1.bar.is_ready_for_reading  # But bar is not ready      assert not task_2.baz.is_ready_for_reading  # neither does baz        assert len(_Orchestrator.blocked_jobs) == 0      with lock_2:          with lock_1:              jobs = _Orchestrator.submit(scenario)  # scenario is submitted              tasks_jobs = {job._task.id: job for job in jobs}              job_1, job_2 = tasks_jobs[task_1.id], tasks_jobs[task_2.id]              assert_true_after_time(job_1.is_running)  # job 1 is submitted and locked so it is still running              assert_true_after_time(lambda: len(_OrchestratorFactory._dispatcher._dispatched_processes) == 1)              assert not _DataManager._get(task_1.bar.id).is_ready_for_reading  # And bar still not ready              assert_true_after_time(job_2.is_blocked)  # the job_2 remains blocked          assert_true_after_time(job_1.is_completed)  # job1 unlocked and can complete          assert _DataManager._get(task_1.bar.id).is_ready_for_reading  # bar becomes ready          assert _DataManager._get(task_1.bar.id).read() == 2  # the data is computed and written          assert_true_after_time(job_2.is_running)  # And job 2 can start running          assert_true_after_time(lambda: len(_OrchestratorFactory._dispatcher._dispatched_processes) == 1)          assert len(_Orchestrator.blocked_jobs) == 0      assert_true_after_time(job_2.is_completed)  # job 2 unlocked so it can complete      assert _DataManager._get(task_2.baz.id).is_ready_for_reading  # baz becomes ready      assert _DataManager._get(task_2.baz.id).read() == 6  # the data is computed and written      assert_true_after_time(lambda: len(_OrchestratorFactory._dispatcher._dispatched_processes) == 0)      def test_task_orchestrator_create_synchronous_dispatcher():      Config.configure_job_executions(mode=JobConfig._DEVELOPMENT_MODE)      _OrchestratorFactory._build_dispatcher()        assert _OrchestratorFactory._dispatcher._nb_available_workers == 1      def test_task_orchestrator_create_standalone_dispatcher():      Config.configure_job_executions(mode=JobConfig._STANDALONE_MODE, max_nb_of_workers=3)      _OrchestratorFactory._build_dispatcher()      assert isinstance(_OrchestratorFactory._dispatcher._executor, ProcessPoolExecutor)      assert _OrchestratorFactory._dispatcher._nb_available_workers == 3      def modified_config_task(n):      from taipy.config import Config        assert_true_after_time(lambda: Config.core.storage_folder == \".my_data/\")      assert_true_after_time(lambda: Config.core.custom_property == \"custom_property\")      return n * 2      def test_can_exec_task_with_modified_config():      Config.configure_job_executions(mode=JobConfig._STANDALONE_MODE, max_nb_of_workers=2)      Config.configure_core(storage_folder=\".my_data/\", custom_property=\"custom_property\")        dn_input_config = Config.configure_data_node(\"input\", \"pickle\", scope=Scope.SCENARIO, default_data=1)      dn_output_config = Config.configure_data_node(\"output\", \"pickle\")      task_config = Config.configure_task(\"task_config\", modified_config_task, dn_input_config, dn_output_config)      scenario_config = Config.configure_scenario(\"scenario_config\", [task_config])        _OrchestratorFactory._build_dispatcher()        scenario = _ScenarioManager._create(scenario_config)        jobs = scenario.submit()      assert_true_after_time(jobs[0].is_finished, time=120)      assert_true_after_time(          jobs[0].is_completed      )  # If the job is completed, that means the asserts in the task are successful      def update_config_task(n):      from taipy.config import Config        # The exception will be saved to logger, and there is no way to check for it      # so it will be checked here      with pytest.raises(ConfigurationUpdateBlocked):          Config.core.storage_folder = \".new_storage_folder/\"      with pytest.raises(ConfigurationUpdateBlocked):          Config.core.properties = {\"custom_property\": \"new_custom_property\"}        Config.core.storage_folder = \".new_storage_folder/\"      Config.core.properties = {\"custom_property\": \"new_custom_property\"}        return n * 2      def test_cannot_exec_task_that_update_config():      \"\"\"      _ConfigBlocker singleton is not passed to the subprocesses. That means in each subprocess,      the config update will not be blocked.        After rebuilding a new Config in each subprocess, the Config should be blocked.      \"\"\"      Config.configure_job_executions(mode=JobConfig._STANDALONE_MODE, max_nb_of_workers=2)        dn_input_config = Config.configure_data_node(\"input\", \"pickle\", scope=Scope.SCENARIO, default_data=1)      dn_output_config = Config.configure_data_node(\"output\", \"pickle\")      task_config = Config.configure_task(\"task_config\", update_config_task, dn_input_config, dn_output_config)      scenario_config = Config.configure_scenario(\"scenario_config\", [task_config])        _OrchestratorFactory._build_dispatcher()        scenario = _ScenarioManager._create(scenario_config)        jobs = scenario.submit()        # The job should fail due to an exception is raised      assert_true_after_time(jobs[0].is_failed)      def test_can_execute_task_with_development_mode():      Config.configure_job_executions(mode=JobConfig._DEVELOPMENT_MODE)        dn_input_config = Config.configure_data_node(\"input\", \"pickle\", scope=Scope.SCENARIO, default_data=1)      dn_output_config = Config.configure_data_node(\"output\", \"pickle\")      task_config = Config.configure_task(\"task_config\", mult_by_2, dn_input_config, dn_output_config)      scenario_config = Config.configure_scenario(\"scenario_config\", [task_config])        _OrchestratorFactory._build_dispatcher()        scenario = _ScenarioManager._create(scenario_config)      scenario.submit()      while scenario.output.edit_in_progress:          sleep(1)      assert 2 == scenario.output.read()      def test_need_to_run_no_output():      hello_cfg = Config.configure_data_node(\"hello\", default_data=\"Hello \")      world_cfg = Config.configure_data_node(\"world\", default_data=\"world !\")      task_cfg = Config.configure_task(\"name\", input=[hello_cfg, world_cfg], function=concat, output=[])      task = _create_task_from_config(task_cfg)        assert _OrchestratorFactory._dispatcher._needs_to_run(task)      def test_need_to_run_task_not_skippable():      hello_cfg = Config.configure_data_node(\"hello\", default_data=\"Hello \")      world_cfg = Config.configure_data_node(\"world\", default_data=\"world !\")      hello_world_cfg = Config.configure_data_node(\"hello_world\")      task_cfg = Config.configure_task(          \"name\", input=[hello_cfg, world_cfg], function=concat, output=[hello_world_cfg], skippable=False      )      task = _create_task_from_config(task_cfg)        assert _OrchestratorFactory._dispatcher._needs_to_run(task)      def test_need_to_run_skippable_task_no_input():      Config.configure_job_executions(mode=JobConfig._DEVELOPMENT_MODE)        hello_world_cfg = Config.configure_data_node(\"hello_world\")      task_cfg = Config.configure_task(\"name\", input=[], function=nothing, output=[hello_world_cfg], skippable=True)        _OrchestratorFactory._build_dispatcher()        task = _create_task_from_config(task_cfg)      assert _OrchestratorFactory._dispatcher._needs_to_run(task)      _Orchestrator.submit_task(task)        assert not _OrchestratorFactory._dispatcher._needs_to_run(task)      def test_need_to_run_skippable_task_no_validity_period_on_output():      Config.configure_job_executions(mode=JobConfig._DEVELOPMENT_MODE)        hello_cfg = Config.configure_data_node(\"hello\", default_data=\"Hello \")      world_cfg = Config.configure_data_node(\"world\", default_data=\"world !\")      hello_world_cfg = Config.configure_data_node(\"hello_world\")      task_cfg = Config.configure_task(          \"name\", input=[hello_cfg, world_cfg], function=concat, output=[hello_world_cfg], skippable=True      )        _OrchestratorFactory._build_dispatcher()        task = _create_task_from_config(task_cfg)      assert _OrchestratorFactory._dispatcher._needs_to_run(task)      _Orchestrator.submit_task(task)        assert not _OrchestratorFactory._dispatcher._needs_to_run(task)      def test_need_to_run_skippable_task_with_validity_period_is_valid_on_output():      Config.configure_job_executions(mode=JobConfig._DEVELOPMENT_MODE)        hello_cfg = Config.configure_data_node(\"hello\", default_data=\"Hello \")      world_cfg = Config.configure_data_node(\"world\", default_data=\"world !\")      hello_world_cfg = Config.configure_data_node(\"hello_world\", validity_days=1)      task_cfg = Config.configure_task(          \"name\", input=[hello_cfg, world_cfg], function=concat, output=[hello_world_cfg], skippable=True      )      _OrchestratorFactory._build_dispatcher()        task = _create_task_from_config(task_cfg)        assert _OrchestratorFactory._dispatcher._needs_to_run(task)      job = _Orchestrator.submit_task(task)        assert not _OrchestratorFactory._dispatcher._needs_to_run(task)      job_skipped = _Orchestrator.submit_task(task)        assert job.is_completed()      assert job.is_finished()      assert job_skipped.is_skipped()      assert job_skipped.is_finished()      def test_need_to_run_skippable_task_with_validity_period_obsolete_on_output():      hello_cfg = Config.configure_data_node(\"hello\", default_data=\"Hello \")      world_cfg = Config.configure_data_node(\"world\", default_data=\"world !\")      hello_world_cfg = Config.configure_data_node(\"hello_world\", validity_days=1)      task_cfg = Config.configure_task(          \"name\", input=[hello_cfg, world_cfg], function=concat, output=[hello_world_cfg], skippable=True      )      task = _create_task_from_config(task_cfg)        assert _OrchestratorFactory._dispatcher._needs_to_run(task)      _Orchestrator.submit_task(task)        output = task.hello_world      output._last_edit_date = datetime.now() - timedelta(days=1, minutes=30)      _DataManager()._set(output)      assert _OrchestratorFactory._dispatcher._needs_to_run(task)      # ################################  UTIL METHODS    ##################################      def _create_task(function, nb_outputs=1):      output_dn_config_id = \"\".join(random.choice(string.ascii_lowercase) for _ in range(10))      dn_input_configs = [          Config.configure_data_node(\"input1\", \"pickle\", Scope.SCENARIO, default_data=21),          Config.configure_data_node(\"input2\", \"pickle\", Scope.SCENARIO, default_data=2),      ]      dn_output_configs = [          Config.configure_data_node(f\"{output_dn_config_id}_output{i}\", \"pickle\", Scope.SCENARIO, default_data=0)          for i in range(nb_outputs)      ]      input_dn = _DataManager._bulk_get_or_create(dn_input_configs).values()      output_dn = _DataManager._bulk_get_or_create(dn_output_configs).values()      return Task(          output_dn_config_id,          {},          function=function,          input=input_dn,          output=output_dn,      )      def _create_task_from_config(task_cfg):      return _TaskManager()._bulk_get_or_create([task_cfg])[0] "}
{"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": "from unittest import mock    import pytest    from src.taipy.core.config.data_node_config import DataNodeConfig  from src.taipy.core.data._data_manager import _DataManager  from src.taipy.core.data.csv import CSVDataNode  from src.taipy.core.data.data_node import DataNode  from src.taipy.core.data.in_memory import InMemoryDataNode  from src.taipy.core.task._task_manager import _TaskManager  from src.taipy.core.task.task import Task  from taipy.config.common.scope import Scope  from taipy.config.config import Config  from taipy.config.exceptions.exceptions import InvalidConfigurationId      @pytest.fixture  def output():      return [DataNode(\"name_1\"), DataNode(\"name_2\"), DataNode(\"name_3\")]      @pytest.fixture  def output_config():      return [DataNodeConfig(\"name_1\"), DataNodeConfig(\"name_2\"), DataNodeConfig(\"name_3\")]      @pytest.fixture  def input():      return [DataNode(\"input_name_1\"), DataNode(\"input_name_2\"), DataNode(\"input_name_3\")]      @pytest.fixture  def input_config():      return [DataNodeConfig(\"input_name_1\"), DataNodeConfig(\"input_name_2\"), DataNodeConfig(\"input_name_3\")]      def test_create_task():      name = \"name_1\"      task = Task(name, {}, print, [], [])      assert f\"TASK_{name}_\" in task.id      assert task.config_id == \"name_1\"        with pytest.raises(InvalidConfigurationId):          Task(\"foo bar\", {}, print, [], [])        path = \"my/csv/path\"      foo_dn = CSVDataNode(\"foo\", Scope.SCENARIO, properties={\"path\": path, \"has_header\": True})      task = Task(\"name_1\", {}, print, [foo_dn], [])      assert task.config_id == \"name_1\"      assert task.id is not None      assert task.owner_id is None      assert task.parent_ids == set()      assert task.foo == foo_dn      assert task.foo.path == path      with pytest.raises(AttributeError):          task.bar        task = Task(\"name_1\", {}, print, [foo_dn], [], parent_ids={\"parent_id\"})      assert task.parent_ids == {\"parent_id\"}        path = \"my/csv/path\"      abc_dn = InMemoryDataNode(\"name_1ea\", Scope.SCENARIO, properties={\"path\": path})        task = Task(\"name_1ea\", {}, print, [abc_dn], [], owner_id=\"owner_id\", parent_ids={\"parent_id_1\", \"parent_id_2\"})      assert task.config_id == \"name_1ea\"      assert task.id is not None      assert task.owner_id == \"owner_id\"      assert task.parent_ids == {\"parent_id_1\", \"parent_id_2\"}      assert task.name_1ea == abc_dn      assert task.name_1ea.path == path      with pytest.raises(AttributeError):          task.bar      with mock.patch(\"src.taipy.core.get\") as get_mck:            class MockOwner:              label = \"owner_label\"                def get_label(self):                  return self.label            get_mck.return_value = MockOwner()          assert task.get_label() == \"owner_label > \" + task.config_id          assert task.get_simple_label() == task.config_id      def test_can_not_change_task_output(output):      task = Task(\"name_1\", {}, print, output=output)        with pytest.raises(Exception):          task.output = {}        assert list(task.output.values()) == output      output.append(output[0])      assert list(task.output.values()) != output      def test_can_not_change_task_input(input):      task = Task(\"name_1\", {}, print, input=input)        with pytest.raises(Exception):          task.input = {}        assert list(task.input.values()) == input      input.append(input[0])      assert list(task.input.values()) != input      def test_can_not_change_task_config_output(output_config):      task_config = Config.configure_task(\"name_1\", print, [], output=output_config)        assert task_config.output_configs == output_config      with pytest.raises(Exception):          task_config.output_configs = []        output_config.append(output_config[0])      assert task_config._output != output_config      def test_can_not_update_task_output_values(output_config):      data_node_cfg = Config.configure_data_node(\"data_node_cfg\")      task_config = Config.configure_task(\"name_1\", print, [], output=output_config)        task_config.output_configs.append(data_node_cfg)      assert task_config.output_configs == output_config        task_config.output_configs[0] = data_node_cfg      assert task_config.output_configs[0] != data_node_cfg      def test_can_not_update_task_input_values(input_config):      data_node_config = DataNodeConfig(\"data_node\")      task_config = Config.configure_task(\"name_1\", print, input=input_config, output=[])        task_config.input_configs.append(data_node_config)      assert task_config.input_configs == input_config        task_config.input_configs[0] = data_node_config      assert task_config.input_configs[0] != data_node_config      def mock_func():      pass      def test_auto_set_and_reload(data_node):      task_1 = Task(          config_id=\"foo\", properties={}, function=print, input=None, output=None, owner_id=None, skippable=False      )        _DataManager._set(data_node)      _TaskManager._set(task_1)        task_2 = _TaskManager._get(task_1)        # auto set & reload on function attribute      assert task_1.function == print      assert task_2.function == print      task_1.function = sum      assert task_1.function == sum      assert task_2.function == sum      task_2.function = mock_func      assert task_1.function == mock_func      assert task_2.function == mock_func        # auto set & reload on skippable attribute      assert not task_1.skippable      assert not task_2.skippable      task_1.skippable = True      assert task_1.skippable      assert task_2.skippable      task_2.skippable = False      assert not task_1.skippable      assert not task_2.skippable        # auto set & reload on parent_ids attribute (set() object does not have auto set yet)      assert task_1.parent_ids == set()      assert task_2.parent_ids == set()      task_1._parent_ids.update([\"sc2\"])      _TaskManager._set(task_1)      assert task_1.parent_ids == {\"sc2\"}      assert task_2.parent_ids == {\"sc2\"}      task_2._parent_ids.clear()      task_2._parent_ids.update([\"sc1\"])      _TaskManager._set(task_2)      assert task_1.parent_ids == {\"sc1\"}      assert task_2.parent_ids == {\"sc1\"}        # auto set & reload on properties attribute      assert task_1.properties == {}      assert task_2.properties == {}      task_1._properties[\"qux\"] = 4      assert task_1.properties[\"qux\"] == 4      assert task_2.properties[\"qux\"] == 4        assert task_1.properties == {\"qux\": 4}      assert task_2.properties == {\"qux\": 4}      task_2._properties[\"qux\"] = 5      assert task_1.properties[\"qux\"] == 5      assert task_2.properties[\"qux\"] == 5        task_1.properties[\"temp_key_1\"] = \"temp_value_1\"      task_1.properties[\"temp_key_2\"] = \"temp_value_2\"      assert task_1.properties == {          \"qux\": 5,          \"temp_key_1\": \"temp_value_1\",          \"temp_key_2\": \"temp_value_2\",      }      assert task_2.properties == {          \"qux\": 5,          \"temp_key_1\": \"temp_value_1\",          \"temp_key_2\": \"temp_value_2\",      }      task_1.properties.pop(\"temp_key_1\")      assert \"temp_key_1\" not in task_1.properties.keys()      assert \"temp_key_1\" not in task_1.properties.keys()      assert task_1.properties == {          \"qux\": 5,          \"temp_key_2\": \"temp_value_2\",      }      assert task_2.properties == {          \"qux\": 5,          \"temp_key_2\": \"temp_value_2\",      }      task_2.properties.pop(\"temp_key_2\")      assert task_1.properties == {\"qux\": 5}      assert task_2.properties == {\"qux\": 5}      assert \"temp_key_2\" not in task_1.properties.keys()      assert \"temp_key_2\" not in task_2.properties.keys()        task_1.properties[\"temp_key_3\"] = 0      assert task_1.properties == {\"qux\": 5, \"temp_key_3\": 0}      assert task_2.properties == {\"qux\": 5, \"temp_key_3\": 0}      task_1.properties.update({\"temp_key_3\": 1})      assert task_1.properties == {\"qux\": 5, \"temp_key_3\": 1}      assert task_2.properties == {\"qux\": 5, \"temp_key_3\": 1}      task_1.properties.update(dict())      assert task_1.properties == {\"qux\": 5, \"temp_key_3\": 1}      assert task_2.properties == {\"qux\": 5, \"temp_key_3\": 1}      task_1.properties[\"temp_key_4\"] = 0      task_1.properties[\"temp_key_5\"] = 0        with task_1 as task:          assert task.config_id == \"foo\"          assert task.owner_id is None          assert task.function == mock_func          assert not task.skippable          assert task._is_in_context          assert task.properties[\"qux\"] == 5          assert task.properties[\"temp_key_3\"] == 1          assert task.properties[\"temp_key_4\"] == 0          assert task.properties[\"temp_key_5\"] == 0            task.function = print          task.skippable = True          task.properties[\"qux\"] = 9          task.properties.pop(\"temp_key_3\")          task.properties.pop(\"temp_key_4\")          task.properties.update({\"temp_key_4\": 1})          task.properties.update({\"temp_key_5\": 2})          task.properties.pop(\"temp_key_5\")          task.properties.update(dict())            assert task.config_id == \"foo\"          assert task.owner_id is None          assert task.function == mock_func          assert not task.skippable          assert task._is_in_context          assert task.properties[\"qux\"] == 5          assert task.properties[\"temp_key_3\"] == 1          assert task.properties[\"temp_key_4\"] == 0          assert task.properties[\"temp_key_5\"] == 0        assert task_1.config_id == \"foo\"      assert task_1.owner_id is None      assert task_1.function == print      assert task.skippable      assert not task_1._is_in_context      assert task_1.properties[\"qux\"] == 9      assert \"temp_key_3\" not in task_1.properties.keys()      assert task_1.properties[\"temp_key_4\"] == 1      assert \"temp_key_5\" not in task_1.properties.keys()      def test_get_parents(task):      with mock.patch(\"src.taipy.core.get_parents\") as mck:          task.get_parents()          mck.assert_called_once_with(task)      def test_submit_task(task: Task):      with mock.patch(\"src.taipy.core.task._task_manager._TaskManager._submit\") as mock_submit:          task.submit([], True)          mock_submit.assert_called_once_with(task, [], True, False, None) "}
{"text": "import os    import pytest    from src.taipy.core.data._data_sql_repository import _DataSQLRepository  from src.taipy.core.exceptions import ModelNotFound  from src.taipy.core.task._task_fs_repository import _TaskFSRepository  from src.taipy.core.task._task_sql_repository import _TaskSQLRepository  from src.taipy.core.task.task import Task, TaskId      class TestTaskFSRepository:      @pytest.mark.parametrize(\"repo\", [_TaskFSRepository, _TaskSQLRepository])      def test_save_and_load(self, data_node, repo, init_sql_repo):          repository = repo()          _DataSQLRepository()._save(data_node)          task = Task(\"task_config_id\", {}, print, [data_node], [data_node])            repository._save(task)            obj = repository._load(task.id)          assert isinstance(obj, Task)        @pytest.mark.parametrize(\"repo\", [_TaskFSRepository, _TaskSQLRepository])      def test_exists(self, data_node, repo, init_sql_repo):          repository = repo()          _DataSQLRepository()._save(data_node)          task = Task(\"task_config_id\", {}, print, [data_node], [data_node])            repository._save(task)            assert repository._exists(task.id)          assert not repository._exists(\"not-existed-task\")        @pytest.mark.parametrize(\"repo\", [_TaskFSRepository, _TaskSQLRepository])      def test_load_all(self, data_node, repo, init_sql_repo):          repository = repo()          _DataSQLRepository()._save(data_node)          task = Task(\"task_config_id\", {}, print, [data_node], [data_node])            for i in range(10):              task.id = TaskId(f\"task-{i}\")              repository._save(task)          data_nodes = repository._load_all()            assert len(data_nodes) == 10        @pytest.mark.parametrize(\"repo\", [_TaskFSRepository, _TaskSQLRepository])      def test_load_all_with_filters(self, data_node, repo, init_sql_repo):          repository = repo()          _DataSQLRepository()._save(data_node)          task = Task(\"task_config_id\", {}, print, [data_node], [data_node])            for i in range(10):              task.id = TaskId(f\"task-{i}\")              task.owner_id = f\"owner-{i}\"              repository._save(task)          objs = repository._load_all(filters=[{\"owner_id\": \"owner-2\"}])            assert len(objs) == 1        @pytest.mark.parametrize(\"repo\", [_TaskFSRepository, _TaskSQLRepository])      def test_delete(self, data_node, repo, init_sql_repo):          repository = repo()          _DataSQLRepository()._save(data_node)          task = Task(\"task_config_id\", {}, print, [data_node], [data_node])          repository._save(task)            repository._delete(task.id)            with pytest.raises(ModelNotFound):              repository._load(task.id)        @pytest.mark.parametrize(\"repo\", [_TaskFSRepository, _TaskSQLRepository])      def test_delete_all(self, data_node, repo, init_sql_repo):          repository = repo()          _DataSQLRepository()._save(data_node)          task = Task(\"task_config_id\", {}, print, [data_node], [data_node])            for i in range(10):              task.id = TaskId(f\"task-{i}\")              repository._save(task)            assert len(repository._load_all()) == 10            repository._delete_all()            assert len(repository._load_all()) == 0        @pytest.mark.parametrize(\"repo\", [_TaskFSRepository, _TaskSQLRepository])      def test_delete_many(self, data_node, repo, init_sql_repo):          repository = repo()          _DataSQLRepository()._save(data_node)          task = Task(\"task_config_id\", {}, print, [data_node], [data_node])            for i in range(10):              task.id = TaskId(f\"task-{i}\")              repository._save(task)            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\", [_TaskFSRepository, _TaskSQLRepository])      def test_delete_by(self, data_node, repo, init_sql_repo):          repository = repo()          _DataSQLRepository()._save(data_node)          task = Task(\"task_config_id\", {}, print, [data_node], [data_node])            # Create 5 entities with version 1.0 and 5 entities with version 2.0          for i in range(10):              task.id = TaskId(f\"task-{i}\")              task._version = f\"{(i+1) // 5}.0\"              repository._save(task)            objs = repository._load_all()          assert len(objs) == 10          repository._delete_by(\"version\", \"1.0\")            assert len(repository._load_all()) == 5        @pytest.mark.parametrize(\"repo\", [_TaskFSRepository, _TaskSQLRepository])      def test_search(self, data_node, repo, init_sql_repo):          repository = repo()          _DataSQLRepository()._save(data_node)          task = Task(\"task_config_id\", {}, print, [data_node], [data_node], version=\"random_version_number\")            for i in range(10):              task.id = TaskId(f\"task-{i}\")              task.owner_id = f\"owner-{i}\"              repository._save(task)            assert len(repository._load_all()) == 10            objs = repository._search(\"owner_id\", \"owner-2\")          assert len(objs) == 1          assert isinstance(objs[0], Task)            objs = repository._search(\"owner_id\", \"owner-2\", filters=[{\"version\": \"random_version_number\"}])          assert len(objs) == 1          assert isinstance(objs[0], Task)            assert repository._search(\"owner_id\", \"owner-2\", filters=[{\"version\": \"non_existed_version\"}]) == []        @pytest.mark.parametrize(\"repo\", [_TaskFSRepository, _TaskSQLRepository])      def test_export(self, tmpdir, data_node, repo, init_sql_repo):          repository = repo()          _DataSQLRepository()._save(data_node)          task = Task(\"task_config_id\", {}, print, [data_node], [data_node])          repository._save(task)            repository._export(task.id, tmpdir.strpath)          dir_path = repository.dir_path if repo == _TaskFSRepository else os.path.join(tmpdir.strpath, \"task\")            assert os.path.exists(os.path.join(dir_path, f\"{task.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 uuid  from unittest import mock    import pytest    from src.taipy.core import taipy  from src.taipy.core._orchestrator._orchestrator import _Orchestrator  from src.taipy.core._version._version_manager import _VersionManager  from src.taipy.core.data._data_manager import _DataManager  from src.taipy.core.data.in_memory import InMemoryDataNode  from src.taipy.core.exceptions.exceptions import ModelNotFound, NonExistingTask  from src.taipy.core.task._task_manager import _TaskManager  from src.taipy.core.task._task_manager_factory import _TaskManagerFactory  from src.taipy.core.task.task import Task  from src.taipy.core.task.task_id import TaskId  from taipy.config.common.scope import Scope  from taipy.config.config import Config      def test_create_and_save():      input_configs = [Config.configure_data_node(\"my_input\", \"in_memory\")]      output_configs = Config.configure_data_node(\"my_output\", \"in_memory\")      task_config = Config.configure_task(\"foo\", print, input_configs, output_configs)      task = _create_task_from_config(task_config)      assert task.id is not None      assert task.config_id == \"foo\"      assert len(task.input) == 1      assert len(_DataManager._get_all()) == 2      assert task.my_input.id is not None      assert task.my_input.config_id == \"my_input\"      assert task.my_output.id is not None      assert task.my_output.config_id == \"my_output\"      assert task.function == print      assert task.parent_ids == set()        task_retrieved_from_manager = _TaskManager._get(task.id)      assert task_retrieved_from_manager.id == task.id      assert task_retrieved_from_manager.config_id == task.config_id      assert len(task_retrieved_from_manager.input) == len(task.input)      assert task_retrieved_from_manager.my_input.id is not None      assert task_retrieved_from_manager.my_input.config_id == task.my_input.config_id      assert task_retrieved_from_manager.my_output.id is not None      assert task_retrieved_from_manager.my_output.config_id == task.my_output.config_id      assert task_retrieved_from_manager.function == task.function      assert task_retrieved_from_manager.parent_ids == set()      def test_do_not_recreate_existing_data_node():      input_config = Config.configure_data_node(\"my_input\", \"in_memory\", scope=Scope.SCENARIO)      output_config = Config.configure_data_node(\"my_output\", \"in_memory\", scope=Scope.SCENARIO)        _DataManager._create_and_set(input_config, \"scenario_id\", \"task_id\")      assert len(_DataManager._get_all()) == 1        task_config = Config.configure_task(\"foo\", print, input_config, output_config)      _create_task_from_config(task_config, scenario_id=\"scenario_id\")      assert len(_DataManager._get_all()) == 2      def test_assign_task_as_parent_of_datanode():      dn_config_1 = Config.configure_data_node(\"dn_1\", \"in_memory\", scope=Scope.SCENARIO)      dn_config_2 = Config.configure_data_node(\"dn_2\", \"in_memory\", scope=Scope.SCENARIO)      dn_config_3 = Config.configure_data_node(\"dn_3\", \"in_memory\", scope=Scope.SCENARIO)      task_config_1 = Config.configure_task(\"task_1\", print, dn_config_1, dn_config_2)      task_config_2 = Config.configure_task(\"task_2\", print, dn_config_2, dn_config_3)      tasks = _TaskManager._bulk_get_or_create([task_config_1, task_config_2], \"cycle_id\", \"scenario_id\")        assert len(_DataManager._get_all()) == 3      assert len(_TaskManager._get_all()) == 2      assert len(tasks) == 2        dns = {dn.config_id: dn for dn in _DataManager._get_all()}      assert dns[\"dn_1\"].parent_ids == {tasks[0].id}      assert dns[\"dn_2\"].parent_ids == set([tasks[0].id, tasks[1].id])      assert dns[\"dn_3\"].parent_ids == {tasks[1].id}      def test_do_not_recreate_existing_task():      input_config_scope_scenario = Config.configure_data_node(\"my_input_1\", \"in_memory\", Scope.SCENARIO)      output_config_scope_scenario = Config.configure_data_node(\"my_output_1\", \"in_memory\", Scope.SCENARIO)      task_config_1 = Config.configure_task(\"bar\", print, input_config_scope_scenario, output_config_scope_scenario)      # task_config_2 scope is Scenario        task_1 = _create_task_from_config(task_config_1)      assert len(_TaskManager._get_all()) == 1      task_2 = _create_task_from_config(task_config_1)  # Do not create. It already exists for None scenario      assert len(_TaskManager._get_all()) == 1      assert task_1.id == task_2.id      task_3 = _create_task_from_config(task_config_1, None, None)  # Do not create. It already exists for None scenario      assert len(_TaskManager._get_all()) == 1      assert task_1.id == task_2.id      assert task_2.id == task_3.id      task_4 = _create_task_from_config(task_config_1, None, \"scenario_1\")  # Create even if sequence is the same.      assert len(_TaskManager._get_all()) == 2      assert task_1.id == task_2.id      assert task_2.id == task_3.id      assert task_3.id != task_4.id      task_5 = _create_task_from_config(          task_config_1, None, \"scenario_1\"      )  # Do not create. It already exists for scenario_1      assert len(_TaskManager._get_all()) == 2      assert task_1.id == task_2.id      assert task_2.id == task_3.id      assert task_3.id != task_4.id      assert task_4.id == task_5.id      task_6 = _create_task_from_config(task_config_1, None, \"scenario_2\")      assert len(_TaskManager._get_all()) == 3      assert task_1.id == task_2.id      assert task_2.id == task_3.id      assert task_3.id != task_4.id      assert task_4.id == task_5.id      assert task_5.id != task_6.id      assert task_3.id != task_6.id        input_config_scope_cycle = Config.configure_data_node(\"my_input_2\", \"in_memory\", Scope.CYCLE)      output_config_scope_cycle = Config.configure_data_node(\"my_output_2\", \"in_memory\", Scope.CYCLE)      task_config_2 = Config.configure_task(\"xyz\", print, input_config_scope_cycle, output_config_scope_cycle)      # task_config_3 scope is Cycle        task_7 = _create_task_from_config(task_config_2)      assert len(_TaskManager._get_all()) == 4      task_8 = _create_task_from_config(task_config_2)  # Do not create. It already exists for None cycle      assert len(_TaskManager._get_all()) == 4      assert task_7.id == task_8.id      task_9 = _create_task_from_config(task_config_2, None, None)  # Do not create. It already exists for None cycle      assert len(_TaskManager._get_all()) == 4      assert task_7.id == task_8.id      assert task_8.id == task_9.id      task_10 = _create_task_from_config(          task_config_2, None, \"scenario\"      )  # Do not create. It already exists for None cycle      assert len(_TaskManager._get_all()) == 4      assert task_7.id == task_8.id      assert task_8.id == task_9.id      assert task_9.id == task_10.id      task_11 = _create_task_from_config(          task_config_2, None, \"scenario\"      )  # Do not create. It already exists for None cycle      assert len(_TaskManager._get_all()) == 4      assert task_7.id == task_8.id      assert task_8.id == task_9.id      assert task_9.id == task_10.id      assert task_10.id == task_11.id      task_12 = _create_task_from_config(task_config_2, \"cycle\", None)      assert len(_TaskManager._get_all()) == 5      assert task_7.id == task_8.id      assert task_8.id == task_9.id      assert task_9.id == task_10.id      assert task_10.id == task_11.id      assert task_11.id != task_12.id      task_13 = _create_task_from_config(task_config_2, \"cycle\", None)      assert len(_TaskManager._get_all()) == 5      assert task_7.id == task_8.id      assert task_8.id == task_9.id      assert task_9.id == task_10.id      assert task_10.id == task_11.id      assert task_11.id != task_12.id      assert task_12.id == task_13.id      def test_set_and_get_task():      task_id_1 = TaskId(\"id1\")      first_task = Task(\"name_1\", {}, print, [], [], task_id_1)      task_id_2 = TaskId(\"id2\")      second_task = Task(\"name_2\", {}, print, [], [], task_id_2)      third_task_with_same_id_as_first_task = Task(\"name_is_not_1_anymore\", {}, print, [], [], task_id_1)        # No task at initialization        assert len(_TaskManager._get_all()) == 0      assert _TaskManager._get(task_id_1) is None      assert _TaskManager._get(first_task) is None      assert _TaskManager._get(task_id_2) is None      assert _TaskManager._get(second_task) is None        # Save one task. We expect to have only one task stored      _TaskManager._set(first_task)      assert len(_TaskManager._get_all()) == 1      assert _TaskManager._get(task_id_1).id == first_task.id      assert _TaskManager._get(first_task).id == first_task.id      assert _TaskManager._get(task_id_2) is None      assert _TaskManager._get(second_task) is None        # Save a second task. Now, we expect to have a total of two tasks stored      _TaskManager._set(second_task)      assert len(_TaskManager._get_all()) == 2      assert _TaskManager._get(task_id_1).id == first_task.id      assert _TaskManager._get(first_task).id == first_task.id      assert _TaskManager._get(task_id_2).id == second_task.id      assert _TaskManager._get(second_task).id == second_task.id        # We save the first task again. We expect nothing to change      _TaskManager._set(first_task)      assert len(_TaskManager._get_all()) == 2      assert _TaskManager._get(task_id_1).id == first_task.id      assert _TaskManager._get(first_task).id == first_task.id      assert _TaskManager._get(task_id_2).id == second_task.id      assert _TaskManager._get(second_task).id == second_task.id        # We save a third task with same id as the first one.      # We expect the first task to be updated      _TaskManager._set(third_task_with_same_id_as_first_task)      assert len(_TaskManager._get_all()) == 2      assert _TaskManager._get(task_id_1).id == third_task_with_same_id_as_first_task.id      assert _TaskManager._get(task_id_1).config_id == third_task_with_same_id_as_first_task.config_id      assert _TaskManager._get(first_task).id == third_task_with_same_id_as_first_task.id      assert _TaskManager._get(task_id_2).id == second_task.id      assert _TaskManager._get(second_task).id == second_task.id      def test_get_all_on_multiple_versions_environment():      # Create 5 tasks with 2 versions each      # Only version 1.0 has the task with config_id = \"config_id_1\"      # Only version 2.0 has the task with config_id = \"config_id_6\"      for version in range(1, 3):          for i in range(5):              _TaskManager._set(                  Task(                      f\"config_id_{i+version}\", {}, print, [], [], id=TaskId(f\"id{i}_v{version}\"), version=f\"{version}.0\"                  )              )        _VersionManager._set_experiment_version(\"1.0\")      assert len(_TaskManager._get_all()) == 5      assert len(_TaskManager._get_all_by(filters=[{\"version\": \"1.0\", \"config_id\": \"config_id_1\"}])) == 1      assert len(_TaskManager._get_all_by(filters=[{\"version\": \"1.0\", \"config_id\": \"config_id_6\"}])) == 0        _VersionManager._set_experiment_version(\"2.0\")      assert len(_TaskManager._get_all()) == 5      assert len(_TaskManager._get_all_by(filters=[{\"version\": \"2.0\", \"config_id\": \"config_id_1\"}])) == 0      assert len(_TaskManager._get_all_by(filters=[{\"version\": \"2.0\", \"config_id\": \"config_id_6\"}])) == 1        _VersionManager._set_development_version(\"1.0\")      assert len(_TaskManager._get_all()) == 5      assert len(_TaskManager._get_all_by(filters=[{\"version\": \"1.0\", \"config_id\": \"config_id_1\"}])) == 1      assert len(_TaskManager._get_all_by(filters=[{\"version\": \"1.0\", \"config_id\": \"config_id_6\"}])) == 0        _VersionManager._set_development_version(\"2.0\")      assert len(_TaskManager._get_all()) == 5      assert len(_TaskManager._get_all_by(filters=[{\"version\": \"2.0\", \"config_id\": \"config_id_1\"}])) == 0      assert len(_TaskManager._get_all_by(filters=[{\"version\": \"2.0\", \"config_id\": \"config_id_6\"}])) == 1      def test_ensure_conservation_of_order_of_data_nodes_on_task_creation():      embedded_1 = Config.configure_data_node(\"dn_1\", \"in_memory\", scope=Scope.SCENARIO)      embedded_2 = Config.configure_data_node(\"dn_2\", \"in_memory\", scope=Scope.SCENARIO)      embedded_3 = Config.configure_data_node(\"a_dn_3\", \"in_memory\", scope=Scope.SCENARIO)      embedded_4 = Config.configure_data_node(\"dn_4\", \"in_memory\", scope=Scope.SCENARIO)      embedded_5 = Config.configure_data_node(\"dn_5\", \"in_memory\", scope=Scope.SCENARIO)        input = [embedded_1, embedded_2, embedded_3]      output = [embedded_4, embedded_5]        task_config_1 = Config.configure_task(\"name_1\", print, input, output)      task_config_2 = Config.configure_task(\"name_2\", print, input, output)        task_1, task_2 = _TaskManager._bulk_get_or_create([task_config_1, task_config_2])        assert [i.config_id for i in task_1.input.values()] == [embedded_1.id, embedded_2.id, embedded_3.id]      assert [o.config_id for o in task_1.output.values()] == [embedded_4.id, embedded_5.id]        assert [i.config_id for i in task_2.input.values()] == [embedded_1.id, embedded_2.id, embedded_3.id]      assert [o.config_id for o in task_2.output.values()] == [embedded_4.id, embedded_5.id]      def test_delete_raise_exception():      dn_input_config_1 = Config.configure_data_node(          \"my_input_1\", \"in_memory\", scope=Scope.SCENARIO, default_data=\"testing\"      )      dn_output_config_1 = Config.configure_data_node(\"my_output_1\", \"in_memory\")      task_config_1 = Config.configure_task(\"task_config_1\", print, dn_input_config_1, dn_output_config_1)      task_1 = _create_task_from_config(task_config_1)      _TaskManager._delete(task_1.id)        with pytest.raises(ModelNotFound):          _TaskManager._delete(task_1.id)      def test_hard_delete():      dn_input_config_1 = Config.configure_data_node(          \"my_input_1\", \"in_memory\", scope=Scope.SCENARIO, default_data=\"testing\"      )      dn_output_config_1 = Config.configure_data_node(\"my_output_1\", \"in_memory\")      task_config_1 = Config.configure_task(\"task_config_1\", print, dn_input_config_1, dn_output_config_1)      task_1 = _create_task_from_config(task_config_1)        assert len(_TaskManager._get_all()) == 1      assert len(_DataManager._get_all()) == 2      _TaskManager._hard_delete(task_1.id)      assert len(_TaskManager._get_all()) == 0      assert len(_DataManager._get_all()) == 2      def test_is_submittable():      assert len(_TaskManager._get_all()) == 0      dn_config = Config.configure_in_memory_data_node(\"dn\", 10)      task_config = Config.configure_task(\"task\", print, [dn_config])      task = _TaskManager._bulk_get_or_create([task_config])[0]        assert len(_TaskManager._get_all()) == 1      assert _TaskManager._is_submittable(task)      assert _TaskManager._is_submittable(task.id)      assert not _TaskManager._is_submittable(\"Task_temp\")        task.input[\"dn\"].edit_in_progress = True      assert not _TaskManager._is_submittable(task)      assert not _TaskManager._is_submittable(task.id)        task.input[\"dn\"].edit_in_progress = False      assert _TaskManager._is_submittable(task)      assert _TaskManager._is_submittable(task.id)      def test_submit_task():      data_node_1 = InMemoryDataNode(\"foo\", Scope.SCENARIO, \"s1\")      data_node_2 = InMemoryDataNode(\"bar\", Scope.SCENARIO, \"s2\")      task_1 = Task(          \"grault\",          {},          print,          [data_node_1],          [data_node_2],          TaskId(\"t1\"),      )        class MockOrchestrator(_Orchestrator):          submit_calls = []          submit_ids = []            def submit_task(self, task, callbacks=None, force=False, wait=False, timeout=None):              submit_id = f\"SUBMISSION_{str(uuid.uuid4())}\"              self.submit_calls.append(task)              self.submit_ids.append(submit_id)              return None        with mock.patch(\"src.taipy.core.task._task_manager._TaskManager._orchestrator\", new=MockOrchestrator):            # Task does not exist, we expect an exception          with pytest.raises(NonExistingTask):              _TaskManager._submit(task_1)          with pytest.raises(NonExistingTask):              _TaskManager._submit(task_1.id)            _TaskManager._set(task_1)          _TaskManager._submit(task_1)          call_ids = [call.id for call in MockOrchestrator.submit_calls]          assert call_ids == [task_1.id]          assert len(MockOrchestrator.submit_ids) == 1            _TaskManager._submit(task_1)          assert len(MockOrchestrator.submit_ids) == 2          assert len(MockOrchestrator.submit_ids) == len(set(MockOrchestrator.submit_ids))            _TaskManager._submit(task_1)          assert len(MockOrchestrator.submit_ids) == 3          assert len(MockOrchestrator.submit_ids) == len(set(MockOrchestrator.submit_ids))      def my_print(a, b):      print(a + b)      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\")      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\")      task_cfg = Config.configure_task(\"task\", my_print, [csv_dn_cfg, pickle_dn_cfg], parquet_dn_cfg)      task_manager = _TaskManagerFactory._build_manager()      tasks = task_manager._bulk_get_or_create([task_cfg])      task = tasks[0]      taipy.submit(task)        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 task.input.values()      ]      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 task.output.values()      ]      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_one_input_dn_wrong_file_path(caplog):      csv_dn_cfg = Config.configure_csv_data_node(\"wrong_csv_file_path\", default_path=\"wrong_path.csv\")      pickle_dn_cfg = Config.configure_pickle_data_node(\"pickle_file_path\", default_data=\"value\")      parquet_dn_cfg = Config.configure_parquet_data_node(\"wrong_parquet_file_path\", default_path=\"wrong_path.parquet\")      task_cfg = Config.configure_task(\"task\", my_print, [csv_dn_cfg, pickle_dn_cfg], parquet_dn_cfg)      task_manager = _TaskManagerFactory._build_manager()      tasks = task_manager._bulk_get_or_create([task_cfg])      task = tasks[0]      taipy.submit(task)        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 [task.input[\"wrong_csv_file_path\"]]      ]      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 [task.input[\"pickle_file_path\"], task.output[\"wrong_parquet_file_path\"]]      ]      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_get_tasks_by_config_id():      dn_config = Config.configure_data_node(\"dn\", scope=Scope.SCENARIO)      task_config_1 = Config.configure_task(\"t1\", print, dn_config)      task_config_2 = Config.configure_task(\"t2\", print, dn_config)      task_config_3 = Config.configure_task(\"t3\", print, dn_config)        t_1_1 = _TaskManager._bulk_get_or_create([task_config_1], scenario_id=\"scenario_1\")[0]      t_1_2 = _TaskManager._bulk_get_or_create([task_config_1], scenario_id=\"scenario_2\")[0]      t_1_3 = _TaskManager._bulk_get_or_create([task_config_1], scenario_id=\"scenario_3\")[0]      assert len(_TaskManager._get_all()) == 3        t_2_1 = _TaskManager._bulk_get_or_create([task_config_2], scenario_id=\"scenario_4\")[0]      t_2_2 = _TaskManager._bulk_get_or_create([task_config_2], scenario_id=\"scenario_5\")[0]      assert len(_TaskManager._get_all()) == 5        t_3_1 = _TaskManager._bulk_get_or_create([task_config_3], scenario_id=\"scenario_6\")[0]      assert len(_TaskManager._get_all()) == 6        t1_tasks = _TaskManager._get_by_config_id(task_config_1.id)      assert len(t1_tasks) == 3      assert sorted([t_1_1.id, t_1_2.id, t_1_3.id]) == sorted([task.id for task in t1_tasks])        t2_tasks = _TaskManager._get_by_config_id(task_config_2.id)      assert len(t2_tasks) == 2      assert sorted([t_2_1.id, t_2_2.id]) == sorted([task.id for task in t2_tasks])        t3_tasks = _TaskManager._get_by_config_id(task_config_3.id)      assert len(t3_tasks) == 1      assert sorted([t_3_1.id]) == sorted([task.id for task in t3_tasks])      def test_get_scenarios_by_config_id_in_multiple_versions_environment():      dn_config = Config.configure_data_node(\"dn\", scope=Scope.SCENARIO)      task_config_1 = Config.configure_task(\"t1\", print, dn_config)      task_config_2 = Config.configure_task(\"t2\", print, dn_config)        _VersionManager._set_experiment_version(\"1.0\")      _TaskManager._bulk_get_or_create([task_config_1], scenario_id=\"scenario_1\")[0]      _TaskManager._bulk_get_or_create([task_config_1], scenario_id=\"scenario_2\")[0]      _TaskManager._bulk_get_or_create([task_config_1], scenario_id=\"scenario_3\")[0]      _TaskManager._bulk_get_or_create([task_config_2], scenario_id=\"scenario_4\")[0]      _TaskManager._bulk_get_or_create([task_config_2], scenario_id=\"scenario_5\")[0]        assert len(_TaskManager._get_by_config_id(task_config_1.id)) == 3      assert len(_TaskManager._get_by_config_id(task_config_2.id)) == 2        _VersionManager._set_experiment_version(\"2.0\")      _TaskManager._bulk_get_or_create([task_config_1], scenario_id=\"scenario_1\")[0]      _TaskManager._bulk_get_or_create([task_config_1], scenario_id=\"scenario_2\")[0]      _TaskManager._bulk_get_or_create([task_config_1], scenario_id=\"scenario_3\")[0]      _TaskManager._bulk_get_or_create([task_config_2], scenario_id=\"scenario_4\")[0]      _TaskManager._bulk_get_or_create([task_config_2], scenario_id=\"scenario_5\")[0]        assert len(_TaskManager._get_by_config_id(task_config_1.id)) == 3      assert len(_TaskManager._get_by_config_id(task_config_2.id)) == 2      def _create_task_from_config(task_config, *args, **kwargs):      return _TaskManager._bulk_get_or_create([task_config], *args, **kwargs)[0] "}
{"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": "import uuid  from unittest import mock    import pytest    from src.taipy.core._orchestrator._orchestrator import _Orchestrator  from src.taipy.core._version._version_manager import _VersionManager  from src.taipy.core.data._data_manager import _DataManager  from src.taipy.core.data._data_manager_factory import _DataManagerFactory  from src.taipy.core.data.in_memory import InMemoryDataNode  from src.taipy.core.exceptions.exceptions import ModelNotFound, NonExistingTask  from src.taipy.core.job._job_manager_factory import _JobManagerFactory  from src.taipy.core.task._task_manager import _TaskManager  from src.taipy.core.task._task_manager_factory import _TaskManagerFactory  from src.taipy.core.task.task import Task  from src.taipy.core.task.task_id import TaskId  from taipy.config.common.scope import Scope  from taipy.config.config import Config      def init_managers():      _JobManagerFactory._build_manager()._delete_all()      _TaskManagerFactory._build_manager()._delete_all()      _DataManagerFactory._build_manager()._delete_all()      def test_create_and_save(init_sql_repo):      init_managers()        input_configs = [Config.configure_data_node(\"my_input\", \"in_memory\")]      output_configs = Config.configure_data_node(\"my_output\", \"in_memory\")      task_config = Config.configure_task(\"foo\", print, input_configs, output_configs)      task = _create_task_from_config(task_config)      assert task.id is not None      assert task.config_id == \"foo\"      assert len(task.input) == 1      assert len(_DataManager._get_all()) == 2      assert task.my_input.id is not None      assert task.my_input.config_id == \"my_input\"      assert task.my_output.id is not None      assert task.my_output.config_id == \"my_output\"      assert task.function == print      assert task.parent_ids == set()        task_retrieved_from_manager = _TaskManager._get(task.id)      assert task_retrieved_from_manager.id == task.id      assert task_retrieved_from_manager.config_id == task.config_id      assert len(task_retrieved_from_manager.input) == len(task.input)      assert task_retrieved_from_manager.my_input.id is not None      assert task_retrieved_from_manager.my_input.config_id == task.my_input.config_id      assert task_retrieved_from_manager.my_output.id is not None      assert task_retrieved_from_manager.my_output.config_id == task.my_output.config_id      assert task_retrieved_from_manager.function == task.function      assert task_retrieved_from_manager.parent_ids == set()      def test_do_not_recreate_existing_data_node(init_sql_repo):      init_managers()        input_config = Config.configure_data_node(\"my_input\", \"in_memory\", scope=Scope.SCENARIO)      output_config = Config.configure_data_node(\"my_output\", \"in_memory\", scope=Scope.SCENARIO)        _DataManager._create_and_set(input_config, \"scenario_id\", \"task_id\")      assert len(_DataManager._get_all()) == 1        task_config = Config.configure_task(\"foo\", print, input_config, output_config)      _create_task_from_config(task_config, scenario_id=\"scenario_id\")      assert len(_DataManager._get_all()) == 2      def test_do_not_recreate_existing_task(init_sql_repo):      init_managers()      assert len(_TaskManager._get_all()) == 0        input_config_scope_scenario = Config.configure_data_node(\"my_input_1\", \"in_memory\", Scope.SCENARIO)      output_config_scope_scenario = Config.configure_data_node(\"my_output_1\", \"in_memory\", Scope.SCENARIO)      task_config_1 = Config.configure_task(\"bar\", print, input_config_scope_scenario, output_config_scope_scenario)      # task_config_1 scope is Scenario        task_1 = _create_task_from_config(task_config_1)      assert len(_TaskManager._get_all()) == 1      task_2 = _create_task_from_config(task_config_1)  # Do not create. It already exists for None scenario      assert len(_TaskManager._get_all()) == 1      assert task_1.id == task_2.id      task_3 = _create_task_from_config(task_config_1, None, None)  # Do not create. It already exists for None scenario      assert len(_TaskManager._get_all()) == 1      assert task_1.id == task_2.id      assert task_2.id == task_3.id      task_4 = _create_task_from_config(task_config_1, None, \"scenario_1\")  # Create even if sequence is the same.      assert len(_TaskManager._get_all()) == 2      assert task_1.id == task_2.id      assert task_2.id == task_3.id      assert task_3.id != task_4.id      task_5 = _create_task_from_config(          task_config_1, None, \"scenario_1\"      )  # Do not create. It already exists for scenario_1      assert len(_TaskManager._get_all()) == 2      assert task_1.id == task_2.id      assert task_2.id == task_3.id      assert task_3.id != task_4.id      assert task_4.id == task_5.id      task_6 = _create_task_from_config(task_config_1, None, \"scenario_2\")      assert len(_TaskManager._get_all()) == 3      assert task_1.id == task_2.id      assert task_2.id == task_3.id      assert task_3.id != task_4.id      assert task_4.id == task_5.id      assert task_5.id != task_6.id      assert task_3.id != task_6.id        input_config_scope_cycle = Config.configure_data_node(\"my_input_2\", \"in_memory\", Scope.CYCLE)      output_config_scope_cycle = Config.configure_data_node(\"my_output_2\", \"in_memory\", Scope.CYCLE)      task_config_2 = Config.configure_task(\"xyz\", print, input_config_scope_cycle, output_config_scope_cycle)      # task_config_3 scope is Cycle        task_7 = _create_task_from_config(task_config_2)      assert len(_TaskManager._get_all()) == 4      task_8 = _create_task_from_config(task_config_2)  # Do not create. It already exists for None cycle      assert len(_TaskManager._get_all()) == 4      assert task_7.id == task_8.id      task_9 = _create_task_from_config(task_config_2, None, None)  # Do not create. It already exists for None cycle      assert len(_TaskManager._get_all()) == 4      assert task_7.id == task_8.id      assert task_8.id == task_9.id      task_10 = _create_task_from_config(          task_config_2, None, \"scenario\"      )  # Do not create. It already exists for None cycle      assert len(_TaskManager._get_all()) == 4      assert task_7.id == task_8.id      assert task_8.id == task_9.id      assert task_9.id == task_10.id      task_11 = _create_task_from_config(          task_config_2, None, \"scenario\"      )  # Do not create. It already exists for None cycle      assert len(_TaskManager._get_all()) == 4      assert task_7.id == task_8.id      assert task_8.id == task_9.id      assert task_9.id == task_10.id      assert task_10.id == task_11.id      task_12 = _create_task_from_config(task_config_2, \"cycle\", None)      assert len(_TaskManager._get_all()) == 5      assert task_7.id == task_8.id      assert task_8.id == task_9.id      assert task_9.id == task_10.id      assert task_10.id == task_11.id      assert task_11.id != task_12.id      task_13 = _create_task_from_config(task_config_2, \"cycle\", None)      assert len(_TaskManager._get_all()) == 5      assert task_7.id == task_8.id      assert task_8.id == task_9.id      assert task_9.id == task_10.id      assert task_10.id == task_11.id      assert task_11.id != task_12.id      assert task_12.id == task_13.id      def test_set_and_get_task(init_sql_repo):      init_managers()        task_id_1 = TaskId(\"id1\")      first_task = Task(\"name_1\", {}, print, [], [], task_id_1)      task_id_2 = TaskId(\"id2\")      second_task = Task(\"name_2\", {}, print, [], [], task_id_2)      third_task_with_same_id_as_first_task = Task(\"name_is_not_1_anymore\", {}, print, [], [], task_id_1)        # No task at initialization        assert len(_TaskManager._get_all()) == 0      assert _TaskManager._get(task_id_1) is None      assert _TaskManager._get(first_task) is None      assert _TaskManager._get(task_id_2) is None      assert _TaskManager._get(second_task) is None        # Save one task. We expect to have only one task stored      _TaskManager._set(first_task)      assert len(_TaskManager._get_all()) == 1      assert _TaskManager._get(task_id_1).id == first_task.id      assert _TaskManager._get(first_task).id == first_task.id      assert _TaskManager._get(task_id_2) is None      assert _TaskManager._get(second_task) is None        # Save a second task. Now, we expect to have a total of two tasks stored      _TaskManager._set(second_task)      assert len(_TaskManager._get_all()) == 2      assert _TaskManager._get(task_id_1).id == first_task.id      assert _TaskManager._get(first_task).id == first_task.id      assert _TaskManager._get(task_id_2).id == second_task.id      assert _TaskManager._get(second_task).id == second_task.id        # We save the first task again. We expect nothing to change      _TaskManager._set(first_task)      assert len(_TaskManager._get_all()) == 2      assert _TaskManager._get(task_id_1).id == first_task.id      assert _TaskManager._get(first_task).id == first_task.id      assert _TaskManager._get(task_id_2).id == second_task.id      assert _TaskManager._get(second_task).id == second_task.id        # We save a third task with same id as the first one.      # We expect the first task to be updated      _TaskManager._set(third_task_with_same_id_as_first_task)      assert len(_TaskManager._get_all()) == 2      assert _TaskManager._get(task_id_1).id == third_task_with_same_id_as_first_task.id      assert _TaskManager._get(task_id_1).config_id == third_task_with_same_id_as_first_task.config_id      assert _TaskManager._get(first_task).id == third_task_with_same_id_as_first_task.id      assert _TaskManager._get(task_id_2).id == second_task.id      assert _TaskManager._get(second_task).id == second_task.id      def test_get_all_on_multiple_versions_environment(init_sql_repo):      Config.configure_global_app(repository_type=\"sql\")      init_managers()        # Create 5 tasks with 2 versions each      # Only version 1.0 has the task with config_id = \"config_id_1\"      # Only version 2.0 has the task with config_id = \"config_id_6\"      for version in range(1, 3):          for i in range(5):              _TaskManager._set(                  Task(                      f\"config_id_{i+version}\", {}, print, [], [], id=TaskId(f\"id{i}_v{version}\"), version=f\"{version}.0\"                  )              )        _VersionManager._set_experiment_version(\"1.0\")      assert len(_TaskManager._get_all()) == 5      assert len(_TaskManager._get_all_by(filters=[{\"version\": \"1.0\", \"config_id\": \"config_id_1\"}])) == 1      assert len(_TaskManager._get_all_by(filters=[{\"version\": \"1.0\", \"config_id\": \"config_id_6\"}])) == 0        _VersionManager._set_experiment_version(\"2.0\")      assert len(_TaskManager._get_all()) == 5      assert len(_TaskManager._get_all_by(filters=[{\"version\": \"2.0\", \"config_id\": \"config_id_1\"}])) == 0      assert len(_TaskManager._get_all_by(filters=[{\"version\": \"2.0\", \"config_id\": \"config_id_6\"}])) == 1        _VersionManager._set_development_version(\"1.0\")      assert len(_TaskManager._get_all()) == 5      assert len(_TaskManager._get_all_by(filters=[{\"version\": \"1.0\", \"config_id\": \"config_id_1\"}])) == 1      assert len(_TaskManager._get_all_by(filters=[{\"version\": \"1.0\", \"config_id\": \"config_id_6\"}])) == 0        _VersionManager._set_development_version(\"2.0\")      assert len(_TaskManager._get_all()) == 5      assert len(_TaskManager._get_all_by(filters=[{\"version\": \"2.0\", \"config_id\": \"config_id_1\"}])) == 0      assert len(_TaskManager._get_all_by(filters=[{\"version\": \"2.0\", \"config_id\": \"config_id_6\"}])) == 1      def test_ensure_conservation_of_order_of_data_nodes_on_task_creation(init_sql_repo):      init_managers()        embedded_1 = Config.configure_data_node(\"dn_1\", \"in_memory\", scope=Scope.SCENARIO)      embedded_2 = Config.configure_data_node(\"dn_2\", \"in_memory\", scope=Scope.SCENARIO)      embedded_3 = Config.configure_data_node(\"a_dn_3\", \"in_memory\", scope=Scope.SCENARIO)      embedded_4 = Config.configure_data_node(\"dn_4\", \"in_memory\", scope=Scope.SCENARIO)      embedded_5 = Config.configure_data_node(\"dn_5\", \"in_memory\", scope=Scope.SCENARIO)        input = [embedded_1, embedded_2, embedded_3]      output = [embedded_4, embedded_5]        task_config_1 = Config.configure_task(\"name_1\", print, input, output)      task_config_2 = Config.configure_task(\"name_2\", print, input, output)        task_1, task_2 = _TaskManager._bulk_get_or_create([task_config_1, task_config_2])        assert [i.config_id for i in task_1.input.values()] == [embedded_1.id, embedded_2.id, embedded_3.id]      assert [o.config_id for o in task_1.output.values()] == [embedded_4.id, embedded_5.id]        assert [i.config_id for i in task_2.input.values()] == [embedded_1.id, embedded_2.id, embedded_3.id]      assert [o.config_id for o in task_2.output.values()] == [embedded_4.id, embedded_5.id]      def test_delete_raise_exception(init_sql_repo):      init_managers()        dn_input_config_1 = Config.configure_data_node(          \"my_input_1\", \"in_memory\", scope=Scope.SCENARIO, default_data=\"testing\"      )      dn_output_config_1 = Config.configure_data_node(\"my_output_1\", \"in_memory\")      task_config_1 = Config.configure_task(\"task_config_1\", print, dn_input_config_1, dn_output_config_1)      task_1 = _create_task_from_config(task_config_1)      _TaskManager._delete(task_1.id)        with pytest.raises(ModelNotFound):          _TaskManager._delete(task_1.id)      def test_hard_delete(init_sql_repo):      init_managers()        dn_input_config_1 = Config.configure_data_node(          \"my_input_1\", \"in_memory\", scope=Scope.SCENARIO, default_data=\"testing\"      )      dn_output_config_1 = Config.configure_data_node(\"my_output_1\", \"in_memory\")      task_config_1 = Config.configure_task(\"task_config_1\", print, dn_input_config_1, dn_output_config_1)      task_1 = _create_task_from_config(task_config_1)        assert len(_TaskManager._get_all()) == 1      assert len(_DataManager._get_all()) == 2      _TaskManager._hard_delete(task_1.id)      assert len(_TaskManager._get_all()) == 0      assert len(_DataManager._get_all()) == 2      def test_submit_task():      data_node_1 = InMemoryDataNode(\"foo\", Scope.SCENARIO, \"s1\")      data_node_2 = InMemoryDataNode(\"bar\", Scope.SCENARIO, \"s2\")      task_1 = Task(          \"grault\",          {},          print,          [data_node_1],          [data_node_2],          TaskId(\"t1\"),      )        class MockOrchestrator(_Orchestrator):          submit_calls = []          submit_ids = []            def submit_task(self, task, callbacks=None, force=False, wait=False, timeout=None):              submit_id = f\"SUBMISSION_{str(uuid.uuid4())}\"              self.submit_calls.append(task)              self.submit_ids.append(submit_id)              return None        with mock.patch(\"src.taipy.core.task._task_manager._TaskManager._orchestrator\", new=MockOrchestrator):            # Task does not exist, we expect an exception          with pytest.raises(NonExistingTask):              _TaskManager._submit(task_1)          with pytest.raises(NonExistingTask):              _TaskManager._submit(task_1.id)            _TaskManager._set(task_1)          _TaskManager._submit(task_1)          call_ids = [call.id for call in MockOrchestrator.submit_calls]          assert call_ids == [task_1.id]          assert len(MockOrchestrator.submit_ids) == 1            _TaskManager._submit(task_1)          assert len(MockOrchestrator.submit_ids) == 2          assert len(MockOrchestrator.submit_ids) == len(set(MockOrchestrator.submit_ids))            _TaskManager._submit(task_1)          assert len(MockOrchestrator.submit_ids) == 3          assert len(MockOrchestrator.submit_ids) == len(set(MockOrchestrator.submit_ids))      def test_get_tasks_by_config_id(init_sql_repo):      init_managers()        dn_config = Config.configure_data_node(\"dn\", scope=Scope.SCENARIO)      task_config_1 = Config.configure_task(\"t1\", print, dn_config)      task_config_2 = Config.configure_task(\"t2\", print, dn_config)      task_config_3 = Config.configure_task(\"t3\", print, dn_config)        t_1_1 = _TaskManager._bulk_get_or_create([task_config_1], scenario_id=\"scenario_1\")[0]      t_1_2 = _TaskManager._bulk_get_or_create([task_config_1], scenario_id=\"scenario_2\")[0]      t_1_3 = _TaskManager._bulk_get_or_create([task_config_1], scenario_id=\"scenario_3\")[0]      assert len(_TaskManager._get_all()) == 3        t_2_1 = _TaskManager._bulk_get_or_create([task_config_2], scenario_id=\"scenario_4\")[0]      t_2_2 = _TaskManager._bulk_get_or_create([task_config_2], scenario_id=\"scenario_5\")[0]      assert len(_TaskManager._get_all()) == 5        t_3_1 = _TaskManager._bulk_get_or_create([task_config_3], scenario_id=\"scenario_6\")[0]      assert len(_TaskManager._get_all()) == 6        t1_tasks = _TaskManager._get_by_config_id(task_config_1.id)      assert len(t1_tasks) == 3      assert sorted([t_1_1.id, t_1_2.id, t_1_3.id]) == sorted([task.id for task in t1_tasks])        t2_tasks = _TaskManager._get_by_config_id(task_config_2.id)      assert len(t2_tasks) == 2      assert sorted([t_2_1.id, t_2_2.id]) == sorted([task.id for task in t2_tasks])        t3_tasks = _TaskManager._get_by_config_id(task_config_3.id)      assert len(t3_tasks) == 1      assert sorted([t_3_1.id]) == sorted([task.id for task in t3_tasks])      def test_get_scenarios_by_config_id_in_multiple_versions_environment(init_sql_repo):      init_managers()        dn_config = Config.configure_data_node(\"dn\", scope=Scope.SCENARIO)      task_config_1 = Config.configure_task(\"t1\", print, dn_config)      task_config_2 = Config.configure_task(\"t2\", print, dn_config)        _VersionManager._set_experiment_version(\"1.0\")      _TaskManager._bulk_get_or_create([task_config_1], scenario_id=\"scenario_1\")[0]      _TaskManager._bulk_get_or_create([task_config_1], scenario_id=\"scenario_2\")[0]      _TaskManager._bulk_get_or_create([task_config_1], scenario_id=\"scenario_3\")[0]      _TaskManager._bulk_get_or_create([task_config_2], scenario_id=\"scenario_4\")[0]      _TaskManager._bulk_get_or_create([task_config_2], scenario_id=\"scenario_5\")[0]        assert len(_TaskManager._get_by_config_id(task_config_1.id)) == 3      assert len(_TaskManager._get_by_config_id(task_config_2.id)) == 2        _VersionManager._set_experiment_version(\"2.0\")      _TaskManager._bulk_get_or_create([task_config_1], scenario_id=\"scenario_1\")[0]      _TaskManager._bulk_get_or_create([task_config_1], scenario_id=\"scenario_2\")[0]      _TaskManager._bulk_get_or_create([task_config_1], scenario_id=\"scenario_3\")[0]      _TaskManager._bulk_get_or_create([task_config_2], scenario_id=\"scenario_4\")[0]      _TaskManager._bulk_get_or_create([task_config_2], scenario_id=\"scenario_5\")[0]        assert len(_TaskManager._get_by_config_id(task_config_1.id)) == 3      assert len(_TaskManager._get_by_config_id(task_config_2.id)) == 2      def _create_task_from_config(task_config, *args, **kwargs):      return _TaskManager._bulk_get_or_create([task_config], *args, **kwargs)[0] "}
{"text": "from datetime import timedelta  from time import sleep  from typing import Union  from unittest import mock  from unittest.mock import MagicMock    import pytest    from src.taipy.core import JobId, Sequence, SequenceId, 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.in_memory import InMemoryDataNode  from src.taipy.core.job._job_manager import _JobManager  from src.taipy.core.job.job import Job  from src.taipy.core.job.status import Status  from src.taipy.core.scenario.scenario import Scenario  from src.taipy.core.submission._submission_manager_factory import _SubmissionManagerFactory  from src.taipy.core.submission.submission import Submission  from src.taipy.core.task._task_manager import _TaskManager  from src.taipy.core.task.task import Task  from taipy.config.common.scope import Scope  from taipy.config.config import Config      @pytest.fixture  def task_id():      return TaskId(\"task_id1\")      @pytest.fixture  def task(task_id):      return Task(config_id=\"name\", properties={}, function=print, input=[], output=[], id=task_id)      @pytest.fixture  def job_id():      return JobId(\"id1\")      @pytest.fixture(scope=\"class\")  def scenario():      return Scenario(          \"scenario_config\",          [],          {},          [],          \"SCENARIO_scenario_config\",          version=\"random_version_number\",      )      @pytest.fixture  def job(task, job_id):      return Job(job_id, task, \"submit_id\", \"SCENARIO_scenario_config\")      @pytest.fixture  def replace_in_memory_write_fct():      default_write = InMemoryDataNode.write      InMemoryDataNode.write = _error      yield      InMemoryDataNode.write = default_write      def _foo():      return 42      def _error():      raise RuntimeError(\"Something bad has happened\")      def test_create_job(scenario, task, job):      from src.taipy.core.scenario._scenario_manager_factory import _ScenarioManagerFactory        _ScenarioManagerFactory._build_manager()._set(scenario)        assert job.id == \"id1\"      assert task in job      assert job.is_submitted()      assert job.submit_id is not None      assert job.submit_entity_id == \"SCENARIO_scenario_config\"      assert job.submit_entity == scenario      with mock.patch(\"src.taipy.core.get\") as get_mck:          get_mck.return_value = task          assert job.get_label() == \"name > \" + job.id      assert job.get_simple_label() == job.id      def test_comparison(task):      job_id_1 = JobId(\"id1\")      job_id_2 = JobId(\"id2\")        job_1 = Job(job_id_1, task, \"submit_id\", \"scenario_entity_id\")      sleep(0.01)  # Comparison is based on time, precision on Windows is not enough important      job_2 = Job(job_id_2, task, \"submit_id\", \"scenario_entity_id\")        assert job_1 < job_2      assert job_2 > job_1      assert job_1 <= job_2      assert job_1 <= job_1      assert job_2 >= job_1      assert job_1 >= job_1      assert job_1 == job_1      assert job_1 != job_2      def test_status_job(task):      submission = _SubmissionManagerFactory._build_manager()._create(task.id)      job = Job(\"job_id\", task, submission.id, \"SCENARIO_scenario_config\")      submission.jobs = [job]        assert job.is_submitted()      assert job.is_skipped() is False      assert job.is_pending() is False      assert job.is_blocked() is False      assert job.is_canceled() is False      assert job.is_failed() is False      assert job.is_completed() is False      assert job.is_running() is False        job.canceled()      assert job.is_canceled()      job.failed()      assert job.is_failed()      job.running()      assert job.is_running()      job.completed()      assert job.is_completed()      job.pending()      assert job.is_pending()      job.blocked()      assert job.is_blocked()      job.skipped()      assert job.is_skipped()      def test_notification_job(task):      subscribe = MagicMock()      submission = _SubmissionManagerFactory._build_manager()._create(task.id)      job = Job(\"job_id\", task, submission.id, \"SCENARIO_scenario_config\")      submission.jobs = [job]        job._on_status_change(subscribe)        job.running()      subscribe.assert_called_once_with(job)      subscribe.reset_mock()        job.completed()      subscribe.assert_called_once_with(job)      subscribe.reset_mock()        job.skipped()      subscribe.assert_called_once_with(job)      def test_handle_exception_in_user_function(task_id, job_id):      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, \"scenario_entity_id\")      submission.jobs = [job]        _dispatch(task, job)        job = _JobManager._get(job_id)      assert job.is_failed()      assert 'raise RuntimeError(\"Something bad has happened\")' in str(job.stacktrace[0])      def test_handle_exception_in_input_data_node(task_id, job_id):      data_node = InMemoryDataNode(\"data_node\", scope=Scope.SCENARIO)      task = Task(config_id=\"name\", properties={}, input=[data_node], function=print, output=[], id=task_id)      submission = _SubmissionManagerFactory._build_manager()._create(task.id)      job = Job(job_id, task, submission.id, \"scenario_entity_id\")      submission.jobs = [job]        _dispatch(task, job)        job = _JobManager._get(job_id)      assert job.is_failed()      assert \"taipy.core.exceptions.exceptions.NoData\" in str(job.stacktrace[0])      def test_handle_exception_in_ouptut_data_node(replace_in_memory_write_fct, task_id, job_id):      data_node = InMemoryDataNode(\"data_node\", scope=Scope.SCENARIO)      task = Task(config_id=\"name\", properties={}, input=[], function=_foo, output=[data_node], id=task_id)      submission = _SubmissionManagerFactory._build_manager()._create(task.id)      job = Job(job_id, task, submission.id, \"scenario_entity_id\")      submission.jobs = [job]        _dispatch(task, job)        job = _JobManager._get(job_id)        assert job.is_failed()      assert \"taipy.core.exceptions.exceptions.DataNodeWritingError\" in str(job.stacktrace[0])      def test_auto_set_and_reload(current_datetime, job_id):      task_1 = Task(config_id=\"name_1\", properties={}, function=_foo, id=TaskId(\"task_1\"))      task_2 = Task(config_id=\"name_2\", properties={}, function=_foo, id=TaskId(\"task_2\"))      submission = _SubmissionManagerFactory._build_manager()._create(task_1.id)      job_1 = Job(job_id, task_1, submission.id, \"scenario_entity_id\")      submission.jobs = [job_1]        _TaskManager._set(task_1)      _TaskManager._set(task_2)      _JobManager._set(job_1)        job_2 = _JobManager._get(job_1, \"submit_id_2\")        # auto set & reload on task attribute      assert job_1.task.id == task_1.id      assert job_2.task.id == task_1.id      job_1.task = task_2      assert job_1.task.id == task_2.id      assert job_2.task.id == task_2.id      job_2.task = task_1      assert job_1.task.id == task_1.id      assert job_2.task.id == task_1.id        # auto set & reload on force attribute      assert not job_1.force      assert not job_2.force      job_1.force = True      assert job_1.force      assert job_2.force      job_2.force = False      assert not job_1.force      assert not job_2.force        # auto set & reload on status attribute      assert job_1.status == Status.SUBMITTED      assert job_2.status == Status.SUBMITTED      job_1.status = Status.CANCELED      assert job_1.status == Status.CANCELED      assert job_2.status == Status.CANCELED      job_2.status = Status.BLOCKED      assert job_1.status == Status.BLOCKED      assert job_2.status == Status.BLOCKED        # auto set & reload on creation_date attribute      new_datetime = current_datetime + timedelta(1)      new_datetime_1 = current_datetime + timedelta(1)      job_1.creation_date = new_datetime_1      assert job_1.creation_date == new_datetime_1      assert job_2.creation_date == new_datetime_1      job_2.creation_date = new_datetime      assert job_1.creation_date == new_datetime      assert job_2.creation_date == new_datetime        with job_1 as job:          assert job.task.id == task_1.id          assert not job.force          assert job.status == Status.BLOCKED          assert job.creation_date == new_datetime          assert job._is_in_context            new_datetime_2 = new_datetime + timedelta(1)          job.task = task_2          job.force = True          job.status = Status.COMPLETED          job.creation_date = new_datetime_2            assert job.task.id == task_1.id          assert not job.force          assert job.status == Status.BLOCKED          assert job.creation_date == new_datetime          assert job._is_in_context        assert job_1.task.id == task_2.id      assert job_1.force      assert job_1.status == Status.COMPLETED      assert job_1.creation_date == new_datetime_2      assert not job_1._is_in_context      def _dispatch(task: Task, job: Job, mode=JobConfig._DEVELOPMENT_MODE):      Config.configure_job_executions(mode=mode)      _OrchestratorFactory._build_dispatcher()      _TaskManager._set(task)      _JobManager._set(job)      dispatcher: Union[_StandaloneJobDispatcher, _DevelopmentJobDispatcher] = _StandaloneJobDispatcher(          _OrchestratorFactory._orchestrator      )      if mode == JobConfig._DEVELOPMENT_MODE:          dispatcher = _DevelopmentJobDispatcher(_OrchestratorFactory._orchestrator)      dispatcher._dispatch(job)      def test_is_deletable():      with mock.patch(\"src.taipy.core.job._job_manager._JobManager._is_deletable\") as mock_submit:          task = Task(config_id=\"name_1\", properties={}, function=_foo, id=TaskId(\"task_1\"))          job = Job(job_id, task, \"submit_id_1\", \"scenario_entity_id\")          job.is_deletable()          mock_submit.assert_called_once_with(job) "}
{"text": "import multiprocessing  import random  import string  from functools import partial  from time import sleep  from unittest import mock    import pytest    from src.taipy.core._orchestrator._dispatcher._job_dispatcher import _JobDispatcher  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.data._data_manager_factory import _DataManagerFactory  from src.taipy.core.data.in_memory import InMemoryDataNode  from src.taipy.core.exceptions.exceptions import JobNotDeletedException  from src.taipy.core.job._job_manager import _JobManager  from src.taipy.core.job.job_id import JobId  from src.taipy.core.job.status import Status  from src.taipy.core.submission._submission_manager_factory import _SubmissionManagerFactory  from src.taipy.core.task._task_manager import _TaskManager  from src.taipy.core.task.task import Task  from taipy.config.common.scope import Scope  from taipy.config.config import Config  from tests.core.utils import assert_true_after_time      def multiply(nb1: float, nb2: float):      return nb1 * nb2      def lock_multiply(lock, nb1: float, nb2: float):      with lock:          return multiply(1 or nb1, 2 or nb2)      def test_create_jobs():      Config.configure_job_executions(mode=JobConfig._DEVELOPMENT_MODE)      task = _create_task(multiply, name=\"get_job\")        _OrchestratorFactory._build_dispatcher()        job_1 = _JobManager._create(task, [print], \"submit_id\", \"secnario_id\", True)      assert _JobManager._get(job_1.id) == job_1      assert job_1.is_submitted()      assert task.config_id in job_1.id      assert job_1.task.id == task.id      assert job_1.submit_id == \"submit_id\"      assert job_1.submit_entity_id == \"secnario_id\"      assert job_1.force        job_2 = _JobManager._create(task, [print], \"submit_id_1\", \"secnario_id\", False)      assert _JobManager._get(job_2.id) == job_2      assert job_2.is_submitted()      assert task.config_id in job_2.id      assert job_2.task.id == task.id      assert job_2.submit_id == \"submit_id_1\"      assert job_2.submit_entity_id == \"secnario_id\"      assert not job_2.force      def test_get_job():      Config.configure_job_executions(mode=JobConfig._DEVELOPMENT_MODE)        task = _create_task(multiply, name=\"get_job\")        _OrchestratorFactory._build_dispatcher()        job_1 = _OrchestratorFactory._orchestrator.submit_task(task)      assert _JobManager._get(job_1.id) == job_1      assert _JobManager._get(job_1.id).submit_entity_id == task.id        job_2 = _OrchestratorFactory._orchestrator.submit_task(task)      assert job_1 != job_2      assert _JobManager._get(job_1.id).id == job_1.id      assert _JobManager._get(job_2.id).id == job_2.id      assert _JobManager._get(job_2.id).submit_entity_id == task.id      def test_get_latest_job():      Config.configure_job_executions(mode=JobConfig._DEVELOPMENT_MODE)        task = _create_task(multiply, name=\"get_latest_job\")      task_2 = _create_task(multiply, name=\"get_latest_job_2\")        _OrchestratorFactory._build_dispatcher()        job_1 = _OrchestratorFactory._orchestrator.submit_task(task)      assert _JobManager._get_latest(task) == job_1      assert _JobManager._get_latest(task_2) is None        sleep(0.01)  # Comparison is based on time, precision on Windows is not enough important      job_2 = _OrchestratorFactory._orchestrator.submit_task(task_2)      assert _JobManager._get_latest(task).id == job_1.id      assert _JobManager._get_latest(task_2).id == job_2.id        sleep(0.01)  # Comparison is based on time, precision on Windows is not enough important      job_1_bis = _OrchestratorFactory._orchestrator.submit_task(task)      assert _JobManager._get_latest(task).id == job_1_bis.id      assert _JobManager._get_latest(task_2).id == job_2.id      def test_get_job_unknown():      assert _JobManager._get(JobId(\"Unknown\")) is None      def test_get_jobs():      Config.configure_job_executions(mode=JobConfig._DEVELOPMENT_MODE)        task = _create_task(multiply, name=\"get_all_jobs\")        _OrchestratorFactory._build_dispatcher()        job_1 = _OrchestratorFactory._orchestrator.submit_task(task)      job_2 = _OrchestratorFactory._orchestrator.submit_task(task)        assert {job.id for job in _JobManager._get_all()} == {job_1.id, job_2.id}      def test_delete_job():      Config.configure_job_executions(mode=JobConfig._DEVELOPMENT_MODE)        task = _create_task(multiply, name=\"delete_job\")        _OrchestratorFactory._build_dispatcher()        job_1 = _OrchestratorFactory._orchestrator.submit_task(task)      job_2 = _OrchestratorFactory._orchestrator.submit_task(task)        _JobManager._delete(job_1)        assert [job.id for job in _JobManager._get_all()] == [job_2.id]      assert _JobManager._get(job_1.id) is None      m = multiprocessing.Manager()  lock = m.Lock()      def inner_lock_multiply(nb1: float, nb2: float):      with lock:          return multiply(1 or nb1, 2 or nb2)      def test_raise_when_trying_to_delete_unfinished_job():      Config.configure_job_executions(mode=JobConfig._STANDALONE_MODE, max_nb_of_workers=2)      m = multiprocessing.Manager()      lock = m.Lock()      dnm = _DataManagerFactory._build_manager()      dn_1 = InMemoryDataNode(\"dn_config_1\", Scope.SCENARIO, properties={\"default_data\": 1})      dnm._set(dn_1)      dn_2 = InMemoryDataNode(\"dn_config_2\", Scope.SCENARIO, properties={\"default_data\": 2})      dnm._set(dn_2)      dn_3 = InMemoryDataNode(\"dn_config_3\", Scope.SCENARIO)      dnm._set(dn_3)      task = Task(          \"task_config_1\", {}, partial(lock_multiply, lock), [dn_1, dn_2], [dn_3], id=\"raise_when_delete_unfinished\"      )      _OrchestratorFactory._build_dispatcher()      with lock:          job = _OrchestratorFactory._orchestrator.submit_task(task)            assert_true_after_time(lambda: len(_JobDispatcher._dispatched_processes) == 1)          assert_true_after_time(job.is_running)          with pytest.raises(JobNotDeletedException):              _JobManager._delete(job)          with pytest.raises(JobNotDeletedException):              _JobManager._delete(job, force=False)      assert_true_after_time(job.is_completed)      _JobManager._delete(job)      def test_force_deleting_unfinished_job():      Config.configure_job_executions(mode=JobConfig._STANDALONE_MODE, max_nb_of_workers=2)      m = multiprocessing.Manager()      lock = m.Lock()      dnm = _DataManagerFactory._build_manager()      dn_1 = InMemoryDataNode(\"dn_config_1\", Scope.SCENARIO, properties={\"default_data\": 1})      dnm._set(dn_1)      dn_2 = InMemoryDataNode(\"dn_config_2\", Scope.SCENARIO, properties={\"default_data\": 2})      dnm._set(dn_2)      dn_3 = InMemoryDataNode(\"dn_config_3\", Scope.SCENARIO)      dnm._set(dn_3)      task = Task(          \"task_config_1\", {}, partial(lock_multiply, lock), [dn_1, dn_2], [dn_3], id=\"force_deleting_unfinished_job\"      )      _OrchestratorFactory._build_dispatcher()      with lock:          job = _OrchestratorFactory._orchestrator.submit_task(task)          assert_true_after_time(job.is_running)          with pytest.raises(JobNotDeletedException):              _JobManager._delete(job, force=False)          _JobManager._delete(job, force=True)      assert _JobManager._get(job.id) is None      def test_cancel_single_job():      Config.configure_job_executions(mode=JobConfig._STANDALONE_MODE, max_nb_of_workers=1)        task = _create_task(multiply, name=\"cancel_single_job\")        _OrchestratorFactory._build_dispatcher()        assert_true_after_time(_OrchestratorFactory._dispatcher.is_running)      _OrchestratorFactory._dispatcher.stop()      assert_true_after_time(lambda: not _OrchestratorFactory._dispatcher.is_running())        job = _OrchestratorFactory._orchestrator.submit_task(task)        assert_true_after_time(job.is_pending)      assert_true_after_time(lambda: len(_JobDispatcher._dispatched_processes) == 0)      _JobManager._cancel(job.id)      assert_true_after_time(job.is_canceled)      assert_true_after_time(job.is_canceled)      @mock.patch(      \"src.taipy.core._orchestrator._orchestrator._Orchestrator._orchestrate_job_to_run_or_block\",      return_value=\"orchestrated_job\",  )  @mock.patch(\"src.taipy.core._orchestrator._orchestrator._Orchestrator._cancel_jobs\")  def test_cancel_canceled_abandoned_failed_jobs(cancel_jobs, orchestrated_job):      Config.configure_job_executions(mode=JobConfig._STANDALONE_MODE, max_nb_of_workers=1)        task = _create_task(multiply, name=\"test_cancel_canceled_abandoned_failed_jobs\")        _OrchestratorFactory._build_dispatcher()        assert_true_after_time(_OrchestratorFactory._dispatcher.is_running)      _OrchestratorFactory._dispatcher.stop()      assert_true_after_time(lambda: not _OrchestratorFactory._dispatcher.is_running())        job = _OrchestratorFactory._orchestrator.submit_task(task)      job.canceled()      assert job.is_canceled()      _JobManager._cancel(job)      cancel_jobs.assert_not_called()      assert job.is_canceled()        job = _OrchestratorFactory._orchestrator.submit_task(task)      job.failed()      assert job.is_failed()      _JobManager._cancel(job)      cancel_jobs.assert_not_called()      assert job.is_failed()        job = _OrchestratorFactory._orchestrator.submit_task(task)      job.abandoned()      assert job.is_abandoned()      _JobManager._cancel(job)      cancel_jobs.assert_not_called()      assert job.is_abandoned()      @mock.patch(      \"src.taipy.core._orchestrator._orchestrator._Orchestrator._orchestrate_job_to_run_or_block\",      return_value=\"orchestrated_job\",  )  @mock.patch(\"src.taipy.core.job.job.Job.canceled\")  def test_cancel_completed_skipped_jobs(cancel_jobs, orchestrated_job):      Config.configure_job_executions(mode=JobConfig._STANDALONE_MODE, max_nb_of_workers=1)      task = _create_task(multiply, name=\"cancel_single_job\")        _OrchestratorFactory._build_dispatcher()        assert_true_after_time(_OrchestratorFactory._dispatcher.is_running)      _OrchestratorFactory._dispatcher.stop()      assert_true_after_time(lambda: not _OrchestratorFactory._dispatcher.is_running())        job = _OrchestratorFactory._orchestrator.submit_task(task)      job.completed()      assert job.is_completed()      cancel_jobs.assert_not_called()      _JobManager._cancel(job)      assert job.is_completed()        job = _OrchestratorFactory._orchestrator.submit_task(task)      job.failed()      assert job.is_failed()      cancel_jobs.assert_not_called()      _JobManager._cancel(job)      assert job.is_failed()        job = _OrchestratorFactory._orchestrator.submit_task(task)      job.skipped()      assert job.is_skipped()      cancel_jobs.assert_not_called()      _JobManager._cancel(job)      assert job.is_skipped()      def test_cancel_single_running_job():      Config.configure_job_executions(mode=JobConfig._STANDALONE_MODE, max_nb_of_workers=2)        m = multiprocessing.Manager()      lock = m.Lock()      dnm = _DataManagerFactory._build_manager()      dn_1 = InMemoryDataNode(\"dn_config_1\", Scope.SCENARIO, properties={\"default_data\": 1})      dnm._set(dn_1)      dn_2 = InMemoryDataNode(\"dn_config_2\", Scope.SCENARIO, properties={\"default_data\": 2})      dnm._set(dn_2)      dn_3 = InMemoryDataNode(\"dn_config_3\", Scope.SCENARIO)      dnm._set(dn_3)      task = Task(\"task_config_1\", {}, partial(lock_multiply, lock), [dn_1, dn_2], [dn_3], id=\"cancel_single_job\")        _OrchestratorFactory._build_dispatcher()        assert_true_after_time(_OrchestratorFactory._dispatcher.is_running)      assert_true_after_time(lambda: _OrchestratorFactory._dispatcher._nb_available_workers == 2)        with lock:          job = _OrchestratorFactory._orchestrator.submit_task(task)            assert_true_after_time(lambda: len(_JobDispatcher._dispatched_processes) == 1)          assert_true_after_time(lambda: _OrchestratorFactory._dispatcher._nb_available_workers == 1)          assert_true_after_time(job.is_running)          _JobManager._cancel(job)          assert_true_after_time(job.is_running)      assert_true_after_time(lambda: len(_JobDispatcher._dispatched_processes) == 0)      assert_true_after_time(lambda: _OrchestratorFactory._dispatcher._nb_available_workers == 2)      assert_true_after_time(job.is_completed)      def test_cancel_subsequent_jobs():      Config.configure_job_executions(mode=JobConfig._STANDALONE_MODE, max_nb_of_workers=1)      _OrchestratorFactory._build_dispatcher()      orchestrator = _OrchestratorFactory._orchestrator      submission_manager = _SubmissionManagerFactory._build_manager()        lock_0 = m.Lock()        dn_1 = InMemoryDataNode(\"dn_config_1\", Scope.SCENARIO, properties={\"default_data\": 1})      dn_2 = InMemoryDataNode(\"dn_config_2\", Scope.SCENARIO, properties={\"default_data\": 2})      dn_3 = InMemoryDataNode(\"dn_config_3\", Scope.SCENARIO, properties={\"default_data\": 3})      dn_4 = InMemoryDataNode(\"dn_config_4\", Scope.SCENARIO, properties={\"default_data\": 4})      task_1 = Task(\"task_config_1\", {}, partial(lock_multiply, lock_0), [dn_1, dn_2], [dn_3], id=\"task_1\")      task_2 = Task(\"task_config_2\", {}, multiply, [dn_1, dn_3], [dn_4], id=\"task_2\")      task_3 = Task(\"task_config_3\", {}, print, [dn_4], id=\"task_3\")        # Can't get tasks under 1 scenario due to partial not serializable      submission_1 = submission_manager._create(\"scenario_id\")      submission_2 = submission_manager._create(\"scenario_id\")        _DataManager._set(dn_1)      _DataManager._set(dn_2)      _DataManager._set(dn_3)      _DataManager._set(dn_4)        with lock_0:          job_1 = orchestrator._lock_dn_output_and_create_job(              task_1, submit_id=submission_1.id, submit_entity_id=submission_1.entity_id          )          orchestrator._orchestrate_job_to_run_or_block([job_1])          job_2 = orchestrator._lock_dn_output_and_create_job(              task_2, submit_id=submission_1.id, submit_entity_id=submission_1.entity_id          )          orchestrator._orchestrate_job_to_run_or_block([job_2])          job_3 = orchestrator._lock_dn_output_and_create_job(              task_3, submit_id=submission_1.id, submit_entity_id=submission_1.entity_id          )          orchestrator._orchestrate_job_to_run_or_block([job_3])            submission_1.jobs = [job_1, job_2, job_3]            assert_true_after_time(lambda: _OrchestratorFactory._orchestrator.jobs_to_run.qsize() == 0)          assert_true_after_time(lambda: len(_OrchestratorFactory._orchestrator.blocked_jobs) == 2)          assert_true_after_time(job_1.is_running)          assert_true_after_time(job_2.is_blocked)          assert_true_after_time(job_3.is_blocked)            job_4 = _OrchestratorFactory._orchestrator._lock_dn_output_and_create_job(              task_1, submit_id=submission_2.id, submit_entity_id=submission_2.entity_id          )          orchestrator._orchestrate_job_to_run_or_block([job_4])          job_5 = _OrchestratorFactory._orchestrator._lock_dn_output_and_create_job(              task_2, submit_id=submission_2.id, submit_entity_id=submission_2.entity_id          )          orchestrator._orchestrate_job_to_run_or_block([job_5])          job_6 = _OrchestratorFactory._orchestrator._lock_dn_output_and_create_job(              task_3, submit_id=submission_2.id, submit_entity_id=submission_2.entity_id          )          orchestrator._orchestrate_job_to_run_or_block([job_6])            submission_2.jobs = [job_4, job_5, job_6]            assert_true_after_time(job_4.is_pending)          assert_true_after_time(job_5.is_blocked)          assert_true_after_time(job_6.is_blocked)          assert _OrchestratorFactory._orchestrator.jobs_to_run.qsize() == 1          assert len(_OrchestratorFactory._orchestrator.blocked_jobs) == 4            _JobManager._cancel(job_4)          assert_true_after_time(job_4.is_canceled)          assert_true_after_time(job_5.is_abandoned)          assert_true_after_time(job_6.is_abandoned)          assert _OrchestratorFactory._orchestrator.jobs_to_run.qsize() == 0          assert len(_OrchestratorFactory._orchestrator.blocked_jobs) == 2            _JobManager._cancel(job_1)          assert_true_after_time(job_1.is_running)          assert_true_after_time(job_2.is_abandoned)          assert_true_after_time(job_3.is_abandoned)        assert_true_after_time(job_1.is_completed)      assert_true_after_time(job_2.is_abandoned)      assert_true_after_time(job_3.is_abandoned)      assert_true_after_time(job_4.is_canceled)      assert_true_after_time(job_5.is_abandoned)      assert_true_after_time(job_6.is_abandoned)      assert_true_after_time(          lambda: all(              not _OrchestratorFactory._orchestrator._is_blocked(job)              for job in [job_1, job_2, job_3, job_4, job_5, job_6]          )      )      assert_true_after_time(lambda: _OrchestratorFactory._orchestrator.jobs_to_run.qsize() == 0)      def test_is_deletable():      assert len(_JobManager._get_all()) == 0      task = _create_task(print, 0, \"task\")      job = _OrchestratorFactory._orchestrator.submit_task(task)        assert job.is_completed()      assert _JobManager._is_deletable(job)      assert _JobManager._is_deletable(job.id)        job.abandoned()      assert job.is_abandoned()      assert _JobManager._is_deletable(job)      assert _JobManager._is_deletable(job.id)        job.canceled()      assert job.is_canceled()      assert _JobManager._is_deletable(job)      assert _JobManager._is_deletable(job.id)        job.failed()      assert job.is_failed()      assert _JobManager._is_deletable(job)      assert _JobManager._is_deletable(job.id)        job.skipped()      assert job.is_skipped()      assert _JobManager._is_deletable(job)      assert _JobManager._is_deletable(job.id)        job.blocked()      assert job.is_blocked()      assert not _JobManager._is_deletable(job)      assert not _JobManager._is_deletable(job.id)        job.running()      assert job.is_running()      assert not _JobManager._is_deletable(job)      assert not _JobManager._is_deletable(job.id)        job.pending()      assert job.is_pending()      assert not _JobManager._is_deletable(job)      assert not _JobManager._is_deletable(job.id)        job.status = Status.SUBMITTED      assert job.is_submitted()      assert not _JobManager._is_deletable(job)      assert not _JobManager._is_deletable(job.id)      def _create_task(function, nb_outputs=1, name=None):      input1_dn_config = Config.configure_data_node(\"input1\", \"pickle\", Scope.SCENARIO, default_data=21)      input2_dn_config = Config.configure_data_node(\"input2\", \"pickle\", Scope.SCENARIO, default_data=2)      output_dn_configs = [          Config.configure_data_node(f\"output{i}\", \"pickle\", Scope.SCENARIO, default_data=0) for i in range(nb_outputs)      ]      _DataManager._bulk_get_or_create({cfg for cfg in output_dn_configs})      name = name or \"\".join(random.choice(string.ascii_lowercase) for _ in range(10))      task_config = Config.configure_task(          id=name,          function=function,          input=[input1_dn_config, input2_dn_config],          output=output_dn_configs,      )      return _TaskManager._bulk_get_or_create([task_config])[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 multiprocessing  import random  import string  from functools import partial  from time import sleep    import pytest    from src.taipy.core import Task  from src.taipy.core._orchestrator._dispatcher._job_dispatcher import _JobDispatcher  from src.taipy.core._orchestrator._orchestrator_factory import _OrchestratorFactory  from src.taipy.core._repository.db._sql_connection import _build_connection, _SQLConnection  from src.taipy.core.config.job_config import JobConfig  from src.taipy.core.data import InMemoryDataNode  from src.taipy.core.data._data_manager import _DataManager  from src.taipy.core.data._data_manager_factory import _DataManagerFactory  from src.taipy.core.exceptions.exceptions import JobNotDeletedException  from src.taipy.core.job._job_manager import _JobManager  from src.taipy.core.job._job_manager_factory import _JobManagerFactory  from src.taipy.core.job.job_id import JobId  from src.taipy.core.job.status import Status  from src.taipy.core.task._task_manager import _TaskManager  from src.taipy.core.task._task_manager_factory import _TaskManagerFactory  from taipy.config.common.scope import Scope  from taipy.config.config import Config  from tests.core.utils import assert_true_after_time      def multiply(nb1: float, nb2: float):      return nb1 * nb2      def lock_multiply(lock, nb1: float, nb2: float):      with lock:          return multiply(nb1 or 1, nb2 or 2)      def init_managers():      _TaskManagerFactory._build_manager()._delete_all()      _DataManagerFactory._build_manager()._delete_all()      _JobManagerFactory._build_manager()._delete_all()      def test_create_jobs(init_sql_repo):      Config.configure_job_executions(mode=JobConfig._DEVELOPMENT_MODE)      init_managers()        task = _create_task(multiply, name=\"get_job\")        _OrchestratorFactory._build_dispatcher()        job_1 = _JobManager._create(task, [print], \"submit_id\", \"secnario_id\", True)      assert _JobManager._get(job_1.id) == job_1      assert job_1.is_submitted()      assert task.config_id in job_1.id      assert job_1.task.id == task.id      assert job_1.submit_id == \"submit_id\"      assert job_1.submit_entity_id == \"secnario_id\"      assert job_1.force        job_2 = _JobManager._create(task, [print], \"submit_id_1\", \"secnario_id\", False)      assert _JobManager._get(job_2.id) == job_2      assert job_2.is_submitted()      assert task.config_id in job_2.id      assert job_2.task.id == task.id      assert job_2.submit_id == \"submit_id_1\"      assert job_2.submit_entity_id == \"secnario_id\"      assert not job_2.force      def test_get_job(init_sql_repo):      Config.configure_job_executions(mode=JobConfig._DEVELOPMENT_MODE)      init_managers()        task = _create_task(multiply, name=\"get_job\")        _OrchestratorFactory._build_dispatcher()        job_1 = _OrchestratorFactory._orchestrator.submit_task(task)      assert _JobManager._get(job_1.id) == job_1      assert _JobManager._get(job_1.id).submit_entity_id == task.id        job_2 = _OrchestratorFactory._orchestrator.submit_task(task)      assert job_1 != job_2      assert _JobManager._get(job_1.id).id == job_1.id      assert _JobManager._get(job_2.id).id == job_2.id      assert _JobManager._get(job_2.id).submit_entity_id == task.id      def test_get_latest_job(init_sql_repo):      Config.configure_job_executions(mode=JobConfig._DEVELOPMENT_MODE)      init_managers()        task = _create_task(multiply, name=\"get_latest_job\")      task_2 = _create_task(multiply, name=\"get_latest_job_2\")        _OrchestratorFactory._build_dispatcher()        job_1 = _OrchestratorFactory._orchestrator.submit_task(task)      assert _JobManager._get_latest(task) == job_1      assert _JobManager._get_latest(task_2) is None        sleep(0.01)  # Comparison is based on time, precision on Windows is not enough important      job_2 = _OrchestratorFactory._orchestrator.submit_task(task_2)      assert _JobManager._get_latest(task).id == job_1.id      assert _JobManager._get_latest(task_2).id == job_2.id        sleep(0.01)  # Comparison is based on time, precision on Windows is not enough important      job_1_bis = _OrchestratorFactory._orchestrator.submit_task(task)      assert _JobManager._get_latest(task).id == job_1_bis.id      assert _JobManager._get_latest(task_2).id == job_2.id      def test_get_job_unknown(init_sql_repo):      init_managers()      assert _JobManager._get(JobId(\"Unknown\")) is None      def test_get_jobs(init_sql_repo):      Config.configure_job_executions(mode=JobConfig._DEVELOPMENT_MODE)      init_managers()        task = _create_task(multiply, name=\"get_all_jobs\")        _OrchestratorFactory._build_dispatcher()        job_1 = _OrchestratorFactory._orchestrator.submit_task(task)      job_2 = _OrchestratorFactory._orchestrator.submit_task(task)        assert {job.id for job in _JobManager._get_all()} == {job_1.id, job_2.id}      def test_delete_job(init_sql_repo):      Config.configure_job_executions(mode=JobConfig._DEVELOPMENT_MODE)        init_managers()        task = _create_task(multiply, name=\"delete_job\")        _OrchestratorFactory._build_dispatcher()        job_1 = _OrchestratorFactory._orchestrator.submit_task(task)      job_2 = _OrchestratorFactory._orchestrator.submit_task(task)        _JobManager._delete(job_1)        assert [job.id for job in _JobManager._get_all()] == [job_2.id]      assert _JobManager._get(job_1.id) is None      def test_raise_when_trying_to_delete_unfinished_job(init_sql_repo):      Config.configure_job_executions(mode=JobConfig._STANDALONE_MODE, max_nb_of_workers=2)      init_managers()        m = multiprocessing.Manager()      lock = m.Lock()      dnm = _DataManagerFactory._build_manager()      dn_1 = InMemoryDataNode(\"dn_config_1\", Scope.SCENARIO, properties={\"default_data\": 1})      dnm._set(dn_1)      dn_2 = InMemoryDataNode(\"dn_config_2\", Scope.SCENARIO, properties={\"default_data\": 2})      dnm._set(dn_2)      dn_3 = InMemoryDataNode(\"dn_config_3\", Scope.SCENARIO)      dnm._set(dn_3)      task = Task(\"task_cfg\", {}, partial(lock_multiply, lock), [dn_1, dn_2], [dn_3], id=\"raise_when_delete_unfinished\")      _OrchestratorFactory._build_dispatcher()        with lock:          job = _OrchestratorFactory._orchestrator.submit_task(task)            assert_true_after_time(lambda: len(_JobDispatcher._dispatched_processes) == 1)          assert_true_after_time(job.is_running)          with pytest.raises(JobNotDeletedException):              _JobManager._delete(job)          with pytest.raises(JobNotDeletedException):              _JobManager._delete(job, force=False)      assert_true_after_time(job.is_completed)      _JobManager._delete(job)      def test_force_deleting_unfinished_job(init_sql_repo):      Config.configure_job_executions(mode=JobConfig._STANDALONE_MODE, max_nb_of_workers=2)      init_managers()        m = multiprocessing.Manager()      lock = m.Lock()      dnm = _DataManagerFactory._build_manager()      dn_1 = InMemoryDataNode(\"dn_config_1\", Scope.SCENARIO, properties={\"default_data\": 1})      dnm._set(dn_1)      dn_2 = InMemoryDataNode(\"dn_config_2\", Scope.SCENARIO, properties={\"default_data\": 2})      dnm._set(dn_2)      dn_3 = InMemoryDataNode(\"dn_config_3\", Scope.SCENARIO)      dnm._set(dn_3)      task_1 = Task(          \"task_config_1\", {}, partial(lock_multiply, lock), [dn_1, dn_2], [dn_3], id=\"delete_force_unfinished_job\"      )      reference_last_edit_date = dn_3.last_edit_date      _OrchestratorFactory._build_dispatcher()        with lock:          job = _OrchestratorFactory._orchestrator.submit_task(task_1)          assert_true_after_time(job.is_running)          with pytest.raises(JobNotDeletedException):              _JobManager._delete(job, force=False)          _JobManager._delete(job, force=True)      assert _JobManager._get(job.id) is None      assert_true_after_time(lambda: reference_last_edit_date != dn_3.last_edit_date)      def test_is_deletable(init_sql_repo):        init_managers()        assert len(_JobManager._get_all()) == 0      task = _create_task(print, 0, \"task\")      job = _OrchestratorFactory._orchestrator.submit_task(task)        assert job.is_completed()      assert _JobManager._is_deletable(job)      assert _JobManager._is_deletable(job.id)        job.abandoned()      assert job.is_abandoned()      assert _JobManager._is_deletable(job)      assert _JobManager._is_deletable(job.id)        job.canceled()      assert job.is_canceled()      assert _JobManager._is_deletable(job)      assert _JobManager._is_deletable(job.id)        job.failed()      assert job.is_failed()      assert _JobManager._is_deletable(job)      assert _JobManager._is_deletable(job.id)        job.skipped()      assert job.is_skipped()      assert _JobManager._is_deletable(job)      assert _JobManager._is_deletable(job.id)        job.blocked()      assert job.is_blocked()      assert not _JobManager._is_deletable(job)      assert not _JobManager._is_deletable(job.id)        job.running()      assert job.is_running()      assert not _JobManager._is_deletable(job)      assert not _JobManager._is_deletable(job.id)        job.pending()      assert job.is_pending()      assert not _JobManager._is_deletable(job)      assert not _JobManager._is_deletable(job.id)        job.status = Status.SUBMITTED      assert job.is_submitted()      assert not _JobManager._is_deletable(job)      assert not _JobManager._is_deletable(job.id)      def _create_task(function, nb_outputs=1, name=None):      input1_dn_config = Config.configure_data_node(\"input1\", scope=Scope.SCENARIO, default_data=21)      input2_dn_config = Config.configure_data_node(\"input2\", scope=Scope.SCENARIO, default_data=2)      output_dn_configs = [          Config.configure_data_node(f\"output{i}\", scope=Scope.SCENARIO, default_data=0) for i in range(nb_outputs)      ]      _DataManager._bulk_get_or_create({cfg for cfg in output_dn_configs})      name = name or \"\".join(random.choice(string.ascii_lowercase) for _ in range(10))      task_config = Config.configure_task(          id=name,          function=function,          input=[input1_dn_config, input2_dn_config],          output=output_dn_configs,      )      return _TaskManager._bulk_get_or_create([task_config])[0] "}
{"text": "import os    import pytest    from src.taipy.core.data._data_sql_repository import _DataSQLRepository  from src.taipy.core.exceptions import ModelNotFound  from src.taipy.core.job._job_fs_repository import _JobFSRepository  from src.taipy.core.job._job_sql_repository import _JobSQLRepository  from src.taipy.core.job.job import Job, JobId, Task  from src.taipy.core.task._task_sql_repository import _TaskSQLRepository      class TestJobRepository:      @pytest.mark.parametrize(\"repo\", [_JobFSRepository, _JobSQLRepository])      def test_save_and_load(self, data_node, job, repo, init_sql_repo):          _DataSQLRepository()._save(data_node)          task = Task(\"task_config_id\", {}, print, [data_node], [data_node])          _TaskSQLRepository()._save(task)          job._task = task            repository = repo()          repository._save(job)            obj = repository._load(job.id)          assert isinstance(obj, Job)        @pytest.mark.parametrize(\"repo\", [_JobFSRepository, _JobSQLRepository])      def test_exists(self, data_node, job, repo, init_sql_repo):          _DataSQLRepository()._save(data_node)          task = Task(\"task_config_id\", {}, print, [data_node], [data_node])          _TaskSQLRepository()._save(task)          job._task = task          repository = repo()          repository._save(job)            assert repository._exists(job.id)          assert not repository._exists(\"not-existed-job\")        @pytest.mark.parametrize(\"repo\", [_JobFSRepository, _JobSQLRepository])      def test_load_all(self, data_node, job, repo, init_sql_repo):          _DataSQLRepository()._save(data_node)          task = Task(\"task_config_id\", {}, print, [data_node], [data_node])          _TaskSQLRepository()._save(task)          job._task = task          repository = repo()          for i in range(10):              job.id = JobId(f\"job-{i}\")              repository._save(job)          jobs = repository._load_all()            assert len(jobs) == 10        @pytest.mark.parametrize(\"repo\", [_JobFSRepository, _JobSQLRepository])      def test_load_all_with_filters(self, data_node, job, repo, init_sql_repo):          repository = repo()          _DataSQLRepository()._save(data_node)          task = Task(\"task_config_id\", {}, print, [data_node], [data_node])          _TaskSQLRepository()._save(task)          job._task = task            for i in range(10):              job.id = JobId(f\"job-{i}\")              repository._save(job)          objs = repository._load_all(filters=[{\"id\": \"job-2\"}])            assert len(objs) == 1        @pytest.mark.parametrize(\"repo\", [_JobFSRepository, _JobSQLRepository])      def test_delete(self, data_node, job, repo, init_sql_repo):          repository = repo()          _DataSQLRepository()._save(data_node)          task = Task(\"task_config_id\", {}, print, [data_node], [data_node])          _TaskSQLRepository()._save(task)          job._task = task          repository._save(job)            repository._delete(job.id)            with pytest.raises(ModelNotFound):              repository._load(job.id)        @pytest.mark.parametrize(\"repo\", [_JobFSRepository, _JobSQLRepository])      def test_delete_all(self, data_node, job, repo, init_sql_repo):          repository = repo()          _DataSQLRepository()._save(data_node)          task = Task(\"task_config_id\", {}, print, [data_node], [data_node])          _TaskSQLRepository()._save(task)          job._task = task            for i in range(10):              job.id = JobId(f\"job-{i}\")              repository._save(job)            assert len(repository._load_all()) == 10            repository._delete_all()            assert len(repository._load_all()) == 0        @pytest.mark.parametrize(\"repo\", [_JobFSRepository, _JobSQLRepository])      def test_delete_many(self, data_node, job, repo, init_sql_repo):          repository = repo()          _DataSQLRepository()._save(data_node)          task = Task(\"task_config_id\", {}, print, [data_node], [data_node])          _TaskSQLRepository()._save(task)          job._task = task            for i in range(10):              job.id = JobId(f\"job-{i}\")              repository._save(job)            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\", [_JobFSRepository, _JobSQLRepository])      def test_delete_by(self, data_node, job, repo, init_sql_repo):          repository = repo()          _DataSQLRepository()._save(data_node)          task = Task(\"task_config_id\", {}, print, [data_node], [data_node])          _TaskSQLRepository()._save(task)          job._task = task            # Create 5 entities with version 1.0 and 5 entities with version 2.0          for i in range(10):              job.id = JobId(f\"job-{i}\")              job._version = f\"{(i+1) // 5}.0\"              repository._save(job)            objs = repository._load_all()          assert len(objs) == 10          repository._delete_by(\"version\", \"1.0\")            assert len(repository._load_all()) == 5        @pytest.mark.parametrize(\"repo\", [_JobFSRepository, _JobSQLRepository])      def test_search(self, data_node, job, repo, init_sql_repo):          repository = repo()          _DataSQLRepository()._save(data_node)          task = Task(\"task_config_id\", {}, print, [data_node], [data_node])          _TaskSQLRepository()._save(task)          job._task = task            for i in range(10):              job.id = JobId(f\"job-{i}\")              repository._save(job)            assert len(repository._load_all()) == 10            objs = repository._search(\"id\", \"job-2\")          assert len(objs) == 1          assert isinstance(objs[0], Job)            objs = repository._search(\"id\", \"job-2\", filters=[{\"version\": \"random_version_number\"}])          assert len(objs) == 1          assert isinstance(objs[0], Job)            assert repository._search(\"id\", \"job-2\", filters=[{\"version\": \"non_existed_version\"}]) == []        @pytest.mark.parametrize(\"repo\", [_JobFSRepository, _JobSQLRepository])      def test_export(self, tmpdir, job, repo, init_sql_repo):          repository = repo()          repository._save(job)            repository._export(job.id, tmpdir.strpath)          dir_path = repository.dir_path if repo == _JobFSRepository else os.path.join(tmpdir.strpath, \"job\")            assert os.path.exists(os.path.join(dir_path, f\"{job.id}.json\")) "}
{"text": "from unittest import mock    import pytest    from src.taipy.core.common._utils import _Subscriber  from src.taipy.core.data._data_manager_factory import _DataManagerFactory  from src.taipy.core.data.data_node import DataNode  from src.taipy.core.data.in_memory import InMemoryDataNode  from src.taipy.core.data.pickle import PickleDataNode  from src.taipy.core.scenario._scenario_manager import _ScenarioManager  from src.taipy.core.scenario.scenario import Scenario  from src.taipy.core.sequence._sequence_manager import _SequenceManager  from src.taipy.core.sequence.sequence import Sequence  from src.taipy.core.sequence.sequence_id import SequenceId  from src.taipy.core.task._task_manager import _TaskManager  from src.taipy.core.task.task import Task, TaskId  from taipy.config.common.scope import Scope      def test_create_sequence():      input = InMemoryDataNode(\"foo\", Scope.SCENARIO)      output = InMemoryDataNode(\"bar\", Scope.SCENARIO)      task = Task(\"baz\", {}, print, [input], [output], TaskId(\"task_id\"))        sequence = Sequence({\"description\": \"description\"}, [task], sequence_id=SequenceId(\"name_1\"))      assert sequence.id == \"name_1\"      assert sequence.owner_id is None      assert sequence.description == \"description\"      assert sequence.foo == input      assert sequence.bar == output      assert sequence.baz.id == task.id      assert sequence.tasks == {task.config_id: task}      assert sequence.data_nodes == {\"foo\": input, \"bar\": output}      assert sequence.parent_ids == set()      with pytest.raises(AttributeError):          sequence.qux      assert sequence.get_label() == sequence.id      assert sequence.get_simple_label() == sequence.id        input_1 = InMemoryDataNode(\"input\", Scope.SCENARIO)      output_1 = InMemoryDataNode(\"output\", Scope.SCENARIO)      task_1 = Task(\"task_1\", {}, print, [input_1], [output_1], TaskId(\"task_id_1\"))      sequence_1 = Sequence(          {\"description\": \"description\"},          [task_1],          owner_id=\"owner_id\",          parent_ids={\"scenario_id\"},          sequence_id=SequenceId(\"name_1\"),      )      assert sequence_1.id == \"name_1\"      assert sequence_1.owner_id == \"owner_id\"      assert sequence_1.description == \"description\"      assert sequence_1.input == input_1      assert sequence_1.output == output_1      assert sequence_1.task_1 == task_1      assert sequence_1.tasks == {task_1.config_id: task_1}      assert sequence_1.data_nodes == {\"input\": input_1, \"output\": output_1}      assert sequence_1.parent_ids == {\"scenario_id\"}      assert sequence_1.id is not None      with mock.patch(\"src.taipy.core.get\") as get_mck:            class MockOwner:              label = \"owner_label\"                def get_label(self):                  return self.label            get_mck.return_value = MockOwner()          assert sequence_1.get_label() == \"owner_label > \" + sequence_1.id          assert sequence_1.get_simple_label() == sequence_1.id        sequence_2 = Sequence(          {\"description\": \"description\", \"name\": \"Name\"},          [task, task_1],          owner_id=\"owner_id\",          parent_ids={\"parent_id_1\", \"parent_id_2\"},          sequence_id=SequenceId(\"name_2\"),      )      assert sequence_2.owner_id == \"owner_id\"      assert sequence_2.id == \"name_2\"      assert sequence_2.description == \"description\"      assert sequence_2.tasks == {task.config_id: task, task_1.config_id: task_1}      assert sequence_2.data_nodes == {\"foo\": input, \"bar\": output, \"input\": input_1, \"output\": output_1}      assert sequence_2.parent_ids == {\"parent_id_1\", \"parent_id_2\"}      with mock.patch(\"src.taipy.core.get\") as get_mck:            class MockOwner:              label = \"owner_label\"                def get_label(self):                  return self.label            get_mck.return_value = MockOwner()          assert sequence_2.get_label() == \"owner_label > \" + sequence_2.name          assert sequence_2.get_simple_label() == sequence_2.name      def test_check_consistency():      sequence_1 = Sequence({}, [], \"name_1\")      assert sequence_1._is_consistent()        input_2 = InMemoryDataNode(\"foo\", Scope.SCENARIO)      output_2 = InMemoryDataNode(\"bar\", Scope.SCENARIO)      task_2 = Task(\"tfoo\", {}, print, [input_2], [output_2], TaskId(\"task_id_2\"))      sequence_2 = Sequence({}, [task_2], \"name_2\")      assert sequence_2._is_consistent()        data_node_3 = InMemoryDataNode(\"foo\", Scope.SCENARIO)      task_3 = Task(\"tfoo\", {}, print, [data_node_3], [data_node_3], TaskId(\"task_id_3\"))      sequence_3 = Sequence({}, [task_3], \"name_3\")      assert not sequence_3._is_consistent()  # Not a dag        input_4 = InMemoryDataNode(\"foo\", Scope.SCENARIO)      output_4 = InMemoryDataNode(\"bar\", Scope.SCENARIO)      task_4_1 = Task(\"tfoo\", {}, print, [input_4], [output_4], TaskId(\"task_id_4_1\"))      task_4_2 = Task(\"tbar\", {}, print, [output_4], [input_4], TaskId(\"task_id_4_2\"))      sequence_4 = Sequence({}, [task_4_1, task_4_2], \"name_4\")      assert not sequence_4._is_consistent()  # Not a Dag        class FakeDataNode:          config_id = \"config_id_of_a_fake_dn\"        input_6 = DataNode(\"foo\", Scope.SCENARIO, \"input_id_5\")      output_6 = DataNode(\"bar\", Scope.SCENARIO, \"output_id_5\")      task_6_1 = Task(\"tfoo\", {}, print, [input_6], [output_6], TaskId(\"task_id_5_1\"))      task_6_2 = Task(\"tbar\", {}, print, [output_6], [FakeDataNode()], TaskId(\"task_id_5_2\"))      sequence_6 = Sequence({}, [task_6_1, task_6_2], \"name_5\")      assert not sequence_6._is_consistent()  # Not a DataNode        intermediate_7 = DataNode(\"foo\", Scope.SCENARIO, \"intermediate_id_7\")      output_7 = DataNode(\"bar\", Scope.SCENARIO, \"output_id_7\")      task_7_1 = Task(\"tfoo\", {}, print, [], [intermediate_7], TaskId(\"task_id_7_1\"))      task_7_2 = Task(\"tbar\", {}, print, [intermediate_7], [output_7], TaskId(\"task_id_7_2\"))      sequence_7 = Sequence({}, [task_7_1, task_7_2], \"name_7\")      assert sequence_7._is_consistent()        input_8 = DataNode(\"foo\", Scope.SCENARIO, \"output_id_8\")      intermediate_8 = DataNode(\"bar\", Scope.SCENARIO, \"intermediate_id_8\")      task_8_1 = Task(\"tfoo\", {}, print, [input_8], [intermediate_8], TaskId(\"task_id_8_1\"))      task_8_2 = Task(\"tbar\", {}, print, [intermediate_8], [], TaskId(\"task_id_8_2\"))      sequence_8 = Sequence({}, [task_8_1, task_8_2], \"name_8\")      assert sequence_8._is_consistent()        input_9_1 = DataNode(\"foo\", Scope.SCENARIO, \"input_id_9_1\")      output_9_1 = DataNode(\"bar\", Scope.SCENARIO, \"output_id_9_1\")      input_9_2 = DataNode(\"baz\", Scope.SCENARIO, \"input_id_9_2\")      output_9_2 = DataNode(\"qux\", Scope.SCENARIO, \"output_id_9_2\")      task_9_1 = Task(\"tfoo\", {}, print, [input_9_1], [output_9_1], TaskId(\"task_id_9_1\"))      task_9_2 = Task(\"tbar\", {}, print, [input_9_2], [output_9_2], TaskId(\"task_id_9_2\"))      sequence_9 = Sequence({}, [task_9_1, task_9_2], \"name_9\")      assert not sequence_9._is_consistent()  # Not connected        input_10_1 = DataNode(\"foo\", Scope.SCENARIO, \"output_id_10_1\")      intermediate_10_1 = DataNode(\"bar\", Scope.SCENARIO, \"intermediate_id_10_1\")      intermediate_10_2 = DataNode(\"baz\", Scope.SCENARIO, \"intermediate_id_10_2\")      output_10 = DataNode(\"qux\", Scope.SCENARIO, \"output_id_10\")      post_10 = DataNode(\"quux\", Scope.SCENARIO, \"post_id_10\")      task_10_1 = Task(\"tfoo\", {}, print, [input_10_1], [intermediate_10_1], TaskId(\"task_id_10_1\"))      task_10_2 = Task(\"tbar\", {}, print, [], [intermediate_10_2], TaskId(\"task_id_10_2\"))      task_10_3 = Task(\"tbaz\", {}, print, [intermediate_10_1, intermediate_10_2], [output_10], TaskId(\"task_id_10_3\"))      task_10_4 = Task(\"tqux\", {}, print, [output_10], [post_10], TaskId(\"task_id_10_4\"))      task_10_5 = Task(\"tquux\", {}, print, [output_10], [], TaskId(\"task_id_10_5\"))      sequence_10 = Sequence({}, [task_10_1, task_10_2, task_10_3, task_10_4, task_10_5], \"name_10\")      assert sequence_10._is_consistent()      def test_get_sorted_tasks():      def assert_equal(tasks_a, tasks_b) -> bool:          if len(tasks_a) != len(tasks_b):              return False          for i in range(len(tasks_a)):              task_a, task_b = tasks_a[i], tasks_b[i]              if isinstance(task_a, list) and isinstance(task_b, list):                  if not assert_equal(task_a, task_b):                      return False              elif isinstance(task_a, list) or isinstance(task_b, list):                  return False              else:                  index_task_b = tasks_b.index(task_a)                  if any([isinstance(task_b, list) for task_b in tasks_b[i : index_task_b + 1]]):                      return False          return True        data_node_1 = DataNode(\"foo\", Scope.SCENARIO, \"s1\")      data_node_2 = DataNode(\"bar\", Scope.SCENARIO, \"s2\")      data_node_3 = DataNode(\"baz\", Scope.SCENARIO, \"s3\")      data_node_4 = DataNode(\"qux\", Scope.SCENARIO, \"s4\")      data_node_5 = DataNode(\"quux\", Scope.SCENARIO, \"s5\")      data_node_6 = DataNode(\"quuz\", Scope.SCENARIO, \"s6\")      data_node_7 = DataNode(\"corge\", Scope.SCENARIO, \"s7\")      task_1 = Task(          \"grault\",          {},          print,          [data_node_1, data_node_2],          [data_node_3, data_node_4],          TaskId(\"t1\"),      )      task_2 = Task(\"garply\", {}, print, [data_node_3], [data_node_5], TaskId(\"t2\"))      task_3 = Task(\"waldo\", {}, print, [data_node_5, data_node_4], [data_node_6], TaskId(\"t3\"))      task_4 = Task(\"fred\", {}, print, [data_node_4], [data_node_7], TaskId(\"t4\"))      sequence = Sequence({}, [task_4, task_2, task_1, task_3], SequenceId(\"p1\"))      # s1 ---             ---> s3 ---> t2 ---> s5 ----      #       |           |                           |      #       |---> t1 ---|      -------------------------> t3 ---> s6      #       |           |      |      # s2 ---             ---> s4 ---> t4 ---> s7      assert assert_equal(sequence._get_sorted_tasks(), [[task_1], [task_2, task_4], [task_3]])        data_node_1 = DataNode(\"foo\", Scope.SCENARIO, \"s1\")      data_node_2 = DataNode(\"bar\", Scope.SCENARIO, \"s2\")      data_node_4 = DataNode(\"qux\", Scope.SCENARIO, \"s4\")      data_node_5 = DataNode(\"quux\", Scope.SCENARIO, \"s5\")      data_node_6 = DataNode(\"quuz\", Scope.SCENARIO, \"s6\")      data_node_7 = DataNode(\"corge\", Scope.SCENARIO, \"s7\")      task_1 = Task(          \"grault\",          {},          print,          [data_node_1, data_node_2],          [data_node_4],          TaskId(\"t1\"),      )      task_2 = Task(\"garply\", {}, print, None, [data_node_5], TaskId(\"t2\"))      task_3 = Task(\"waldo\", {}, print, [data_node_5, data_node_4], [data_node_6], TaskId(\"t3\"))      task_4 = Task(\"fred\", {}, print, [data_node_4], [data_node_7], TaskId(\"t4\"))      sequence = Sequence({}, [task_4, task_2, task_1, task_3], SequenceId(\"p1\"))      # s1 ---      t2 ---> s5 ------      #       |                     |      #       |---> t1 ---|      -----> t3 ---> s6      #       |           |      |      # s2 ---             ---> s4 ---> t4 ---> s7      assert assert_equal(sequence._get_sorted_tasks(), [[task_2, task_1], [task_4, task_3]])        data_node_1 = DataNode(\"foo\", Scope.SCENARIO, \"s1\")      data_node_2 = DataNode(\"bar\", Scope.SCENARIO, \"s2\")      data_node_4 = DataNode(\"qux\", Scope.SCENARIO, \"s4\")      data_node_5 = DataNode(\"quux\", Scope.SCENARIO, \"s5\")      data_node_6 = DataNode(\"quuz\", Scope.SCENARIO, \"s6\")      data_node_7 = DataNode(\"corge\", Scope.SCENARIO, \"s7\")      task_1 = Task(          \"grault\",          {},          print,          [data_node_1, data_node_2],          [data_node_4],          TaskId(\"t1\"),      )      task_2 = Task(\"garply\", {}, print, [data_node_6], [data_node_5], TaskId(\"t2\"))      task_3 = Task(\"waldo\", {}, print, [data_node_5, data_node_4], id=TaskId(\"t3\"))      task_4 = Task(\"fred\", {}, print, [data_node_4], [data_node_7], TaskId(\"t4\"))      sequence = Sequence({}, [task_4, task_2, task_1, task_3], SequenceId(\"p1\"))      # s1 ---      s6 ---> t2 ---> s5      #       |                     |      #       |---> t1 ---|      -----> t3      #       |           |      |      # s2 ---             ---> s4 ---> t4 ---> s7      assert assert_equal(sequence._get_sorted_tasks(), [[task_2, task_1], [task_4, task_3]])        data_node_1 = DataNode(\"foo\", Scope.SCENARIO, \"s1\")      data_node_2 = DataNode(\"bar\", Scope.SCENARIO, \"s2\")      data_node_4 = DataNode(\"qux\", Scope.SCENARIO, \"s4\")      data_node_5 = DataNode(\"quux\", Scope.SCENARIO, \"s5\")      data_node_6 = DataNode(\"quuz\", Scope.SCENARIO, \"s6\")      data_node_7 = DataNode(\"corge\", Scope.SCENARIO, \"s7\")      task_1 = Task(          \"grault\",          {},          print,          [data_node_1, data_node_2],          [data_node_4],          TaskId(\"t1\"),      )      task_2 = Task(\"garply\", {}, print, output=[data_node_5], id=TaskId(\"t2\"))      task_3 = Task(\"waldo\", {}, print, [data_node_5, data_node_4], None, id=TaskId(\"t3\"))      task_4 = Task(\"fred\", {}, print, [data_node_4], [data_node_7], TaskId(\"t4\"))      sequence = Sequence({}, [task_4, task_2, task_1, task_3], SequenceId(\"p1\"))      # s1 ---              t2 ---> s5      #       |                     |      #       |---> t1 ---|      -----> t3      #       |           |      |      # s2 ---             ---> s4 ---> t4 ---> s7      assert assert_equal(sequence._get_sorted_tasks(), [[task_2, task_1], [task_4, task_3]])        data_node_1 = DataNode(\"foo\", Scope.SCENARIO, \"s1\")      data_node_2 = DataNode(\"bar\", Scope.SCENARIO, \"s2\")      data_node_4 = DataNode(\"qux\", Scope.SCENARIO, \"s4\")      data_node_5 = DataNode(\"quux\", Scope.SCENARIO, \"s5\")      data_node_6 = DataNode(\"quuz\", Scope.SCENARIO, \"s6\")      data_node_7 = DataNode(\"corge\", Scope.SCENARIO, \"s7\")      data_node_8 = DataNode(\"hugh\", Scope.SCENARIO, \"s8\")        task_1 = Task(          \"grault\",          {},          print,          [data_node_1, data_node_2],          [data_node_4],          TaskId(\"t1\"),      )      task_2 = Task(\"garply\", {}, print, output=[data_node_5], id=TaskId(\"t2\"))      task_3 = Task(\"waldo\", {}, print, [data_node_4], None, id=TaskId(\"t3\"))      task_4 = Task(\"fred\", {}, print, [data_node_4], [data_node_7], TaskId(\"t4\"))      task_5 = Task(\"bob\", {}, print, [data_node_8], None, TaskId(\"t5\"))      sequence = Sequence({}, [task_5, task_4, task_2, task_1, task_3], SequenceId(\"p1\"))      # s1 ---      #       |      #       |---> t1 ---|      -----> t3      #       |           |      |      # s2 ---             ---> s4 ---> t4 ---> s7      # t2 ---> s5      # s8 ---> t5      assert assert_equal(sequence._get_sorted_tasks(), [[task_5, task_2, task_1], [task_4, task_3]])      def test_get_inputs():      data_node_1 = DataNode(\"foo\", Scope.SCENARIO, \"s1\")      data_node_2 = DataNode(\"bar\", Scope.SCENARIO, \"s2\")      data_node_3 = DataNode(\"baz\", Scope.SCENARIO, \"s3\")      data_node_4 = DataNode(\"qux\", Scope.SCENARIO, \"s4\")      data_node_5 = DataNode(\"quux\", Scope.SCENARIO, \"s5\")      data_node_6 = DataNode(\"quuz\", Scope.SCENARIO, \"s6\")      data_node_7 = DataNode(\"corge\", Scope.SCENARIO, \"s7\")      task_1 = Task(\"grault\", {}, print, [data_node_1, data_node_2], [data_node_3, data_node_4], TaskId(\"t1\"))      task_2 = Task(\"garply\", {}, print, [data_node_3], [data_node_5], TaskId(\"t2\"))      task_3 = Task(\"waldo\", {}, print, [data_node_5, data_node_4], [data_node_6], TaskId(\"t3\"))      task_4 = Task(\"fred\", {}, print, [data_node_4], [data_node_7], TaskId(\"t4\"))      sequence = Sequence({}, [task_4, task_2, task_1, task_3], SequenceId(\"p1\"))      # s1 ---             ---> s3 ---> t2 ---> s5 ----      #       |           |                           |      #       |---> t1 ---|      -------------------------> t3 ---> s6      #       |           |      |      # s2 ---             ---> s4 ---> t4 ---> s7      assert sequence.get_inputs() == {data_node_1, data_node_2}      assert sequence.get_outputs() == {data_node_6, data_node_7}      assert sequence.get_intermediate() == {data_node_3, data_node_4, data_node_5}        data_node_1 = DataNode(\"foo\", Scope.SCENARIO, \"s1\")      data_node_2 = DataNode(\"bar\", Scope.SCENARIO, \"s2\")      data_node_4 = DataNode(\"qux\", Scope.SCENARIO, \"s4\")      data_node_5 = DataNode(\"quux\", Scope.SCENARIO, \"s5\")      data_node_6 = DataNode(\"quuz\", Scope.SCENARIO, \"s6\")      data_node_7 = DataNode(\"corge\", Scope.SCENARIO, \"s7\")      task_1 = Task(\"grault\", {}, print, [data_node_1, data_node_2], [data_node_4], TaskId(\"t1\"))      task_2 = Task(\"garply\", {}, print, None, [data_node_5], TaskId(\"t2\"))      task_3 = Task(\"waldo\", {}, print, [data_node_5, data_node_4], [data_node_6], TaskId(\"t3\"))      task_4 = Task(\"fred\", {}, print, [data_node_4], [data_node_7], TaskId(\"t4\"))      sequence = Sequence({}, [task_4, task_2, task_1, task_3], SequenceId(\"p1\"))      # s1 ---      t2 ---> s5 ------      #       |                     |      #       |---> t1 ---|      -----> t3 ---> s6      #       |           |      |      # s2 ---             ---> s4 ---> t4 ---> s7      assert sequence.get_inputs() == {data_node_1, data_node_2}      assert sequence.get_outputs() == {data_node_6, data_node_7}      assert sequence.get_intermediate() == {data_node_4, data_node_5}        data_node_1 = DataNode(\"foo\", Scope.SCENARIO, \"s1\")      data_node_2 = DataNode(\"bar\", Scope.SCENARIO, \"s2\")      data_node_4 = DataNode(\"qux\", Scope.SCENARIO, \"s4\")      data_node_5 = DataNode(\"quux\", Scope.SCENARIO, \"s5\")      data_node_6 = DataNode(\"quuz\", Scope.SCENARIO, \"s6\")      data_node_7 = DataNode(\"corge\", Scope.SCENARIO, \"s7\")      task_1 = Task(\"grault\", {}, print, [data_node_1, data_node_2], [data_node_4], TaskId(\"t1\"))      task_2 = Task(\"garply\", {}, print, [data_node_6], [data_node_5], TaskId(\"t2\"))      task_3 = Task(\"waldo\", {}, print, [data_node_5, data_node_4], id=TaskId(\"t3\"))      task_4 = Task(\"fred\", {}, print, [data_node_4], [data_node_7], TaskId(\"t4\"))      sequence = Sequence({}, [task_4, task_2, task_1, task_3], SequenceId(\"p1\"))      # s1 ---      s6 ---> t2 ---> s5      #       |                     |      #       |---> t1 ---|      -----> t3      #       |           |      |      # s2 ---             ---> s4 ---> t4 ---> s7      assert sequence.get_inputs() == {data_node_1, data_node_2, data_node_6}      assert sequence.get_outputs() == {data_node_7}      assert sequence.get_intermediate() == {data_node_4, data_node_5}        data_node_1 = DataNode(\"foo\", Scope.SCENARIO, \"s1\")      data_node_2 = DataNode(\"bar\", Scope.SCENARIO, \"s2\")      data_node_4 = DataNode(\"qux\", Scope.SCENARIO, \"s4\")      data_node_5 = DataNode(\"quux\", Scope.SCENARIO, \"s5\")      data_node_6 = DataNode(\"quuz\", Scope.SCENARIO, \"s6\")      data_node_7 = DataNode(\"corge\", Scope.SCENARIO, \"s7\")      data_node_8 = DataNode(\"hugh\", Scope.SCENARIO, \"s8\")      task_1 = Task(\"grault\", {}, print, [data_node_1, data_node_2], [data_node_4], TaskId(\"t1\"))      task_2 = Task(\"garply\", {}, print, output=[data_node_5], id=TaskId(\"t2\"))      task_3 = Task(\"waldo\", {}, print, [data_node_4], None, id=TaskId(\"t3\"))      task_4 = Task(\"fred\", {}, print, [data_node_4, data_node_6], [data_node_7], TaskId(\"t4\"))      task_5 = Task(\"bob\", {}, print, [data_node_8], None, TaskId(\"t5\"))      sequence = Sequence({}, [task_5, task_4, task_2, task_1, task_3], SequenceId(\"p1\"))      # s1 ---      #       |      #       |---> t1 ---|      -----> t3      #       |           |      |      # s2 ---             ---> s4 ---> t4 ---> s7      # t2 ---> s5                   |      # s8 ---> t5              s6 --|      assert sequence.get_inputs() == {data_node_1, data_node_2, data_node_8, data_node_6}      assert sequence.get_outputs() == {data_node_5, data_node_7}      assert sequence.get_intermediate() == {data_node_4}      def test_is_ready_to_run():      data_node_1 = PickleDataNode(\"foo\", Scope.SCENARIO, \"s1\", properties={\"default_data\": 1})      data_node_2 = PickleDataNode(\"bar\", Scope.SCENARIO, \"s2\", properties={\"default_data\": 2})      data_node_4 = PickleDataNode(\"qux\", Scope.SCENARIO, \"s4\", properties={\"default_data\": 4})      data_node_5 = PickleDataNode(\"quux\", Scope.SCENARIO, \"s5\", properties={\"default_data\": 5})      data_node_6 = PickleDataNode(\"quuz\", Scope.SCENARIO, \"s6\", properties={\"default_data\": 6})      data_node_7 = PickleDataNode(\"corge\", Scope.SCENARIO, \"s7\", properties={\"default_data\": 7})      task_1 = Task(\"grault\", {}, print, [data_node_1, data_node_2], [data_node_4], TaskId(\"t1\"))      task_2 = Task(\"garply\", {}, print, [data_node_6], [data_node_5], TaskId(\"t2\"))      task_3 = Task(\"waldo\", {}, print, [data_node_5, data_node_4], id=TaskId(\"t3\"))      task_4 = Task(\"fred\", {}, print, [data_node_4], [data_node_7], TaskId(\"t4\"))      sequence = Sequence({}, [task_4, task_2, task_1, task_3], SequenceId(\"p1\"))      # s1 ---      s6 ---> t2 ---> s5      #       |                     |      #       |---> t1 ---|      -----> t3      #       |           |      |      # s2 ---             ---> s4 ---> t4 ---> s7        data_manager = _DataManagerFactory._build_manager()      for dn in [data_node_1, data_node_2, data_node_4, data_node_5, data_node_6, data_node_7]:          data_manager._set(dn)        assert sequence.is_ready_to_run()        data_node_1.edit_in_progress = True      assert not sequence.is_ready_to_run()        data_node_2.edit_in_progress = True      data_node_6.edit_in_progress = True      assert not sequence.is_ready_to_run()        data_node_1.edit_in_progress = False      data_node_2.edit_in_progress = False      data_node_6.edit_in_progress = False      assert sequence.is_ready_to_run()      def test_data_nodes_being_edited():      data_node_1 = PickleDataNode(\"foo\", Scope.SCENARIO, \"s1\", properties={\"default_data\": 1})      data_node_2 = PickleDataNode(\"bar\", Scope.SCENARIO, \"s2\", properties={\"default_data\": 2})      data_node_4 = PickleDataNode(\"qux\", Scope.SCENARIO, \"s4\", properties={\"default_data\": 4})      data_node_5 = PickleDataNode(\"quux\", Scope.SCENARIO, \"s5\", properties={\"default_data\": 5})      data_node_6 = PickleDataNode(\"quuz\", Scope.SCENARIO, \"s6\", properties={\"default_data\": 6})      data_node_7 = PickleDataNode(\"corge\", Scope.SCENARIO, \"s7\", properties={\"default_data\": 7})      task_1 = Task(\"grault\", {}, print, [data_node_1, data_node_2], [data_node_4], TaskId(\"t1\"))      task_2 = Task(\"garply\", {}, print, [data_node_6], [data_node_5], TaskId(\"t2\"))      task_3 = Task(\"waldo\", {}, print, [data_node_5, data_node_4], id=TaskId(\"t3\"))      task_4 = Task(\"fred\", {}, print, [data_node_4], [data_node_7], TaskId(\"t4\"))      sequence = Sequence({}, [task_4, task_2, task_1, task_3], SequenceId(\"p1\"))      # s1 ---      s6 ---> t2 ---> s5      #       |                     |      #       |---> t1 ---|      -----> t3      #       |           |      |      # s2 ---             ---> s4 ---> t4 ---> s7        data_manager = _DataManagerFactory._build_manager()      for dn in [data_node_1, data_node_2, data_node_4, data_node_5, data_node_6, data_node_7]:          data_manager._set(dn)        assert len(sequence.data_nodes_being_edited()) == 0      assert sequence.data_nodes_being_edited() == set()        data_node_1.edit_in_progress = True      assert len(sequence.data_nodes_being_edited()) == 1      assert sequence.data_nodes_being_edited() == {data_node_1}        data_node_2.edit_in_progress = True      data_node_6.edit_in_progress = True      assert len(sequence.data_nodes_being_edited()) == 3      assert sequence.data_nodes_being_edited() == {data_node_1, data_node_2, data_node_6}        data_node_4.edit_in_progress = True      data_node_5.edit_in_progress = True      assert len(sequence.data_nodes_being_edited()) == 5      assert sequence.data_nodes_being_edited() == {data_node_1, data_node_2, data_node_4, data_node_5, data_node_6}        data_node_1.edit_in_progress = False      data_node_2.edit_in_progress = False      data_node_6.edit_in_progress = False      assert len(sequence.data_nodes_being_edited()) == 2      assert sequence.data_nodes_being_edited() == {data_node_4, data_node_5}        data_node_4.edit_in_progress = False      data_node_5.edit_in_progress = False      data_node_7.edit_in_progress = True      assert len(sequence.data_nodes_being_edited()) == 1      assert sequence.data_nodes_being_edited() == {data_node_7}        data_node_7.edit_in_progress = False      assert len(sequence.data_nodes_being_edited()) == 0      assert sequence.data_nodes_being_edited() == set()      def test_get_tasks():      task_1 = Task(\"grault\", {}, print, id=TaskId(\"t1\"))      task_2 = Task(\"garply\", {}, print, id=TaskId(\"t2\"))      task_3 = Task(\"waldo\", {}, print, id=TaskId(\"t3\"))      sequence_1 = Sequence({}, [task_1, task_2, task_3], SequenceId(\"p1\"))      assert sequence_1.tasks == {\"grault\": task_1, \"garply\": task_2, \"waldo\": task_3}      def test_get_set_of_tasks():      task_1 = Task(\"grault\", {}, print, id=TaskId(\"t1\"))      task_2 = Task(\"garply\", {}, print, id=TaskId(\"t2\"))      task_3 = Task(\"waldo\", {}, print, id=TaskId(\"t3\"))      sequence_1 = Sequence({}, [task_1, task_2, task_3], SequenceId(\"p1\"))      assert sequence_1._get_set_of_tasks() == {task_1, task_2, task_3}      def test_auto_set_and_reload(task):      tmp_task = Task(\"tmp_task_config_id\", {}, print, list(task.output.values()), [], TaskId(\"tmp_task_id\"))      scenario = Scenario(\"scenario\", [task, tmp_task], {}, sequences={\"foo\": {}})        _TaskManager._set(task)      _TaskManager._set(tmp_task)      _ScenarioManager._set(scenario)        sequence_1 = scenario.sequences[\"foo\"]      sequence_2 = _SequenceManager._get(sequence_1)        # auto set & reload on tasks attribute      assert len(sequence_1.tasks) == 0      assert len(sequence_2.tasks) == 0      sequence_1.tasks = [tmp_task]      assert len(sequence_1.tasks) == 1      assert sequence_1.tasks[tmp_task.config_id].id == tmp_task.id      assert len(sequence_2.tasks) == 1      assert sequence_2.tasks[tmp_task.config_id].id == tmp_task.id      sequence_2.tasks = [task]      assert len(sequence_1.tasks) == 1      assert sequence_1.tasks[task.config_id].id == task.id      assert len(sequence_2.tasks) == 1      assert sequence_2.tasks[task.config_id].id == task.id        assert sequence_1.owner_id == scenario.id      assert sequence_2.owner_id == scenario.id        # auto set & reload on subscribers attribute      assert len(sequence_1.subscribers) == 0      assert len(sequence_2.subscribers) == 0      sequence_1.subscribers.append(print)      assert len(sequence_1.subscribers) == 1      assert len(sequence_2.subscribers) == 1      sequence_2.subscribers.append(print)      assert len(sequence_1.subscribers) == 2      assert len(sequence_2.subscribers) == 2        sequence_1.subscribers.clear()      assert len(sequence_1.subscribers) == 0      assert len(sequence_2.subscribers) == 0        sequence_1.subscribers.extend([print, map])      assert len(sequence_1.subscribers) == 2      assert len(sequence_2.subscribers) == 2        sequence_1.subscribers.remove(_Subscriber(print, []))      assert len(sequence_1.subscribers) == 1      assert len(sequence_2.subscribers) == 1        sequence_2.subscribers.clear()      assert len(sequence_1.subscribers) == 0      assert len(sequence_2.subscribers) == 0        sequence_1.subscribers + print + len      assert len(sequence_1.subscribers) == 2      assert len(sequence_2.subscribers) == 2        sequence_1.subscribers = []      assert len(sequence_1.subscribers) == 0      assert len(sequence_2.subscribers) == 0        # auto set & reload on properties attribute      assert sequence_1.properties == {\"name\": \"foo\"}      assert sequence_2.properties == {\"name\": \"foo\"}      sequence_1.properties[\"qux\"] = 4      assert sequence_1.properties[\"qux\"] == 4      assert sequence_2.properties[\"qux\"] == 4      sequence_2.properties[\"qux\"] = 5      assert sequence_1.properties[\"qux\"] == 5      assert sequence_2.properties[\"qux\"] == 5        sequence_1.properties[\"temp_key_1\"] = \"temp_value_1\"      sequence_1.properties[\"temp_key_2\"] = \"temp_value_2\"      assert sequence_1.properties == {          \"qux\": 5,          \"name\": \"foo\",          \"temp_key_1\": \"temp_value_1\",          \"temp_key_2\": \"temp_value_2\",      }      assert sequence_2.properties == {          \"qux\": 5,          \"name\": \"foo\",          \"temp_key_1\": \"temp_value_1\",          \"temp_key_2\": \"temp_value_2\",      }      sequence_1.properties.pop(\"temp_key_1\")      assert \"temp_key_1\" not in sequence_1.properties.keys()      assert \"temp_key_1\" not in sequence_1.properties.keys()      assert sequence_1.properties == {          \"qux\": 5,          \"name\": \"foo\",          \"temp_key_2\": \"temp_value_2\",      }      assert sequence_2.properties == {          \"qux\": 5,          \"name\": \"foo\",          \"temp_key_2\": \"temp_value_2\",      }      sequence_2.properties.pop(\"temp_key_2\")      assert sequence_1.properties == {\"name\": \"foo\", \"qux\": 5}      assert sequence_2.properties == {\"name\": \"foo\", \"qux\": 5}      assert \"temp_key_2\" not in sequence_1.properties.keys()      assert \"temp_key_2\" not in sequence_2.properties.keys()        sequence_1.properties[\"temp_key_3\"] = 0      assert sequence_1.properties == {\"name\": \"foo\", \"qux\": 5, \"temp_key_3\": 0}      assert sequence_2.properties == {\"name\": \"foo\", \"qux\": 5, \"temp_key_3\": 0}      sequence_1.properties.update({\"temp_key_3\": 1})      assert sequence_1.properties == {\"name\": \"foo\", \"qux\": 5, \"temp_key_3\": 1}      assert sequence_2.properties == {\"name\": \"foo\", \"qux\": 5, \"temp_key_3\": 1}      sequence_1.properties.update(dict())      assert sequence_1.properties == {\"name\": \"foo\", \"qux\": 5, \"temp_key_3\": 1}      assert sequence_2.properties == {\"name\": \"foo\", \"qux\": 5, \"temp_key_3\": 1}      sequence_1.properties[\"temp_key_4\"] = 0      sequence_1.properties[\"temp_key_5\"] = 0        with sequence_1 as sequence:          assert len(sequence.tasks) == 1          assert sequence.tasks[task.config_id].id == task.id          assert len(sequence.subscribers) == 0          assert sequence._is_in_context          assert sequence.properties[\"qux\"] == 5          assert sequence.properties[\"temp_key_3\"] == 1          assert sequence.properties[\"temp_key_4\"] == 0          assert sequence.properties[\"temp_key_5\"] == 0            sequence.tasks = []          sequence.subscribers = [print]          sequence.properties[\"qux\"] = 9          sequence.properties.pop(\"temp_key_3\")          sequence.properties.pop(\"temp_key_4\")          sequence.properties.update({\"temp_key_4\": 1})          sequence.properties.update({\"temp_key_5\": 2})          sequence.properties.pop(\"temp_key_5\")          sequence.properties.update(dict())            assert len(sequence.tasks) == 1          assert sequence.tasks[task.config_id].id == task.id          assert len(sequence.subscribers) == 0          assert sequence._is_in_context          assert sequence.properties[\"qux\"] == 5          assert sequence.properties[\"temp_key_3\"] == 1          assert sequence.properties[\"temp_key_4\"] == 0          assert sequence.properties[\"temp_key_5\"] == 0        assert len(sequence_1.tasks) == 0      assert len(sequence_1.subscribers) == 1      assert not sequence_1._is_in_context      assert sequence_1.properties[\"qux\"] == 9      assert \"temp_key_3\" not in sequence_1.properties.keys()      assert sequence_1.properties[\"temp_key_4\"] == 1      assert \"temp_key_5\" not in sequence_1.properties.keys()      def test_get_parents(sequence):      with mock.patch(\"src.taipy.core.get_parents\") as mck:          sequence.get_parents()          mck.assert_called_once_with(sequence)      def test_subscribe_sequence():      with mock.patch(\"src.taipy.core.subscribe_sequence\") as mck:          sequence = Sequence({}, [], \"id\")          sequence.subscribe(None)          mck.assert_called_once_with(None, None, sequence)      def test_unsubscribe_sequence():      with mock.patch(\"src.taipy.core.unsubscribe_sequence\") as mck:          sequence = Sequence({}, [], \"id\")          sequence.unsubscribe(None)          mck.assert_called_once_with(None, None, sequence)      def test_submit_sequence():      with mock.patch(\"src.taipy.core.sequence._sequence_manager._SequenceManager._submit\") as mck:          sequence = Sequence({}, [], \"id\")          sequence.submit(None, False)          mck.assert_called_once_with(sequence, None, False, False, None) "}
{"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": "import pytest    from src.taipy.core._orchestrator._orchestrator_factory import _OrchestratorFactory  from src.taipy.core._version._version_manager import _VersionManager  from src.taipy.core.config.job_config import JobConfig  from src.taipy.core.data._data_manager import _DataManager  from src.taipy.core.data.in_memory import InMemoryDataNode  from src.taipy.core.job._job_manager import _JobManager  from src.taipy.core.scenario._scenario_manager import _ScenarioManager  from src.taipy.core.scenario.scenario import Scenario  from src.taipy.core.sequence._sequence_manager import _SequenceManager  from src.taipy.core.sequence.sequence_id import SequenceId  from src.taipy.core.task._task_manager import _TaskManager  from src.taipy.core.task.task import Task  from src.taipy.core.task.task_id import TaskId  from taipy.config.common.scope import Scope  from taipy.config.config import Config  from tests.conftest import init_managers      def test_set_and_get_sequence(init_sql_repo):      Config.configure_job_executions(mode=JobConfig._DEVELOPMENT_MODE)        init_managers()      _OrchestratorFactory._build_dispatcher()        input_dn = InMemoryDataNode(\"foo\", Scope.SCENARIO)      output_dn = InMemoryDataNode(\"foo\", Scope.SCENARIO)      task = Task(\"task\", {}, print, [input_dn], [output_dn], TaskId(\"task_id\"))        scenario = Scenario(\"scenario\", {task}, {}, set())      _ScenarioManager._set(scenario)        sequence_name_1 = \"p1\"      sequence_id_1 = SequenceId(f\"SEQUENCE_{sequence_name_1}_{scenario.id}\")      sequence_name_2 = \"p2\"      sequence_id_2 = SequenceId(f\"SEQUENCE_{sequence_name_2}_{scenario.id}\")        # No existing Sequence      assert _SequenceManager._get(sequence_id_1) is None      assert _SequenceManager._get(sequence_id_2) is None        scenario.add_sequences({sequence_name_1: []})      sequence_1 = scenario.sequences[sequence_name_1]        # Save one sequence. We expect to have only one sequence stored      _SequenceManager._set(sequence_1)      assert _SequenceManager._get(sequence_id_1).id == sequence_1.id      assert len(_SequenceManager._get(sequence_id_1).tasks) == 0      assert _SequenceManager._get(sequence_1).id == sequence_1.id      assert len(_SequenceManager._get(sequence_1).tasks) == 0      assert _SequenceManager._get(sequence_id_2) is None        # Save a second sequence. Now, we expect to have a total of two sequences stored      _TaskManager._set(task)      scenario.add_sequences({sequence_name_2: [task]})      sequence_2 = scenario.sequences[sequence_name_2]      assert _SequenceManager._get(sequence_id_1).id == sequence_1.id      assert len(_SequenceManager._get(sequence_id_1).tasks) == 0      assert _SequenceManager._get(sequence_1).id == sequence_1.id      assert len(_SequenceManager._get(sequence_1).tasks) == 0      assert _SequenceManager._get(sequence_id_2).id == sequence_2.id      assert len(_SequenceManager._get(sequence_id_2).tasks) == 1      assert _SequenceManager._get(sequence_2).id == sequence_2.id      assert len(_SequenceManager._get(sequence_2).tasks) == 1        # We save the first sequence again. We expect nothing to change      scenario.add_sequences({sequence_name_1: {}})      sequence_1 = scenario.sequences[sequence_name_1]      assert _SequenceManager._get(sequence_id_1).id == sequence_1.id      assert len(_SequenceManager._get(sequence_id_1).tasks) == 0      assert _SequenceManager._get(sequence_1).id == sequence_1.id      assert len(_SequenceManager._get(sequence_1).tasks) == 0      assert _SequenceManager._get(sequence_id_2).id == sequence_2.id      assert len(_SequenceManager._get(sequence_id_2).tasks) == 1      assert _SequenceManager._get(sequence_2).id == sequence_2.id      assert len(_SequenceManager._get(sequence_2).tasks) == 1        # We save a third sequence with same id as the first one.      # We expect the first sequence to be updated      scenario.add_sequences({sequence_name_1: [task]})      sequence_3 = scenario.sequences[sequence_name_1]      assert _SequenceManager._get(sequence_id_1).id == sequence_1.id      assert _SequenceManager._get(sequence_id_1).id == sequence_3.id      assert len(_SequenceManager._get(sequence_id_1).tasks) == 1      assert _SequenceManager._get(sequence_1).id == sequence_1.id      assert len(_SequenceManager._get(sequence_1).tasks) == 1      assert _SequenceManager._get(sequence_id_2).id == sequence_2.id      assert len(_SequenceManager._get(sequence_id_2).tasks) == 1      assert _SequenceManager._get(sequence_2).id == sequence_2.id      assert len(_SequenceManager._get(sequence_2).tasks) == 1      assert _TaskManager._get(task.id).id == task.id      def test_get_all_on_multiple_versions_environment(init_sql_repo):      init_managers()        # Create 5 sequences from Scenario with 2 versions each      for version in range(1, 3):          for i in range(5):              _ScenarioManager._set(                  Scenario(                      f\"config_id_{i+version}\",                      [],                      {},                      [],                      f\"SCENARIO_id_{i}_v{version}\",                      version=f\"{version}.0\",                      sequences={\"sequence\": {}},                  )              )        _VersionManager._set_experiment_version(\"1.0\")      assert len(_SequenceManager._get_all()) == 5      assert (          len(_SequenceManager._get_all_by(filters=[{\"version\": \"1.0\", \"id\": \"SEQUENCE_sequence_SCENARIO_id_1_v1\"}])) == 1      )      assert (          len(_SequenceManager._get_all_by(filters=[{\"version\": \"2.0\", \"id\": \"SEQUENCE_sequence_SCENARIO_id_1_v1\"}])) == 0      )        _VersionManager._set_experiment_version(\"2.0\")      assert len(_SequenceManager._get_all()) == 5      assert (          len(_SequenceManager._get_all_by(filters=[{\"version\": \"2.0\", \"id\": \"SEQUENCE_sequence_SCENARIO_id_1_v1\"}])) == 0      )      assert (          len(_SequenceManager._get_all_by(filters=[{\"version\": \"2.0\", \"id\": \"SEQUENCE_sequence_SCENARIO_id_1_v2\"}])) == 1      )        _VersionManager._set_development_version(\"1.0\")      assert len(_SequenceManager._get_all()) == 5      assert (          len(_SequenceManager._get_all_by(filters=[{\"version\": \"1.0\", \"id\": \"SEQUENCE_sequence_SCENARIO_id_1_v1\"}])) == 1      )      assert (          len(_SequenceManager._get_all_by(filters=[{\"version\": \"1.0\", \"id\": \"SEQUENCE_sequence_SCENARIO_id_1_v2\"}])) == 0      )        _VersionManager._set_development_version(\"2.0\")      assert len(_SequenceManager._get_all()) == 5      assert (          len(_SequenceManager._get_all_by(filters=[{\"version\": \"2.0\", \"id\": \"SEQUENCE_sequence_SCENARIO_id_1_v1\"}])) == 0      )      assert (          len(_SequenceManager._get_all_by(filters=[{\"version\": \"2.0\", \"id\": \"SEQUENCE_sequence_SCENARIO_id_1_v2\"}])) == 1      )      def mult_by_two(nb: int):      return nb * 2      def mult_by_3(nb: int):      return nb * 3      def test_get_or_create_data(init_sql_repo):      # only create intermediate data node once      Config.configure_job_executions(mode=JobConfig._DEVELOPMENT_MODE)        init_managers()        dn_config_1 = Config.configure_data_node(\"foo\", \"in_memory\", Scope.SCENARIO, default_data=1)      dn_config_2 = Config.configure_data_node(\"bar\", \"in_memory\", Scope.SCENARIO, default_data=0)      dn_config_6 = Config.configure_data_node(\"baz\", \"in_memory\", Scope.SCENARIO, default_data=0)        task_config_mult_by_two = Config.configure_task(\"mult_by_two\", mult_by_two, [dn_config_1], dn_config_2)      task_config_mult_by_3 = Config.configure_task(\"mult_by_3\", mult_by_3, [dn_config_2], dn_config_6)      # dn_1 ---> mult_by_two ---> dn_2 ---> mult_by_3 ---> dn_6      scenario_config = Config.configure_scenario(\"scenario\", [task_config_mult_by_two, task_config_mult_by_3])        _OrchestratorFactory._build_dispatcher()        assert len(_DataManager._get_all()) == 0      assert len(_TaskManager._get_all()) == 0        scenario = _ScenarioManager._create(scenario_config)      scenario.add_sequences({\"by_6\": list(scenario.tasks.values())})      sequence = scenario.sequences[\"by_6\"]        assert sequence.name == \"by_6\"        assert len(_DataManager._get_all()) == 3      assert len(_TaskManager._get_all()) == 2      assert len(sequence._get_sorted_tasks()) == 2      assert sequence.foo.read() == 1      assert sequence.bar.read() == 0      assert sequence.baz.read() == 0      assert sequence._get_sorted_tasks()[0][0].config_id == task_config_mult_by_two.id      assert sequence._get_sorted_tasks()[1][0].config_id == task_config_mult_by_3.id        _SequenceManager._submit(sequence.id)      assert sequence.foo.read() == 1      assert sequence.bar.read() == 2      assert sequence.baz.read() == 6        sequence.foo.write(\"new data value\")      assert sequence.foo.read() == \"new data value\"      assert sequence.bar.read() == 2      assert sequence.baz.read() == 6        sequence.bar.write(7)      assert sequence.foo.read() == \"new data value\"      assert sequence.bar.read() == 7      assert sequence.baz.read() == 6        with pytest.raises(AttributeError):          sequence.WRONG.write(7)      def test_hard_delete_one_single_sequence_with_scenario_data_nodes(init_sql_repo):      Config.configure_job_executions(mode=JobConfig._DEVELOPMENT_MODE)        init_managers()        dn_input_config = Config.configure_data_node(\"my_input\", \"in_memory\", scope=Scope.SCENARIO, default_data=\"testing\")      dn_output_config = Config.configure_data_node(\"my_output\", \"in_memory\", scope=Scope.SCENARIO)      task_config = Config.configure_task(\"task_config\", print, dn_input_config, dn_output_config)        _OrchestratorFactory._build_dispatcher()        tasks = _TaskManager._bulk_get_or_create([task_config])      scenario = Scenario(\"scenario\", set(tasks), {}, sequences={\"sequence\": {\"tasks\": tasks}})      _ScenarioManager._set(scenario)        sequence = scenario.sequences[\"sequence\"]      sequence.submit()        assert len(_ScenarioManager._get_all()) == 1      assert len(_SequenceManager._get_all()) == 1      assert len(_TaskManager._get_all()) == 1      assert len(_DataManager._get_all()) == 2      assert len(_JobManager._get_all()) == 1      _SequenceManager._hard_delete(sequence.id)      assert len(_ScenarioManager._get_all()) == 1      assert len(_SequenceManager._get_all()) == 0      assert len(_TaskManager._get_all()) == 1      assert len(_DataManager._get_all()) == 2      assert len(_JobManager._get_all()) == 1      def test_hard_delete_one_single_sequence_with_cycle_data_nodes(init_sql_repo):      Config.configure_job_executions(mode=JobConfig._DEVELOPMENT_MODE)        init_managers()        dn_input_config = Config.configure_data_node(\"my_input\", \"in_memory\", scope=Scope.CYCLE, default_data=\"testing\")      dn_output_config = Config.configure_data_node(\"my_output\", \"in_memory\", scope=Scope.CYCLE)      task_config = Config.configure_task(\"task_config\", print, dn_input_config, dn_output_config)        _OrchestratorFactory._build_dispatcher()        tasks = _TaskManager._bulk_get_or_create([task_config])      scenario = Scenario(\"scenario\", tasks, {}, sequences={\"sequence\": {\"tasks\": tasks}})      _ScenarioManager._set(scenario)        sequence = scenario.sequences[\"sequence\"]      sequence.submit()        assert len(_ScenarioManager._get_all()) == 1      assert len(_SequenceManager._get_all()) == 1      assert len(_TaskManager._get_all()) == 1      assert len(_DataManager._get_all()) == 2      assert len(_JobManager._get_all()) == 1      _SequenceManager._hard_delete(sequence.id)      assert len(_ScenarioManager._get_all()) == 1      assert len(_SequenceManager._get_all()) == 0      assert len(_TaskManager._get_all()) == 1      assert len(_DataManager._get_all()) == 2      assert len(_JobManager._get_all()) == 1      def test_hard_delete_shared_entities(init_sql_repo):      Config.configure_job_executions(mode=JobConfig._DEVELOPMENT_MODE)        init_managers()        input_dn = Config.configure_data_node(\"my_input\", \"in_memory\", scope=Scope.SCENARIO, default_data=\"testing\")      intermediate_dn = Config.configure_data_node(\"my_inter\", \"in_memory\", scope=Scope.GLOBAL, default_data=\"testing\")      output_dn = Config.configure_data_node(\"my_output\", \"in_memory\", scope=Scope.GLOBAL, default_data=\"testing\")      task_1 = Config.configure_task(\"task_1\", print, input_dn, intermediate_dn)      task_2 = Config.configure_task(\"task_2\", print, intermediate_dn, output_dn)        _OrchestratorFactory._build_dispatcher()        tasks_scenario_1 = _TaskManager._bulk_get_or_create([task_1, task_2], scenario_id=\"scenario_id_1\")      tasks_scenario_2 = _TaskManager._bulk_get_or_create([task_1, task_2], scenario_id=\"scenario_id_2\")        scenario_1 = Scenario(\"scenario_1\", tasks_scenario_1, {}, sequences={\"sequence\": {\"tasks\": tasks_scenario_1}})      scenario_2 = Scenario(\"scenario_2\", tasks_scenario_2, {}, sequences={\"sequence\": {\"tasks\": tasks_scenario_2}})      _ScenarioManager._set(scenario_1)      _ScenarioManager._set(scenario_2)      sequence_1 = scenario_1.sequences[\"sequence\"]      sequence_2 = scenario_2.sequences[\"sequence\"]        _SequenceManager._submit(sequence_1.id)      _SequenceManager._submit(sequence_2.id)        assert len(_ScenarioManager._get_all()) == 2      assert len(_SequenceManager._get_all()) == 2      assert len(_TaskManager._get_all()) == 3      assert len(_DataManager._get_all()) == 4      assert len(_JobManager._get_all()) == 4      _SequenceManager._hard_delete(sequence_1.id)      assert len(_ScenarioManager._get_all()) == 2      assert len(_SequenceManager._get_all()) == 1      assert len(_TaskManager._get_all()) == 3      assert len(_DataManager._get_all()) == 4      assert len(_JobManager._get_all()) == 4 "}
{"text": "import json  from pathlib import Path  from typing import Callable, Iterable, Optional  from unittest import mock  from unittest.mock import ANY    import pytest    from src.taipy.core._orchestrator._orchestrator import _Orchestrator  from src.taipy.core._orchestrator._orchestrator_factory import _OrchestratorFactory  from src.taipy.core._version._version_manager import _VersionManager  from src.taipy.core.common import _utils  from src.taipy.core.common._utils import _Subscriber  from src.taipy.core.config.job_config import JobConfig  from src.taipy.core.data._data_manager import _DataManager  from src.taipy.core.data.in_memory import InMemoryDataNode  from src.taipy.core.exceptions.exceptions import (      InvalidSequenceId,      ModelNotFound,      NonExistingSequence,      NonExistingTask,      SequenceBelongsToNonExistingScenario,  )  from src.taipy.core.job._job_manager import _JobManager  from src.taipy.core.scenario._scenario_manager import _ScenarioManager  from src.taipy.core.scenario.scenario import Scenario  from src.taipy.core.sequence._sequence_manager import _SequenceManager  from src.taipy.core.sequence._sequence_manager_factory import _SequenceManagerFactory  from src.taipy.core.sequence.sequence import Sequence  from src.taipy.core.sequence.sequence_id import SequenceId  from src.taipy.core.task._task_manager import _TaskManager  from src.taipy.core.task.task import Task  from src.taipy.core.task.task_id import TaskId  from taipy.config.common.scope import Scope  from taipy.config.config import Config  from tests.core.utils.NotifyMock import NotifyMock      def test_breakdown_sequence_id():      with pytest.raises(InvalidSequenceId):          _SequenceManager._breakdown_sequence_id(\"scenario_id\")      with pytest.raises(InvalidSequenceId):          _SequenceManager._breakdown_sequence_id(\"sequence_id\")      with pytest.raises(InvalidSequenceId):          _SequenceManager._breakdown_sequence_id(\"SEQUENCE_sequence_id\")      with pytest.raises(InvalidSequenceId):          _SequenceManager._breakdown_sequence_id(\"SCENARIO_scenario_id\")      with pytest.raises(InvalidSequenceId):          _SequenceManager._breakdown_sequence_id(\"sequence_SCENARIO_scenario_id\")      with pytest.raises(InvalidSequenceId):          _SequenceManager._breakdown_sequence_id(\"SEQUENCE_sequence_scenario_id\")      sequence_name, scenario_id = _SequenceManager._breakdown_sequence_id(\"SEQUENCE_sequence_SCENARIO_scenario\")      assert sequence_name == \"sequence\" and scenario_id == \"SCENARIO_scenario\"      sequence_name, scenario_id = _SequenceManager._breakdown_sequence_id(\"SEQUENCEsequenceSCENARIO_scenario\")      assert sequence_name == \"sequence\" and scenario_id == \"SCENARIO_scenario\"      def test_raise_sequence_does_not_belong_to_scenario():      with pytest.raises(SequenceBelongsToNonExistingScenario):          sequence = Sequence({\"name\": \"sequence_name\"}, [], \"SEQUENCE_sequence_name_SCENARIO_scenario_id\")          _SequenceManager._set(sequence)      def __init():      Config.configure_job_executions(mode=JobConfig._DEVELOPMENT_MODE)      _OrchestratorFactory._build_dispatcher()      input_dn = InMemoryDataNode(\"foo\", Scope.SCENARIO)      output_dn = InMemoryDataNode(\"foo\", Scope.SCENARIO)      task = Task(\"task\", {}, print, [input_dn], [output_dn], TaskId(\"task_id\"))      scenario = Scenario(\"scenario\", set([task]), {}, set())      _ScenarioManager._set(scenario)      return scenario, task      def test_set_and_get_sequence_no_existing_sequence():      scenario, task = __init()      sequence_name_1 = \"p1\"      sequence_id_1 = SequenceId(f\"SEQUENCE_{sequence_name_1}_{scenario.id}\")      sequence_name_2 = \"p2\"      sequence_id_2 = SequenceId(f\"SEQUENCE_{sequence_name_2}_{scenario.id}\")        assert _SequenceManager._get(sequence_id_1) is None      assert _SequenceManager._get(sequence_id_2) is None      assert _SequenceManager._get(\"sequence\") is None      def test_set_and_get():      scenario, task = __init()      sequence_name_1 = \"p1\"      sequence_id_1 = SequenceId(f\"SEQUENCE_{sequence_name_1}_{scenario.id}\")      sequence_name_2 = \"p2\"      sequence_id_2 = SequenceId(f\"SEQUENCE_{sequence_name_2}_{scenario.id}\")        scenario.add_sequences({sequence_name_1: []})      sequence_1 = scenario.sequences[sequence_name_1]      assert _SequenceManager._get(sequence_id_1).id == sequence_1.id      assert len(_SequenceManager._get(sequence_id_1).tasks) == 0      assert _SequenceManager._get(sequence_1).id == sequence_1.id      assert len(_SequenceManager._get(sequence_1).tasks) == 0      assert _SequenceManager._get(sequence_id_2) is None        # Save a second sequence. Now, we expect to have a total of two sequences stored      _TaskManager._set(task)      scenario.add_sequences({sequence_name_2: [task]})      sequence_2 = scenario.sequences[sequence_name_2]      assert _SequenceManager._get(sequence_id_1).id == sequence_1.id      assert len(_SequenceManager._get(sequence_id_1).tasks) == 0      assert _SequenceManager._get(sequence_1).id == sequence_1.id      assert len(_SequenceManager._get(sequence_1).tasks) == 0      assert _SequenceManager._get(sequence_id_2).id == sequence_2.id      assert len(_SequenceManager._get(sequence_id_2).tasks) == 1      assert _SequenceManager._get(sequence_2).id == sequence_2.id      assert len(_SequenceManager._get(sequence_2).tasks) == 1      assert _TaskManager._get(task.id).id == task.id        # We save the first sequence again. We expect nothing to change      scenario.add_sequence(sequence_name_1, [])      sequence_1 = scenario.sequences[sequence_name_1]      assert _SequenceManager._get(sequence_id_1).id == sequence_1.id      assert len(_SequenceManager._get(sequence_id_1).tasks) == 0      assert _SequenceManager._get(sequence_1).id == sequence_1.id      assert len(_SequenceManager._get(sequence_1).tasks) == 0      assert _SequenceManager._get(sequence_id_2).id == sequence_2.id      assert len(_SequenceManager._get(sequence_id_2).tasks) == 1      assert _SequenceManager._get(sequence_2).id == sequence_2.id      assert len(_SequenceManager._get(sequence_2).tasks) == 1      assert _TaskManager._get(task.id).id == task.id        # We save a third sequence with same name as the first one.      # We expect the first sequence to be updated      scenario.add_sequences({sequence_name_1: [task]})      sequence_3 = scenario.sequences[sequence_name_1]      assert _SequenceManager._get(sequence_id_1).id == sequence_1.id      assert _SequenceManager._get(sequence_id_1).id == sequence_3.id      assert len(_SequenceManager._get(sequence_id_1).tasks) == 1      assert _SequenceManager._get(sequence_1).id == sequence_1.id      assert len(_SequenceManager._get(sequence_1).tasks) == 1      assert _SequenceManager._get(sequence_id_2).id == sequence_2.id      assert len(_SequenceManager._get(sequence_id_2).tasks) == 1      assert _SequenceManager._get(sequence_2).id == sequence_2.id      assert len(_SequenceManager._get(sequence_2).tasks) == 1      assert _TaskManager._get(task.id).id == task.id      def test_get_all_on_multiple_versions_environment():      # Create 5 sequences from Scenario with 2 versions each      for version in range(1, 3):          for i in range(5):              _ScenarioManager._set(                  Scenario(                      f\"config_id_{i+version}\",                      [],                      {},                      [],                      f\"SCENARIO_id_{i}_v{version}\",                      version=f\"{version}.0\",                      sequences={\"sequence\": {}},                  )              )        _VersionManager._set_experiment_version(\"1.0\")      assert len(_SequenceManager._get_all()) == 5      assert (          len(_SequenceManager._get_all_by(filters=[{\"version\": \"1.0\", \"id\": \"SEQUENCE_sequence_SCENARIO_id_1_v1\"}])) == 1      )      assert (          len(_SequenceManager._get_all_by(filters=[{\"version\": \"2.0\", \"id\": \"SEQUENCE_sequence_SCENARIO_id_1_v1\"}])) == 0      )        _VersionManager._set_experiment_version(\"2.0\")      assert len(_SequenceManager._get_all()) == 5      assert (          len(_SequenceManager._get_all_by(filters=[{\"version\": \"2.0\", \"id\": \"SEQUENCE_sequence_SCENARIO_id_1_v1\"}])) == 0      )      assert (          len(_SequenceManager._get_all_by(filters=[{\"version\": \"2.0\", \"id\": \"SEQUENCE_sequence_SCENARIO_id_1_v2\"}])) == 1      )        _VersionManager._set_development_version(\"1.0\")      assert len(_SequenceManager._get_all()) == 5      assert (          len(_SequenceManager._get_all_by(filters=[{\"version\": \"1.0\", \"id\": \"SEQUENCE_sequence_SCENARIO_id_1_v1\"}])) == 1      )      assert (          len(_SequenceManager._get_all_by(filters=[{\"version\": \"1.0\", \"id\": \"SEQUENCE_sequence_SCENARIO_id_1_v2\"}])) == 0      )        _VersionManager._set_development_version(\"2.0\")      assert len(_SequenceManager._get_all()) == 5      assert (          len(_SequenceManager._get_all_by(filters=[{\"version\": \"2.0\", \"id\": \"SEQUENCE_sequence_SCENARIO_id_1_v1\"}])) == 0      )      assert (          len(_SequenceManager._get_all_by(filters=[{\"version\": \"2.0\", \"id\": \"SEQUENCE_sequence_SCENARIO_id_1_v2\"}])) == 1      )      def test_is_submittable():      dn = InMemoryDataNode(\"dn\", Scope.SCENARIO, properties={\"default_data\": 10})      task = Task(\"task\", {}, print, [dn])      scenario = Scenario(\"scenario\", set([task]), {}, set())      _ScenarioManager._set(scenario)        scenario.add_sequences({\"sequence\": list([task])})      sequence = scenario.sequences[\"sequence\"]        assert len(_SequenceManager._get_all()) == 1      assert _SequenceManager._is_submittable(sequence)      assert _SequenceManager._is_submittable(sequence.id)      assert not _SequenceManager._is_submittable(\"Sequence_temp\")      assert not _SequenceManager._is_submittable(\"SEQUENCE_temp_SCENARIO_scenario\")        scenario.dn.edit_in_progress = True      assert not _SequenceManager._is_submittable(sequence)      assert not _SequenceManager._is_submittable(sequence.id)        scenario.dn.edit_in_progress = False      assert _SequenceManager._is_submittable(sequence)      assert _SequenceManager._is_submittable(sequence.id)      def test_submit():      Config.configure_job_executions(mode=JobConfig._DEVELOPMENT_MODE)      _OrchestratorFactory._build_dispatcher()        data_node_1 = InMemoryDataNode(\"foo\", Scope.SCENARIO, \"s1\")      data_node_2 = InMemoryDataNode(\"bar\", Scope.SCENARIO, \"s2\")      data_node_3 = InMemoryDataNode(\"baz\", Scope.SCENARIO, \"s3\")      data_node_4 = InMemoryDataNode(\"qux\", Scope.SCENARIO, \"s4\")      data_node_5 = InMemoryDataNode(\"quux\", Scope.SCENARIO, \"s5\")      data_node_6 = InMemoryDataNode(\"quuz\", Scope.SCENARIO, \"s6\")      data_node_7 = InMemoryDataNode(\"corge\", Scope.SCENARIO, \"s7\")      task_1 = Task(          \"grault\",          {},          print,          [data_node_1, data_node_2],          [data_node_3, data_node_4],          TaskId(\"t1\"),      )      task_2 = Task(\"garply\", {}, print, [data_node_3], [data_node_5], TaskId(\"t2\"))      task_3 = Task(\"waldo\", {}, print, [data_node_5, data_node_4], [data_node_6], TaskId(\"t3\"))      task_4 = Task(\"fred\", {}, print, [data_node_4], [data_node_7], TaskId(\"t4\"))      scenario = Scenario(\"sce\", {task_1, task_2, task_3, task_4}, {})        sequence_name = \"sequence\"      sequence_id = Sequence._new_id(sequence_name, scenario.id)        class MockOrchestrator(_Orchestrator):          submit_calls = []            @classmethod          def _lock_dn_output_and_create_job(              cls,              task: Task,              submit_id: str,              submit_entity_id: str,              callbacks: Optional[Iterable[Callable]] = None,              force: bool = False,          ):              cls.submit_calls.append(task)              return super()._lock_dn_output_and_create_job(task, submit_id, submit_entity_id, callbacks, force)        with mock.patch(\"src.taipy.core.task._task_manager._TaskManager._orchestrator\", new=MockOrchestrator):          # sequence does not exists. We expect an exception to be raised          with pytest.raises(NonExistingSequence):              _SequenceManager._submit(sequence_id)            _ScenarioManager._set(scenario)          scenario.add_sequences({sequence_name: [task_4, task_2, task_1, task_3]})            # sequence, and tasks does exist. We expect the tasks to be submitted          # in a specific order          _TaskManager._set(task_1)          _TaskManager._set(task_2)          _TaskManager._set(task_3)          _TaskManager._set(task_4)          sequence = scenario.sequences[sequence_name]            _SequenceManager._submit(sequence.id)          calls_ids = [t.id for t in _TaskManager._orchestrator().submit_calls]          tasks_ids = [task_1.id, task_2.id, task_4.id, task_3.id]          assert calls_ids == tasks_ids            _SequenceManager._submit(sequence)          calls_ids = [t.id for t in _TaskManager._orchestrator().submit_calls]          tasks_ids = tasks_ids * 2          assert set(calls_ids) == set(tasks_ids)      def test_assign_sequence_as_parent_of_task():      dn_config_1 = Config.configure_data_node(\"dn_1\", \"in_memory\", scope=Scope.SCENARIO)      dn_config_2 = Config.configure_data_node(\"dn_2\", \"in_memory\", scope=Scope.SCENARIO)      dn_config_3 = Config.configure_data_node(\"dn_3\", \"in_memory\", scope=Scope.SCENARIO)      task_config_1 = Config.configure_task(\"task_1\", print, [dn_config_1], [dn_config_2])      task_config_2 = Config.configure_task(\"task_2\", print, [dn_config_2], [dn_config_3])      task_config_3 = Config.configure_task(\"task_3\", print, [dn_config_2], [dn_config_3])        tasks = _TaskManager._bulk_get_or_create([task_config_1, task_config_2, task_config_3], \"scenario_id\")      sequence_1 = _SequenceManager._create(\"sequence_1\", [tasks[0], tasks[1]], scenario_id=\"scenario_id\")      sequence_2 = _SequenceManager._create(\"sequence_2\", [tasks[0], tasks[2]], scenario_id=\"scenario_id\")        tasks_1 = list(sequence_1.tasks.values())      tasks_2 = list(sequence_2.tasks.values())        assert len(tasks_1) == 2      assert len(tasks_2) == 2        assert tasks_1[0].parent_ids == {sequence_1.id, sequence_2.id}      assert tasks_2[0].parent_ids == {sequence_1.id, sequence_2.id}      assert tasks_1[1].parent_ids == {sequence_1.id}      assert tasks_2[1].parent_ids == {sequence_2.id}      g = 0      def mock_function_no_input_no_output():      global g      g += 1      def mock_function_one_input_no_output(inp):      global g      g += inp      def mock_function_no_input_one_output():      global g      return g      def test_submit_sequence_from_tasks_with_one_or_no_input_output():      Config.configure_job_executions(mode=JobConfig._DEVELOPMENT_MODE)      _OrchestratorFactory._build_dispatcher()        # test no input and no output Task      task_no_input_no_output = Task(\"task_no_input_no_output\", {}, mock_function_no_input_no_output)      scenario_1 = Scenario(\"scenario_1\", {task_no_input_no_output}, {})        _TaskManager._set(task_no_input_no_output)      _ScenarioManager._set(scenario_1)        scenario_1.add_sequences({\"my_sequence_1\": [task_no_input_no_output]})      sequence_1 = scenario_1.sequences[\"my_sequence_1\"]        assert len(sequence_1._get_sorted_tasks()) == 1        _SequenceManager._submit(sequence_1)      assert g == 1        # test one input and no output Task      data_node_input = InMemoryDataNode(\"input_dn\", Scope.SCENARIO, properties={\"default_data\": 2})      task_one_input_no_output = Task(          \"task_one_input_no_output\", {}, mock_function_one_input_no_output, input=[data_node_input]      )      scenario_2 = Scenario(\"scenario_2\", {task_one_input_no_output}, {})        _DataManager._set(data_node_input)      data_node_input.unlock_edit()        _TaskManager._set(task_one_input_no_output)      _ScenarioManager._set(scenario_2)        scenario_2.add_sequences({\"my_sequence_2\": [task_one_input_no_output]})      sequence_2 = scenario_2.sequences[\"my_sequence_2\"]      assert len(sequence_2._get_sorted_tasks()) == 1        _SequenceManager._submit(sequence_2)      assert g == 3        # test no input and one output Task      data_node_output = InMemoryDataNode(\"output_dn\", Scope.SCENARIO, properties={\"default_data\": None})      task_no_input_one_output = Task(          \"task_no_input_one_output\", {}, mock_function_no_input_one_output, output=[data_node_output]      )      scenario_3 = Scenario(\"scenario_3\", {task_no_input_one_output}, {})        _DataManager._set(data_node_output)      assert data_node_output.read() is None      _TaskManager._set(task_no_input_one_output)      _ScenarioManager._set(scenario_3)        scenario_3.add_sequences({\"my_sequence_3\": [task_no_input_one_output]})      sequence_3 = scenario_3.sequences[\"my_sequence_3\"]        assert len(sequence_2._get_sorted_tasks()) == 1        _SequenceManager._submit(sequence_3)      assert data_node_output.read() == 3      def mult_by_two(nb: int):      return nb * 2      def mult_by_3(nb: int):      return nb * 3      def test_get_or_create_data():      # only create intermediate data node once      Config.configure_job_executions(mode=JobConfig._DEVELOPMENT_MODE)        dn_config_1 = Config.configure_data_node(\"foo\", \"in_memory\", Scope.SCENARIO, default_data=1)      dn_config_2 = Config.configure_data_node(\"bar\", \"in_memory\", Scope.SCENARIO, default_data=0)      dn_config_6 = Config.configure_data_node(\"baz\", \"in_memory\", Scope.SCENARIO, default_data=0)        task_config_mult_by_two = Config.configure_task(\"mult_by_two\", mult_by_two, [dn_config_1], dn_config_2)      task_config_mult_by_3 = Config.configure_task(\"mult_by_3\", mult_by_3, [dn_config_2], dn_config_6)      # dn_1 ---> mult_by_two ---> dn_2 ---> mult_by_3 ---> dn_6      scenario_config = Config.configure_scenario(\"scenario\", [task_config_mult_by_two, task_config_mult_by_3])        _OrchestratorFactory._build_dispatcher()        assert len(_DataManager._get_all()) == 0      assert len(_TaskManager._get_all()) == 0        scenario = _ScenarioManager._create(scenario_config)      scenario.add_sequences({\"by_6\": list(scenario.tasks.values())})      sequence = scenario.sequences[\"by_6\"]        assert sequence.name == \"by_6\"        assert len(_DataManager._get_all()) == 3      assert len(_TaskManager._get_all()) == 2      assert len(sequence._get_sorted_tasks()) == 2      assert sequence.foo.read() == 1      assert sequence.bar.read() == 0      assert sequence.baz.read() == 0      assert sequence._get_sorted_tasks()[0][0].config_id == task_config_mult_by_two.id      assert sequence._get_sorted_tasks()[1][0].config_id == task_config_mult_by_3.id        _SequenceManager._submit(sequence.id)      assert sequence.foo.read() == 1      assert sequence.bar.read() == 2      assert sequence.baz.read() == 6        sequence.foo.write(\"new data value\")      assert sequence.foo.read() == \"new data value\"      assert sequence.bar.read() == 2      assert sequence.baz.read() == 6        sequence.bar.write(7)      assert sequence.foo.read() == \"new data value\"      assert sequence.bar.read() == 7      assert sequence.baz.read() == 6        with pytest.raises(AttributeError):          sequence.WRONG.write(7)      def notify1(*args, **kwargs):      ...      def notify2(*args, **kwargs):      ...      def notify_multi_param(*args, **kwargs):      ...      def test_sequence_notification_subscribe(mocker):      Config.configure_job_executions(mode=JobConfig._DEVELOPMENT_MODE)        mocker.patch(\"src.taipy.core._entity._reload._Reloader._reload\", side_effect=lambda m, o: o)        task_configs = [          Config.configure_task(              \"mult_by_two\",              mult_by_two,              [Config.configure_data_node(\"foo\", \"in_memory\", Scope.SCENARIO, default_data=1)],              Config.configure_data_node(\"bar\", \"in_memory\", Scope.SCENARIO, default_data=0),          )      ]        _OrchestratorFactory._build_dispatcher()        tasks = _TaskManager._bulk_get_or_create(task_configs=task_configs)      scenario = Scenario(\"scenario\", set(tasks), {}, sequences={\"by_1\": {\"tasks\": tasks}})      _ScenarioManager._set(scenario)        sequence = scenario.sequences[\"by_1\"]        notify_1 = NotifyMock(sequence)      notify_1.__name__ = \"notify_1\"      notify_1.__module__ = \"notify_1\"      notify_2 = NotifyMock(sequence)      notify_2.__name__ = \"notify_2\"      notify_2.__module__ = \"notify_2\"      # Mocking this because NotifyMock is a class that does not loads correctly when getting the sequence      # from the storage.      mocker.patch.object(_utils, \"_load_fct\", side_effect=[notify_1, notify_1, notify_2, notify_2, notify_2, notify_2])        # test subscription      callback = mock.MagicMock()      _SequenceManager._submit(sequence.id, [callback])      callback.assert_called()        # test sequence subscribe notification      _SequenceManager._subscribe(callback=notify_1, sequence=sequence)      _SequenceManager._submit(sequence.id)        notify_1.assert_called_3_times()      notify_1.reset()        # test sequence unsubscribe notification      # test subscribe notification only on new job      _SequenceManager._unsubscribe(callback=notify_1, sequence=sequence)      _SequenceManager._subscribe(callback=notify_2, sequence=sequence)      _SequenceManager._submit(sequence)        notify_1.assert_not_called()      notify_2.assert_called_3_times()      def test_sequence_notification_subscribe_multi_param(mocker):      Config.configure_job_executions(mode=JobConfig._DEVELOPMENT_MODE)        mocker.patch(\"src.taipy.core._entity._reload._Reloader._reload\", side_effect=lambda m, o: o)        task_configs = [          Config.configure_task(              \"mult_by_two\",              mult_by_two,              [Config.configure_data_node(\"foo\", \"in_memory\", Scope.SCENARIO, default_data=1)],              Config.configure_data_node(\"bar\", \"in_memory\", Scope.SCENARIO, default_data=0),          )      ]        _OrchestratorFactory._build_dispatcher()        tasks = _TaskManager._bulk_get_or_create(task_configs)      scenario = Scenario(\"scenario\", set(tasks), {}, sequences={\"by_6\": {\"tasks\": tasks}})      _ScenarioManager._set(scenario)        sequence = scenario.sequences[\"by_6\"]      notify = mocker.Mock()        # test sequence subscribe notification      _SequenceManager._subscribe(callback=notify, params=[\"foobar\", 123, 1.2], sequence=sequence)      mocker.patch.object(_SequenceManager, \"_get\", return_value=sequence)        _SequenceManager._submit(sequence.id)        # as the callback is called with Sequence/Scenario and Job objects      # we can assert that is called with params plus a sequence object that we know      # of and a job object that is represented by ANY in this case      notify.assert_called_with(\"foobar\", 123, 1.2, sequence, ANY)      def test_sequence_notification_unsubscribe(mocker):      Config.configure_job_executions(mode=JobConfig._DEVELOPMENT_MODE)        mocker.patch(\"src.taipy.core._entity._reload._Reloader._reload\", side_effect=lambda m, o: o)        task_configs = [          Config.configure_task(              \"mult_by_two\",              mult_by_two,              [Config.configure_data_node(\"foo\", \"in_memory\", Scope.SCENARIO, default_data=1)],              Config.configure_data_node(\"bar\", \"in_memory\", Scope.SCENARIO, default_data=0),          )      ]        _OrchestratorFactory._build_dispatcher()        tasks = _TaskManager._bulk_get_or_create(task_configs)      scenario = Scenario(\"scenario\", set(tasks), {}, sequences={\"by_6\": {\"tasks\": tasks}})      _ScenarioManager._set(scenario)        sequence = scenario.sequences[\"by_6\"]        notify_1 = notify1      notify_2 = notify2        _SequenceManager._subscribe(callback=notify_1, sequence=sequence)      _SequenceManager._unsubscribe(callback=notify_1, sequence=sequence)      _SequenceManager._subscribe(callback=notify_2, sequence=sequence)      _SequenceManager._submit(sequence.id)        with pytest.raises(ValueError):          _SequenceManager._unsubscribe(callback=notify_1, sequence=sequence)          _SequenceManager._unsubscribe(callback=notify_2, sequence=sequence)      def test_sequence_notification_unsubscribe_multi_param():      Config.configure_job_executions(mode=JobConfig._DEVELOPMENT_MODE)        task_configs = [          Config.configure_task(              \"mult_by_two\",              mult_by_two,              [Config.configure_data_node(\"foo\", \"in_memory\", Scope.SCENARIO, default_data=1)],              Config.configure_data_node(\"bar\", \"in_memory\", Scope.SCENARIO, default_data=0),          )      ]        _OrchestratorFactory._build_dispatcher()        tasks = _TaskManager._bulk_get_or_create(task_configs)      scenario = Scenario(\"scenario\", tasks, {}, sequences={\"by_6\": {\"tasks\": tasks}})      _ScenarioManager._set(scenario)        sequence = scenario.sequences[\"by_6\"]        _SequenceManager._subscribe(callback=notify_multi_param, params=[\"foobar\", 123, 0], sequence=sequence)      _SequenceManager._subscribe(callback=notify_multi_param, params=[\"foobar\", 123, 1], sequence=sequence)      _SequenceManager._subscribe(callback=notify_multi_param, params=[\"foobar\", 123, 2], sequence=sequence)        assert len(sequence.subscribers) == 3        sequence.unsubscribe(notify_multi_param)      assert len(sequence.subscribers) == 2      assert _Subscriber(notify_multi_param, [\"foobar\", 123, 0]) not in sequence.subscribers        sequence.unsubscribe(notify_multi_param, [\"foobar\", 123, 2])      assert len(sequence.subscribers) == 1      assert _Subscriber(notify_multi_param, [\"foobar\", 123, 2]) not in sequence.subscribers        with pytest.raises(ValueError):          sequence.unsubscribe(notify_multi_param, [\"foobar\", 123, 10000])      def test_sequence_notification_subscribe_all():      Config.configure_job_executions(mode=JobConfig._DEVELOPMENT_MODE)        task_configs = [          Config.configure_task(              \"mult_by_two\",              mult_by_two,              [Config.configure_data_node(\"foo\", \"in_memory\", Scope.SCENARIO, default_data=1)],              Config.configure_data_node(\"bar\", \"in_memory\", Scope.SCENARIO, default_data=0),          )      ]        _OrchestratorFactory._build_dispatcher()        tasks = _TaskManager._bulk_get_or_create(task_configs)      scenario = Scenario(\"scenario\", tasks, {}, sequences={\"by_6\": {\"tasks\": tasks}, \"other_sequence\": {\"tasks\": tasks}})      _ScenarioManager._set(scenario)        sequence = scenario.sequences[\"by_6\"]      other_sequence = scenario.sequences[\"other_sequence\"]        notify_1 = NotifyMock(sequence)        _SequenceManager._subscribe(notify_1)        assert len(_SequenceManager._get(sequence.id).subscribers) == 1      assert len(_SequenceManager._get(other_sequence.id).subscribers) == 1      def test_delete():      sequence_id = \"SEQUENCE_sequence_SCENARIO_scenario_id_1\"      with pytest.raises(ModelNotFound):          _SequenceManager._delete(sequence_id)        scenario_1 = Scenario(\"scenario_1\", [], {}, scenario_id=\"SCENARIO_scenario_id_1\")      scenario_2 = Scenario(\"scenario_2\", [], {}, scenario_id=\"SCENARIO_scenario_id_2\")      _ScenarioManager._set(scenario_1)      _ScenarioManager._set(scenario_2)      with pytest.raises(ModelNotFound):          _SequenceManager._delete(sequence_id)        scenario_1.add_sequences({\"sequence\": {}})      assert len(_SequenceManager._get_all()) == 1      _SequenceManager._delete(sequence_id)      assert len(_SequenceManager._get_all()) == 0        scenario_1.add_sequences({\"sequence\": {}, \"sequence_1\": {}})      assert len(_SequenceManager._get_all()) == 2      _SequenceManager._delete(sequence_id)      assert len(_SequenceManager._get_all()) == 1        scenario_1.add_sequences({\"sequence_1\": {}, \"sequence_2\": {}, \"sequence_3\": {}})      scenario_2.add_sequences({\"sequence_1_2\": {}, \"sequence_2_2\": {}})      assert len(_SequenceManager._get_all()) == 5      _SequenceManager._delete_all()      assert len(_SequenceManager._get_all()) == 0        scenario_1.add_sequences({\"sequence_1\": {}, \"sequence_2\": {}, \"sequence_3\": {}, \"sequence_4\": {}})      scenario_2.add_sequences({\"sequence_1_2\": {}, \"sequence_2_2\": {}})      assert len(_SequenceManager._get_all()) == 6      _SequenceManager._delete_many(          [              \"SEQUENCE_sequence_1_SCENARIO_scenario_id_1\",              \"SEQUENCE_sequence_2_SCENARIO_scenario_id_1\",              \"SEQUENCE_sequence_1_2_SCENARIO_scenario_id_2\",          ]      )      assert len(_SequenceManager._get_all()) == 3        with pytest.raises(ModelNotFound):          _SequenceManager._delete_many(              [\"SEQUENCE_sequence_1_SCENARIO_scenario_id_1\", \"SEQUENCE_sequence_2_SCENARIO_scenario_id_1\"]          )      def test_delete_version():      scenario_1_0 = Scenario(          \"scenario_config\",          [],          {},          scenario_id=\"SCENARIO_id_1_v1_0\",          version=\"1.0\",          sequences={\"sequence_1\": {}, \"sequence_2\": {}},      )      scenario_1_1 = Scenario(          \"scenario_config\",          [],          {},          scenario_id=\"SCENARIO_id_1_v1_1\",          version=\"1.1\",          sequences={\"sequence_1\": {}, \"sequence_2\": {}},      )      _ScenarioManager._set(scenario_1_0)      _ScenarioManager._set(scenario_1_1)        _VersionManager._set_experiment_version(\"1.1\")      assert len(_ScenarioManager._get_all()) == 1      assert len(_SequenceManager._get_all()) == 2        _VersionManager._set_experiment_version(\"1.0\")      assert len(_ScenarioManager._get_all()) == 1      assert len(_SequenceManager._get_all()) == 2        _SequenceManager._delete_by_version(\"1.0\")      assert len(_ScenarioManager._get_all()) == 1      assert len(_SequenceManager._get_all()) == 0      assert len(scenario_1_0.sequences) == 0      assert len(scenario_1_1.sequences) == 2        _VersionManager._set_experiment_version(\"1.1\")      assert len(_ScenarioManager._get_all()) == 1      assert len(_SequenceManager._get_all()) == 2      assert len(scenario_1_0.sequences) == 0      assert len(scenario_1_1.sequences) == 2      _SequenceManager._delete_by_version(\"1.1\")      assert len(_ScenarioManager._get_all()) == 1      assert len(_SequenceManager._get_all()) == 0      def test_exists():      scenario = Scenario(\"scenario\", [], {}, scenario_id=\"SCENARIO_scenario\", sequences={\"sequence\": {}})      _ScenarioManager._set(scenario)      assert len(_ScenarioManager._get_all()) == 1      assert len(_SequenceManager._get_all()) == 1      assert not _SequenceManager._exists(\"SEQUENCE_sequence_not_exist_SCENARIO_scenario\")      assert not _SequenceManager._exists(\"SEQUENCE_sequence_SCENARIO_scenario_id\")      assert _SequenceManager._exists(\"SEQUENCE_sequence_SCENARIO_scenario\")      assert _SequenceManager._exists(scenario.sequences[\"sequence\"])      def test_export(tmpdir_factory):      path = tmpdir_factory.mktemp(\"data\")      task = Task(\"task\", {}, print, id=TaskId(\"task_id\"))      scenario = Scenario(          \"scenario\",          set([task]),          {},          set(),          version=\"1.0\",          sequences={\"sequence_1\": {}, \"sequence_2\": {\"tasks\": [task], \"properties\": {\"xyz\": \"acb\"}}},      )      _TaskManager._set(task)      _ScenarioManager._set(scenario)        sequence_1 = scenario.sequences[\"sequence_1\"]      sequence_2 = scenario.sequences[\"sequence_2\"]        _SequenceManager._export(sequence_1.id, Path(path))      export_sequence_json_file_path = f\"{path}/sequences/{sequence_1.id}.json\"      with open(export_sequence_json_file_path, \"rb\") as f:          sequence_json_file = json.load(f)          expected_json = {              \"id\": sequence_1.id,              \"owner_id\": scenario.id,              \"parent_ids\": [scenario.id],              \"name\": \"sequence_1\",              \"tasks\": [],              \"properties\": {},              \"subscribers\": [],          }          assert expected_json == sequence_json_file        _SequenceManager._export(sequence_2.id, Path(path))      export_sequence_json_file_path = f\"{path}/sequences/{sequence_2.id}.json\"      with open(export_sequence_json_file_path, \"rb\") as f:          sequence_json_file = json.load(f)          expected_json = {              \"id\": sequence_2.id,              \"owner_id\": scenario.id,              \"parent_ids\": [scenario.id],              \"name\": \"sequence_2\",              \"tasks\": [task.id],              \"properties\": {\"xyz\": \"acb\"},              \"subscribers\": [],          }          assert expected_json == sequence_json_file      def test_hard_delete_one_single_sequence_with_scenario_data_nodes():      Config.configure_job_executions(mode=JobConfig._DEVELOPMENT_MODE)        dn_input_config = Config.configure_data_node(\"my_input\", \"in_memory\", scope=Scope.SCENARIO, default_data=\"testing\")      dn_output_config = Config.configure_data_node(\"my_output\", \"in_memory\", scope=Scope.SCENARIO)      task_config = Config.configure_task(\"task_config\", print, dn_input_config, dn_output_config)        _OrchestratorFactory._build_dispatcher()        tasks = _TaskManager._bulk_get_or_create([task_config])      scenario = Scenario(\"scenario\", tasks, {}, sequences={\"sequence\": {\"tasks\": tasks}})      _ScenarioManager._set(scenario)        sequence = scenario.sequences[\"sequence\"]      sequence.submit()        assert len(_ScenarioManager._get_all()) == 1      assert len(_SequenceManager._get_all()) == 1      assert len(_TaskManager._get_all()) == 1      assert len(_DataManager._get_all()) == 2      assert len(_JobManager._get_all()) == 1      _SequenceManager._hard_delete(sequence.id)      assert len(_ScenarioManager._get_all()) == 1      assert len(_SequenceManager._get_all()) == 0      assert len(_TaskManager._get_all()) == 1      assert len(_DataManager._get_all()) == 2      assert len(_JobManager._get_all()) == 1      def test_hard_delete_one_single_sequence_with_cycle_data_nodes():      Config.configure_job_executions(mode=JobConfig._DEVELOPMENT_MODE)        dn_input_config = Config.configure_data_node(\"my_input\", \"in_memory\", scope=Scope.CYCLE, default_data=\"testing\")      dn_output_config = Config.configure_data_node(\"my_output\", \"in_memory\", scope=Scope.CYCLE)      task_config = Config.configure_task(\"task_config\", print, dn_input_config, dn_output_config)        _OrchestratorFactory._build_dispatcher()        tasks = _TaskManager._bulk_get_or_create([task_config])      scenario = Scenario(\"scenario\", tasks, {}, sequences={\"sequence\": {\"tasks\": tasks}})      _ScenarioManager._set(scenario)        sequence = scenario.sequences[\"sequence\"]      sequence.submit()        assert len(_ScenarioManager._get_all()) == 1      assert len(_SequenceManager._get_all()) == 1      assert len(_TaskManager._get_all()) == 1      assert len(_DataManager._get_all()) == 2      assert len(_JobManager._get_all()) == 1      _SequenceManager._hard_delete(sequence.id)      assert len(_ScenarioManager._get_all()) == 1      assert len(_SequenceManager._get_all()) == 0      assert len(_TaskManager._get_all()) == 1      assert len(_DataManager._get_all()) == 2      assert len(_JobManager._get_all()) == 1      def test_hard_delete_shared_entities():      Config.configure_job_executions(mode=JobConfig._DEVELOPMENT_MODE)        input_dn = Config.configure_data_node(\"my_input\", \"in_memory\", scope=Scope.SCENARIO, default_data=\"testing\")      intermediate_dn = Config.configure_data_node(\"my_inter\", \"in_memory\", scope=Scope.GLOBAL, default_data=\"testing\")      output_dn = Config.configure_data_node(\"my_output\", \"in_memory\", scope=Scope.GLOBAL, default_data=\"testing\")      task_1 = Config.configure_task(\"task_1\", print, input_dn, intermediate_dn)      task_2 = Config.configure_task(\"task_2\", print, intermediate_dn, output_dn)        _OrchestratorFactory._build_dispatcher()        tasks_scenario_1 = _TaskManager._bulk_get_or_create([task_1, task_2], scenario_id=\"scenario_id_1\")      tasks_scenario_2 = _TaskManager._bulk_get_or_create([task_1, task_2], scenario_id=\"scenario_id_2\")        scenario_1 = Scenario(\"scenario_1\", tasks_scenario_1, {}, sequences={\"sequence\": {\"tasks\": tasks_scenario_1}})      scenario_2 = Scenario(\"scenario_2\", tasks_scenario_2, {}, sequences={\"sequence\": {\"tasks\": tasks_scenario_2}})      _ScenarioManager._set(scenario_1)      _ScenarioManager._set(scenario_2)      sequence_1 = scenario_1.sequences[\"sequence\"]      sequence_2 = scenario_2.sequences[\"sequence\"]        _SequenceManager._submit(sequence_1.id)      _SequenceManager._submit(sequence_2.id)        assert len(_ScenarioManager._get_all()) == 2      assert len(_SequenceManager._get_all()) == 2      assert len(_TaskManager._get_all()) == 3      assert len(_DataManager._get_all()) == 4      assert len(_JobManager._get_all()) == 4      _SequenceManager._hard_delete(sequence_1.id)      assert len(_ScenarioManager._get_all()) == 2      assert len(_SequenceManager._get_all()) == 1      assert len(_TaskManager._get_all()) == 3      assert len(_DataManager._get_all()) == 4      assert len(_JobManager._get_all()) == 4      def my_print(a, b):      print(a + b)      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\")      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\")      json_dn_cfg = Config.configure_parquet_data_node(\"wrong_json_file_path\", default_path=\"wrong_path.json\")      task_cfg = Config.configure_task(\"task\", my_print, [csv_dn_cfg, pickle_dn_cfg], parquet_dn_cfg)      task_2_cfg = Config.configure_task(\"task2\", my_print, [csv_dn_cfg, parquet_dn_cfg], json_dn_cfg)        tasks = _TaskManager._bulk_get_or_create([task_cfg, task_2_cfg])      scenario = Scenario(\"scenario\", tasks, {}, sequences={\"sequence\": {\"tasks\": tasks}})      _ScenarioManager._set(scenario)      sequence = scenario.sequences[\"sequence\"]        pip_manager = _SequenceManagerFactory._build_manager()      pip_manager._submit(sequence)        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 sequence.get_inputs()      ]      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 sequence.data_nodes.values()          if input_dn not in sequence.get_inputs()      ]      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_one_input_dn_wrong_file_path(caplog):      csv_dn_cfg = Config.configure_csv_data_node(\"wrong_csv_file_path\", default_path=\"wrong_path.csv\")      pickle_dn_cfg = Config.configure_pickle_data_node(\"wrong_pickle_file_path\", default_data=\"value\")      parquet_dn_cfg = Config.configure_parquet_data_node(\"wrong_parquet_file_path\", default_path=\"wrong_path.parquet\")      json_dn_cfg = Config.configure_parquet_data_node(\"wrong_json_file_path\", default_path=\"wrong_path.json\")      task_cfg = Config.configure_task(\"task\", my_print, [csv_dn_cfg, pickle_dn_cfg], parquet_dn_cfg)      task_2_cfg = Config.configure_task(\"task2\", my_print, [csv_dn_cfg, parquet_dn_cfg], json_dn_cfg)        tasks = _TaskManager._bulk_get_or_create([task_cfg, task_2_cfg])      scenario = Scenario(\"scenario\", tasks, {}, sequences={\"sequence\": {\"tasks\": tasks}})      _ScenarioManager._set(scenario)      sequence = scenario.sequences[\"sequence\"]        pip_manager = _SequenceManagerFactory._build_manager()      pip_manager._submit(sequence)        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 sequence.get_inputs()          if input_dn.config_id == \"wrong_csv_file_path\"      ]      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 sequence.data_nodes.values()          if input_dn.config_id != \"wrong_csv_file_path\"      ]      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]) "}
{"text": "import datetime  import json  import os  import pathlib  from dataclasses import dataclass  from enum import Enum  from time import sleep    import numpy as np  import pandas as pd  import pytest    from src.taipy.core.data._data_manager import _DataManager  from src.taipy.core.data.data_node_id import DataNodeId  from src.taipy.core.data.json import JSONDataNode  from src.taipy.core.data.operator import JoinOperator, Operator  from src.taipy.core.exceptions.exceptions import NoData  from taipy.config.common.scope import Scope  from taipy.config.config import Config  from taipy.config.exceptions.exceptions import InvalidConfigurationId      @pytest.fixture(scope=\"function\", autouse=True)  def cleanup():      yield      path = os.path.join(pathlib.Path(__file__).parent.resolve(), \"data_sample/temp.json\")      if os.path.isfile(path):          os.remove(path)      class MyCustomObject:      def __init__(self, id, integer, text):          self.id = id          self.integer = integer          self.text = text      class MyCustomObject2:      def __init__(self, id, boolean, text):          self.id = id          self.boolean = boolean          self.text = text      class MyEnum(Enum):      A = 1      B = 2      C = 3      @dataclass  class CustomDataclass:      integer: int      string: str      class MyCustomEncoder(json.JSONEncoder):      def default(self, o):          if isinstance(o, MyCustomObject):              return {\"__type__\": \"MyCustomObject\", \"id\": o.id, \"integer\": o.integer, \"text\": o.text}          return super().default(self, o)      class MyCustomDecoder(json.JSONDecoder):      def __init__(self, *args, **kwargs):          super().__init__(object_hook=self.object_hook, *args, **kwargs)        def object_hook(self, o):          if o.get(\"__type__\") == \"MyCustomObject\":              return MyCustomObject(o[\"id\"], o[\"integer\"], o[\"text\"])          else:              return o      class TestJSONDataNode:      def test_create(self):          path = \"data/node/path\"          dn = JSONDataNode(\"foo_bar\", Scope.SCENARIO, properties={\"default_path\": path, \"name\": \"super name\"})          assert isinstance(dn, JSONDataNode)          assert dn.storage_type() == \"json\"          assert dn.config_id == \"foo_bar\"          assert dn.name == \"super name\"          assert dn.scope == Scope.SCENARIO          assert dn.id is not None          assert dn.owner_id is None          assert dn.last_edit_date is None          assert dn.job_ids == []          assert not dn.is_ready_for_reading          assert dn.path == path            with pytest.raises(InvalidConfigurationId):              dn = JSONDataNode(                  \"foo bar\", Scope.SCENARIO, properties={\"default_path\": path, \"has_header\": False, \"name\": \"super name\"}              )        def test_get_user_properties(self, json_file):          dn_1 = JSONDataNode(\"dn_1\", Scope.SCENARIO, properties={\"path\": json_file})          assert dn_1._get_user_properties() == {}            dn_2 = JSONDataNode(              \"dn_2\",              Scope.SCENARIO,              properties={                  \"default_data\": \"foo\",                  \"default_path\": json_file,                  \"encoder\": MyCustomEncoder,                  \"decoder\": MyCustomDecoder,                  \"foo\": \"bar\",              },          )            # default_data, default_path, path, encoder, decoder are filtered out          assert dn_2._get_user_properties() == {\"foo\": \"bar\"}        def test_new_json_data_node_with_existing_file_is_ready_for_reading(self):          not_ready_dn_cfg = Config.configure_data_node(              \"not_ready_data_node_config_id\", \"json\", default_path=\"NOT_EXISTING.json\"          )          not_ready_dn = _DataManager._bulk_get_or_create([not_ready_dn_cfg])[not_ready_dn_cfg]          assert not not_ready_dn.is_ready_for_reading          assert not_ready_dn.path == \"NOT_EXISTING.json\"            path = os.path.join(pathlib.Path(__file__).parent.resolve(), \"data_sample/json/example_list.json\")          ready_dn_cfg = Config.configure_data_node(\"ready_data_node_config_id\", \"json\", default_path=path)          ready_dn = _DataManager._bulk_get_or_create([ready_dn_cfg])[ready_dn_cfg]          assert ready_dn.is_ready_for_reading        def test_read_non_existing_json(self):          not_existing_json = JSONDataNode(\"foo\", Scope.SCENARIO, properties={\"default_path\": \"WRONG.json\"})          with pytest.raises(NoData):              assert not_existing_json.read() is None              not_existing_json.read_or_raise()        def test_read(self):          path_1 = os.path.join(pathlib.Path(__file__).parent.resolve(), \"data_sample/json/example_list.json\")          dn_1 = JSONDataNode(\"bar\", Scope.SCENARIO, properties={\"default_path\": path_1})          data_1 = dn_1.read()          assert isinstance(data_1, list)          assert len(data_1) == 4            path_2 = os.path.join(pathlib.Path(__file__).parent.resolve(), \"data_sample/json/example_dict.json\")          dn_2 = JSONDataNode(\"bar\", Scope.SCENARIO, properties={\"default_path\": path_2})          data_2 = dn_2.read()          assert isinstance(data_2, dict)          assert data_2[\"id\"] == \"1\"            path_3 = os.path.join(pathlib.Path(__file__).parent.resolve(), \"data_sample/json/example_int.json\")          dn_3 = JSONDataNode(\"bar\", Scope.SCENARIO, properties={\"default_path\": path_3})          data_3 = dn_3.read()          assert isinstance(data_3, int)          assert data_3 == 1            path_4 = os.path.join(pathlib.Path(__file__).parent.resolve(), \"data_sample/json/example_null.json\")          dn_4 = JSONDataNode(\"bar\", Scope.SCENARIO, properties={\"default_path\": path_4})          data_4 = dn_4.read()          assert data_4 is None        def test_read_invalid_json(self):          path = os.path.join(pathlib.Path(__file__).parent.resolve(), \"data_sample/invalid.json.txt\")          dn = JSONDataNode(\"foo\", Scope.SCENARIO, properties={\"default_path\": path})          with pytest.raises(ValueError):              dn.read()        def test_append_to_list(self, json_file):          json_dn = JSONDataNode(\"foo\", Scope.SCENARIO, properties={\"default_path\": json_file})          original_data = json_dn.read()            # Append a dictionary          append_data_1 = {\"a\": 1, \"b\": 2, \"c\": 3}          json_dn.append(append_data_1)          assert json_dn.read() == original_data + [append_data_1]            # Append a list of dictionaries          append_data_data_2 = [{\"a\": 1, \"b\": 2, \"c\": 3}, {\"a\": 4, \"b\": 5, \"c\": 6}]          json_dn.append(append_data_data_2)          assert json_dn.read() == original_data + [append_data_1] + append_data_data_2        def test_append_to_a_dictionary(self, json_file):          json_dn = JSONDataNode(\"foo\", Scope.SCENARIO, properties={\"default_path\": json_file})          original_data = {\"a\": 1, \"b\": 2, \"c\": 3}          json_dn.write(original_data)            # Append another dictionary          append_data_1 = {\"d\": 1, \"e\": 2, \"f\": 3}          json_dn.append(append_data_1)          assert json_dn.read() == {**original_data, **append_data_1}            # Append an overlap dictionary          append_data_data_2 = {\"a\": 10, \"b\": 20, \"g\": 30}          json_dn.append(append_data_data_2)          assert json_dn.read() == {**original_data, **append_data_1, **append_data_data_2}        def test_write(self, json_file):          json_dn = JSONDataNode(\"foo\", Scope.SCENARIO, properties={\"default_path\": json_file})          data = {\"a\": 1, \"b\": 2, \"c\": 3}          json_dn.write(data)          assert np.array_equal(json_dn.read(), data)        def test_write_with_different_encoding(self, json_file):          data = {\"\u2265a\": 1, \"b\": 2}            utf8_dn = JSONDataNode(\"utf8_dn\", Scope.SCENARIO, properties={\"default_path\": json_file})          utf16_dn = JSONDataNode(              \"utf16_dn\", Scope.SCENARIO, properties={\"default_path\": json_file, \"encoding\": \"utf-16\"}          )            # If a file is written with utf-8 encoding, it can only be read with utf-8, not utf-16 encoding          utf8_dn.write(data)          assert np.array_equal(utf8_dn.read(), data)          with pytest.raises(UnicodeError):              utf16_dn.read()            # If a file is written with utf-16 encoding, it can only be read with utf-16, not utf-8 encoding          utf16_dn.write(data)          assert np.array_equal(utf16_dn.read(), data)          with pytest.raises(UnicodeError):              utf8_dn.read()        def test_write_non_serializable(self, json_file):          json_dn = JSONDataNode(\"foo\", Scope.SCENARIO, properties={\"default_path\": json_file})          data = {\"a\": 1, \"b\": json_dn}          with pytest.raises(TypeError):              json_dn.write(data)        def test_write_date(self, json_file):          json_dn = JSONDataNode(\"foo\", Scope.SCENARIO, properties={\"default_path\": json_file})          now = datetime.datetime.now()          data = {\"date\": now}          json_dn.write(data)          read_data = json_dn.read()          assert read_data[\"date\"] == now        def test_write_enum(self, json_file):          json_dn = JSONDataNode(\"foo\", Scope.SCENARIO, properties={\"default_path\": json_file})          data = [MyEnum.A, MyEnum.B, MyEnum.C]          json_dn.write(data)          read_data = json_dn.read()          assert read_data == [MyEnum.A, MyEnum.B, MyEnum.C]        def test_write_dataclass(self, json_file):          json_dn = JSONDataNode(\"foo\", Scope.SCENARIO, properties={\"default_path\": json_file})          json_dn.write(CustomDataclass(integer=1, string=\"foo\"))          read_data = json_dn.read()          assert read_data.integer == 1          assert read_data.string == \"foo\"        def test_write_custom_encoder(self, json_file):          json_dn = JSONDataNode(              \"foo\", Scope.SCENARIO, properties={\"default_path\": json_file, \"encoder\": MyCustomEncoder}          )          data = [MyCustomObject(\"1\", 1, \"abc\"), 100]          json_dn.write(data)          read_data = json_dn.read()          assert read_data[0][\"__type__\"] == \"MyCustomObject\"          assert read_data[0][\"id\"] == \"1\"          assert read_data[0][\"integer\"] == 1          assert read_data[0][\"text\"] == \"abc\"          assert read_data[1] == 100        def test_read_write_custom_encoder_decoder(self, json_file):          json_dn = JSONDataNode(              \"foo\",              Scope.SCENARIO,              properties={\"default_path\": json_file, \"encoder\": MyCustomEncoder, \"decoder\": MyCustomDecoder},          )          data = [MyCustomObject(\"1\", 1, \"abc\"), 100]          json_dn.write(data)          read_data = json_dn.read()          assert isinstance(read_data[0], MyCustomObject)          assert read_data[0].id == \"1\"          assert read_data[0].integer == 1          assert read_data[0].text == \"abc\"          assert read_data[1] == 100        def test_filter(self, json_file):          json_dn = JSONDataNode(\"foo\", Scope.SCENARIO, properties={\"default_path\": json_file})          json_dn.write(              [                  {\"foo\": 1, \"bar\": 1},                  {\"foo\": 1, \"bar\": 2},                  {\"foo\": 1},                  {\"foo\": 2, \"bar\": 2},                  {\"bar\": 2},                  {\"KWARGS_KEY\": \"KWARGS_VALUE\"},              ]          )            assert len(json_dn.filter((\"foo\", 1, Operator.EQUAL))) == 3          assert len(json_dn.filter((\"foo\", 1, Operator.NOT_EQUAL))) == 3          assert len(json_dn.filter((\"bar\", 2, Operator.EQUAL))) == 3          assert len(json_dn.filter([(\"bar\", 1, Operator.EQUAL), (\"bar\", 2, Operator.EQUAL)], JoinOperator.OR)) == 4            assert json_dn[0] == {\"foo\": 1, \"bar\": 1}          assert json_dn[2] == {\"foo\": 1}          assert json_dn[:2] == [{\"foo\": 1, \"bar\": 1}, {\"foo\": 1, \"bar\": 2}]        @pytest.mark.parametrize(          [\"properties\", \"exists\"],          [              ({}, False),              ({\"default_data\": {\"foo\": \"bar\"}}, True),          ],      )      def test_create_with_default_data(self, properties, exists):          dn = JSONDataNode(\"foo\", Scope.SCENARIO, DataNodeId(\"dn_id\"), properties=properties)          assert os.path.exists(dn.path) is exists        def test_set_path(self):          dn = JSONDataNode(\"foo\", Scope.SCENARIO, properties={\"default_path\": \"foo.json\"})          assert dn.path == \"foo.json\"          dn.path = \"bar.json\"          assert dn.path == \"bar.json\"        def test_read_write_after_modify_path(self):          path = os.path.join(pathlib.Path(__file__).parent.resolve(), \"data_sample/json/example_dict.json\")          new_path = os.path.join(pathlib.Path(__file__).parent.resolve(), \"data_sample/temp.json\")          dn = JSONDataNode(\"foo\", Scope.SCENARIO, properties={\"default_path\": path})          read_data = dn.read()          assert read_data is not None          dn.path = new_path          with pytest.raises(FileNotFoundError):              dn.read()          dn.write({\"other\": \"stuff\"})          assert dn.read() == {\"other\": \"stuff\"}        def test_get_system_modified_date_instead_of_last_edit_date(self, tmpdir_factory):          temp_file_path = str(tmpdir_factory.mktemp(\"data\").join(\"temp.json\"))          pd.DataFrame([]).to_json(temp_file_path)          dn = JSONDataNode(\"foo\", Scope.SCENARIO, properties={\"path\": temp_file_path})            dn.write([1, 2, 3])          previous_edit_date = dn.last_edit_date            sleep(0.1)            pd.DataFrame([4, 5, 6]).to_json(temp_file_path)          new_edit_date = datetime.datetime.fromtimestamp(os.path.getmtime(temp_file_path))            assert previous_edit_date < dn.last_edit_date          assert new_edit_date == dn.last_edit_date            sleep(0.1)            dn.write([1, 2, 3])          assert new_edit_date < dn.last_edit_date          os.unlink(temp_file_path) "}
{"text": "from importlib import util  from unittest.mock import patch    import modin.pandas as modin_pd  import numpy as np  import pandas as pd  import pytest  from modin.pandas.test.utils import df_equals  from pandas.testing import assert_frame_equal    from src.taipy.core.data.data_node_id import DataNodeId  from src.taipy.core.data.operator import JoinOperator, Operator  from src.taipy.core.data.sql import SQLDataNode  from src.taipy.core.exceptions.exceptions import MissingAppendQueryBuilder, MissingRequiredProperty  from taipy.config.common.scope import Scope      class MyCustomObject:      def __init__(self, foo=None, bar=None, *args, **kwargs):          self.foo = foo          self.bar = bar          self.args = args          self.kwargs = kwargs      def my_write_query_builder_with_pandas(data: pd.DataFrame):      insert_data = data.to_dict(\"records\")      return [\"DELETE FROM example\", (\"INSERT INTO example VALUES (:foo, :bar)\", insert_data)]      def my_write_query_builder_with_modin(data: modin_pd.DataFrame):      insert_data = data.to_dict(\"records\")      return [\"DELETE FROM example\", (\"INSERT INTO example VALUES (:foo, :bar)\", insert_data)]      def my_append_query_builder_with_pandas(data: pd.DataFrame):      insert_data = data.to_dict(\"records\")      return [(\"INSERT INTO example VALUES (:foo, :bar)\", insert_data)]      def my_append_query_builder_with_modin(data: modin_pd.DataFrame):      insert_data = data.to_dict(\"records\")      return [(\"INSERT INTO example VALUES (:foo, :bar)\", insert_data)]      def single_write_query_builder(data):      return \"DELETE FROM example\"      class TestSQLDataNode:      __pandas_properties = [          {              \"db_name\": \"taipy.sqlite3\",              \"db_engine\": \"sqlite\",              \"read_query\": \"SELECT * FROM example\",              \"write_query_builder\": my_write_query_builder_with_pandas,              \"db_extra_args\": {                  \"TrustServerCertificate\": \"yes\",                  \"other\": \"value\",              },          },      ]        __modin_properties = [          {              \"db_name\": \"taipy.sqlite3\",              \"db_engine\": \"sqlite\",              \"read_query\": \"SELECT * FROM example\",              \"write_query_builder\": my_write_query_builder_with_modin,              \"exposed_type\": \"modin\",              \"db_extra_args\": {                  \"TrustServerCertificate\": \"yes\",                  \"other\": \"value\",              },          },      ]        if util.find_spec(\"pyodbc\"):          __pandas_properties.append(              {                  \"db_username\": \"sa\",                  \"db_password\": \"Passw0rd\",                  \"db_name\": \"taipy\",                  \"db_engine\": \"mssql\",                  \"read_query\": \"SELECT * FROM example\",                  \"write_query_builder\": my_write_query_builder_with_pandas,                  \"db_extra_args\": {                      \"TrustServerCertificate\": \"yes\",                  },              },          )          __modin_properties.append(              {                  \"db_username\": \"sa\",                  \"db_password\": \"Passw0rd\",                  \"db_name\": \"taipy\",                  \"db_engine\": \"mssql\",                  \"read_query\": \"SELECT * FROM example\",                  \"write_query_builder\": my_write_query_builder_with_modin,                  \"exposed_type\": \"modin\",                  \"db_extra_args\": {                      \"TrustServerCertificate\": \"yes\",                  },              },          )        if util.find_spec(\"pymysql\"):          __pandas_properties.append(              {                  \"db_username\": \"sa\",                  \"db_password\": \"Passw0rd\",                  \"db_name\": \"taipy\",                  \"db_engine\": \"mysql\",                  \"read_query\": \"SELECT * FROM example\",                  \"write_query_builder\": my_write_query_builder_with_pandas,                  \"db_extra_args\": {                      \"TrustServerCertificate\": \"yes\",                  },              },          )          __modin_properties.append(              {                  \"db_username\": \"sa\",                  \"db_password\": \"Passw0rd\",                  \"db_name\": \"taipy\",                  \"db_engine\": \"mysql\",                  \"read_query\": \"SELECT * FROM example\",                  \"write_query_builder\": my_write_query_builder_with_modin,                  \"exposed_type\": \"modin\",                  \"db_extra_args\": {                      \"TrustServerCertificate\": \"yes\",                  },              },          )        if util.find_spec(\"psycopg2\"):          __pandas_properties.append(              {                  \"db_username\": \"sa\",                  \"db_password\": \"Passw0rd\",                  \"db_name\": \"taipy\",                  \"db_engine\": \"postgresql\",                  \"read_query\": \"SELECT * FROM example\",                  \"write_query_builder\": my_write_query_builder_with_pandas,                  \"db_extra_args\": {                      \"TrustServerCertificate\": \"yes\",                  },              },          )          __modin_properties.append(              {                  \"db_username\": \"sa\",                  \"db_password\": \"Passw0rd\",                  \"db_name\": \"taipy\",                  \"db_engine\": \"postgresql\",                  \"read_query\": \"SELECT * FROM example\",                  \"write_query_builder\": my_write_query_builder_with_modin,                  \"exposed_type\": \"modin\",                  \"db_extra_args\": {                      \"TrustServerCertificate\": \"yes\",                  },              },          )        @pytest.mark.parametrize(\"pandas_properties\", __pandas_properties)      @pytest.mark.parametrize(\"modin_properties\", __modin_properties)      def test_create(self, pandas_properties, modin_properties):          dn = SQLDataNode(              \"foo_bar\",              Scope.SCENARIO,              properties=pandas_properties,          )          assert isinstance(dn, SQLDataNode)          assert dn.storage_type() == \"sql\"          assert dn.config_id == \"foo_bar\"          assert dn.scope == Scope.SCENARIO          assert dn.id is not None          assert dn.owner_id is None          assert dn.job_ids == []          assert dn.is_ready_for_reading          assert dn.exposed_type == \"pandas\"          assert dn.read_query == \"SELECT * FROM example\"          assert dn.write_query_builder == my_write_query_builder_with_pandas            dn = SQLDataNode(              \"foo_bar\",              Scope.SCENARIO,              properties=modin_properties,          )          assert isinstance(dn, SQLDataNode)          assert dn.storage_type() == \"sql\"          assert dn.config_id == \"foo_bar\"          assert dn.scope == Scope.SCENARIO          assert dn.id is not None          assert dn.owner_id is None          assert dn.job_ids == []          assert dn.is_ready_for_reading          assert dn.exposed_type == \"modin\"          assert dn.read_query == \"SELECT * FROM example\"          assert dn.write_query_builder == my_write_query_builder_with_modin        @pytest.mark.parametrize(\"properties\", __pandas_properties + __modin_properties)      def test_get_user_properties(self, properties):          custom_properties = properties.copy()          custom_properties[\"foo\"] = \"bar\"          dn = SQLDataNode(              \"foo_bar\",              Scope.SCENARIO,              properties=custom_properties,          )          assert dn._get_user_properties() == {\"foo\": \"bar\"}        @pytest.mark.parametrize(          \"properties\",          [              {},              {\"db_username\": \"foo\"},              {\"db_username\": \"foo\", \"db_password\": \"foo\"},              {\"db_username\": \"foo\", \"db_password\": \"foo\", \"db_name\": \"foo\"},              {\"engine\": \"sqlite\"},              {\"engine\": \"mssql\", \"db_name\": \"foo\"},              {\"engine\": \"mysql\", \"db_username\": \"foo\"},              {\"engine\": \"postgresql\", \"db_username\": \"foo\", \"db_password\": \"foo\"},          ],      )      def test_create_with_missing_parameters(self, properties):          with pytest.raises(MissingRequiredProperty):              SQLDataNode(\"foo\", Scope.SCENARIO, DataNodeId(\"dn_id\"))          with pytest.raises(MissingRequiredProperty):              SQLDataNode(\"foo\", Scope.SCENARIO, DataNodeId(\"dn_id\"), properties=properties)        @pytest.mark.parametrize(\"pandas_properties\", __pandas_properties)      @pytest.mark.parametrize(\"modin_properties\", __modin_properties)      def test_write_query_builder(self, pandas_properties, modin_properties):          custom_properties = pandas_properties.copy()          custom_properties.pop(\"db_extra_args\")          dn = SQLDataNode(\"foo_bar\", Scope.SCENARIO, properties=custom_properties)          with patch(\"sqlalchemy.engine.Engine.connect\") as engine_mock:              # mock connection execute              dn.write(pd.DataFrame({\"foo\": [1, 2, 3], \"bar\": [4, 5, 6]}))              assert len(engine_mock.mock_calls[4].args) == 1              assert engine_mock.mock_calls[4].args[0].text == \"DELETE FROM example\"              assert len(engine_mock.mock_calls[5].args) == 2              assert engine_mock.mock_calls[5].args[0].text == \"INSERT INTO example VALUES (:foo, :bar)\"              assert engine_mock.mock_calls[5].args[1] == [                  {\"foo\": 1, \"bar\": 4},                  {\"foo\": 2, \"bar\": 5},                  {\"foo\": 3, \"bar\": 6},              ]            custom_properties[\"write_query_builder\"] = single_write_query_builder          dn = SQLDataNode(\"foo_bar\", Scope.SCENARIO, properties=custom_properties)            with patch(\"sqlalchemy.engine.Engine.connect\") as engine_mock:              # mock connection execute              dn.write(pd.DataFrame({\"foo\": [1, 2, 3], \"bar\": [4, 5, 6]}))              assert len(engine_mock.mock_calls[4].args) == 1              assert engine_mock.mock_calls[4].args[0].text == \"DELETE FROM example\"            custom_properties = modin_properties.copy()          custom_properties.pop(\"db_extra_args\")          dn = SQLDataNode(\"foo_bar\", Scope.SCENARIO, properties=custom_properties)          with patch(\"sqlalchemy.engine.Engine.connect\") as engine_mock:              # mock connection execute              dn.write(modin_pd.DataFrame({\"foo\": [1, 2, 3], \"bar\": [4, 5, 6]}))              assert len(engine_mock.mock_calls[4].args) == 1              assert engine_mock.mock_calls[4].args[0].text == \"DELETE FROM example\"              assert len(engine_mock.mock_calls[5].args) == 2              assert engine_mock.mock_calls[5].args[0].text == \"INSERT INTO example VALUES (:foo, :bar)\"              assert engine_mock.mock_calls[5].args[1] == [                  {\"foo\": 1, \"bar\": 4},                  {\"foo\": 2, \"bar\": 5},                  {\"foo\": 3, \"bar\": 6},              ]            custom_properties[\"write_query_builder\"] = single_write_query_builder          dn = SQLDataNode(\"foo_bar\", Scope.SCENARIO, properties=custom_properties)            with patch(\"sqlalchemy.engine.Engine.connect\") as engine_mock:              # mock connection execute              dn.write(modin_pd.DataFrame({\"foo\": [1, 2, 3], \"bar\": [4, 5, 6]}))              assert len(engine_mock.mock_calls[4].args) == 1              assert engine_mock.mock_calls[4].args[0].text == \"DELETE FROM example\"        @pytest.mark.parametrize(          \"tmp_sqlite_path\",          [              \"tmp_sqlite_db_file_path\",              \"tmp_sqlite_sqlite3_file_path\",          ],      )      def test_sqlite_read_file_with_different_extension(self, tmp_sqlite_path, request):          tmp_sqlite_path = request.getfixturevalue(tmp_sqlite_path)          folder_path, db_name, file_extension = tmp_sqlite_path          properties = {              \"db_engine\": \"sqlite\",              \"read_query\": \"SELECT * from example\",              \"write_query_builder\": single_write_query_builder,              \"db_name\": db_name,              \"sqlite_folder_path\": folder_path,              \"sqlite_file_extension\": file_extension,          }            dn = SQLDataNode(\"sqlite_dn\", Scope.SCENARIO, properties=properties)          data = dn.read()          assert data.equals(pd.DataFrame([{\"foo\": 1, \"bar\": 2}, {\"foo\": 3, \"bar\": 4}]))        def test_sqlite_append_pandas(self, tmp_sqlite_sqlite3_file_path):          folder_path, db_name, file_extension = tmp_sqlite_sqlite3_file_path          properties = {              \"db_engine\": \"sqlite\",              \"read_query\": \"SELECT * FROM example\",              \"write_query_builder\": my_write_query_builder_with_pandas,              \"append_query_builder\": my_append_query_builder_with_pandas,              \"db_name\": db_name,              \"sqlite_folder_path\": folder_path,              \"sqlite_file_extension\": file_extension,          }            dn = SQLDataNode(\"sqlite_dn\", Scope.SCENARIO, properties=properties)          original_data = pd.DataFrame([{\"foo\": 1, \"bar\": 2}, {\"foo\": 3, \"bar\": 4}])          data = dn.read()          assert_frame_equal(data, original_data)            append_data_1 = pd.DataFrame([{\"foo\": 5, \"bar\": 6}, {\"foo\": 7, \"bar\": 8}])          dn.append(append_data_1)          assert_frame_equal(dn.read(), pd.concat([original_data, append_data_1]).reset_index(drop=True))        def test_sqlite_append_modin(self, tmp_sqlite_sqlite3_file_path):          folder_path, db_name, file_extension = tmp_sqlite_sqlite3_file_path          properties = {              \"db_engine\": \"sqlite\",              \"read_query\": \"SELECT * FROM example\",              \"write_query_builder\": my_write_query_builder_with_pandas,              \"append_query_builder\": my_append_query_builder_with_pandas,              \"db_name\": db_name,              \"sqlite_folder_path\": folder_path,              \"sqlite_file_extension\": file_extension,              \"exposed_type\": \"modin\",          }            dn = SQLDataNode(\"sqlite_dn\", Scope.SCENARIO, properties=properties)          original_data = modin_pd.DataFrame([{\"foo\": 1, \"bar\": 2}, {\"foo\": 3, \"bar\": 4}])          data = dn.read()          df_equals(data, original_data)            append_data_1 = modin_pd.DataFrame([{\"foo\": 5, \"bar\": 6}, {\"foo\": 7, \"bar\": 8}])          dn.append(append_data_1)          df_equals(dn.read(), modin_pd.concat([original_data, append_data_1]).reset_index(drop=True))        def test_sqlite_append_without_append_query_builder(self, tmp_sqlite_sqlite3_file_path):          folder_path, db_name, file_extension = tmp_sqlite_sqlite3_file_path          properties = {              \"db_engine\": \"sqlite\",              \"read_query\": \"SELECT * FROM example\",              \"write_query_builder\": my_write_query_builder_with_pandas,              \"db_name\": db_name,              \"sqlite_folder_path\": folder_path,              \"sqlite_file_extension\": file_extension,          }            dn = SQLDataNode(\"sqlite_dn\", Scope.SCENARIO, properties=properties)          with pytest.raises(MissingAppendQueryBuilder):              dn.append(pd.DataFrame([{\"foo\": 1, \"bar\": 2}, {\"foo\": 3, \"bar\": 4}]))        def test_filter_pandas_exposed_type(self, tmp_sqlite_sqlite3_file_path):          folder_path, db_name, file_extension = tmp_sqlite_sqlite3_file_path          properties = {              \"db_engine\": \"sqlite\",              \"read_query\": \"SELECT * FROM example\",              \"write_query_builder\": my_write_query_builder_with_pandas,              \"db_name\": db_name,              \"sqlite_folder_path\": folder_path,              \"sqlite_file_extension\": file_extension,              \"exposed_type\": \"pandas\",          }          dn = SQLDataNode(\"foo\", Scope.SCENARIO, properties=properties)          dn.write(              pd.DataFrame(                  [                      {\"foo\": 1, \"bar\": 1},                      {\"foo\": 1, \"bar\": 2},                      {\"foo\": 1, \"bar\": 3},                      {\"foo\": 2, \"bar\": 1},                      {\"foo\": 2, \"bar\": 2},                      {\"foo\": 2, \"bar\": 3},                  ]              )          )            # Test datanode indexing and slicing          assert dn[\"foo\"].equals(pd.Series([1, 1, 1, 2, 2, 2]))          assert dn[\"bar\"].equals(pd.Series([1, 2, 3, 1, 2, 3]))          assert dn[:2].equals(pd.DataFrame([{\"foo\": 1, \"bar\": 1}, {\"foo\": 1, \"bar\": 2}]))            # Test filter data          filtered_by_filter_method = dn.filter((\"foo\", 1, Operator.EQUAL))          filtered_by_indexing = dn[dn[\"foo\"] == 1]          expected_data = pd.DataFrame([{\"foo\": 1, \"bar\": 1}, {\"foo\": 1, \"bar\": 2}, {\"foo\": 1, \"bar\": 3}])          assert_frame_equal(filtered_by_filter_method.reset_index(drop=True), expected_data)          assert_frame_equal(filtered_by_indexing.reset_index(drop=True), expected_data)            filtered_by_filter_method = dn.filter((\"foo\", 1, Operator.NOT_EQUAL))          filtered_by_indexing = dn[dn[\"foo\"] != 1]          expected_data = pd.DataFrame([{\"foo\": 2, \"bar\": 1}, {\"foo\": 2, \"bar\": 2}, {\"foo\": 2, \"bar\": 3}])          assert_frame_equal(filtered_by_filter_method.reset_index(drop=True), expected_data)          assert_frame_equal(filtered_by_indexing.reset_index(drop=True), expected_data)            filtered_by_filter_method = dn.filter([(\"bar\", 1, Operator.EQUAL), (\"bar\", 2, Operator.EQUAL)], JoinOperator.OR)          filtered_by_indexing = dn[(dn[\"bar\"] == 1) | (dn[\"bar\"] == 2)]          expected_data = pd.DataFrame(              [                  {\"foo\": 1, \"bar\": 1},                  {\"foo\": 1, \"bar\": 2},                  {\"foo\": 2, \"bar\": 1},                  {\"foo\": 2, \"bar\": 2},              ]          )          assert_frame_equal(filtered_by_filter_method.reset_index(drop=True), expected_data)          assert_frame_equal(filtered_by_indexing.reset_index(drop=True), expected_data)        def test_filter_modin_exposed_type(self, tmp_sqlite_sqlite3_file_path):          folder_path, db_name, file_extension = tmp_sqlite_sqlite3_file_path          properties = {              \"db_engine\": \"sqlite\",              \"read_query\": \"SELECT * FROM example\",              \"write_query_builder\": my_write_query_builder_with_modin,              \"db_name\": db_name,              \"sqlite_folder_path\": folder_path,              \"sqlite_file_extension\": file_extension,              \"exposed_type\": \"modin\",          }          dn = SQLDataNode(\"foo\", Scope.SCENARIO, properties=properties)          dn.write(              pd.DataFrame(                  [                      {\"foo\": 1, \"bar\": 1},                      {\"foo\": 1, \"bar\": 2},                      {\"foo\": 1, \"bar\": 3},                      {\"foo\": 2, \"bar\": 1},                      {\"foo\": 2, \"bar\": 2},                      {\"foo\": 2, \"bar\": 3},                  ]              )          )            # Test datanode indexing and slicing          assert dn[\"foo\"].equals(pd.Series([1, 1, 1, 2, 2, 2]))          assert dn[\"bar\"].equals(pd.Series([1, 2, 3, 1, 2, 3]))          assert dn[:2].equals(modin_pd.DataFrame([{\"foo\": 1, \"bar\": 1}, {\"foo\": 1, \"bar\": 2}]))            # Test filter data          filtered_by_filter_method = dn.filter((\"foo\", 1, Operator.EQUAL))          filtered_by_indexing = dn[dn[\"foo\"] == 1]          expected_data = modin_pd.DataFrame([{\"foo\": 1, \"bar\": 1}, {\"foo\": 1, \"bar\": 2}, {\"foo\": 1, \"bar\": 3}])          df_equals(filtered_by_filter_method.reset_index(drop=True), expected_data)          df_equals(filtered_by_indexing.reset_index(drop=True), expected_data)            filtered_by_filter_method = dn.filter((\"foo\", 1, Operator.NOT_EQUAL))          filtered_by_indexing = dn[dn[\"foo\"] != 1]          expected_data = modin_pd.DataFrame([{\"foo\": 2, \"bar\": 1}, {\"foo\": 2, \"bar\": 2}, {\"foo\": 2, \"bar\": 3}])          df_equals(filtered_by_filter_method.reset_index(drop=True), expected_data)          df_equals(filtered_by_indexing.reset_index(drop=True), expected_data)            filtered_by_filter_method = dn.filter([(\"bar\", 1, Operator.EQUAL), (\"bar\", 2, Operator.EQUAL)], JoinOperator.OR)          filtered_by_indexing = dn[(dn[\"bar\"] == 1) | (dn[\"bar\"] == 2)]          expected_data = modin_pd.DataFrame(              [                  {\"foo\": 1, \"bar\": 1},                  {\"foo\": 1, \"bar\": 2},                  {\"foo\": 2, \"bar\": 1},                  {\"foo\": 2, \"bar\": 2},              ]          )          df_equals(filtered_by_filter_method.reset_index(drop=True), expected_data)          df_equals(filtered_by_indexing.reset_index(drop=True), expected_data)        def test_filter_numpy_exposed_type(self, tmp_sqlite_sqlite3_file_path):          folder_path, db_name, file_extension = tmp_sqlite_sqlite3_file_path          properties = {              \"db_engine\": \"sqlite\",              \"read_query\": \"SELECT * FROM example\",              \"write_query_builder\": my_write_query_builder_with_pandas,              \"db_name\": db_name,              \"sqlite_folder_path\": folder_path,              \"sqlite_file_extension\": file_extension,              \"exposed_type\": \"numpy\",          }          dn = SQLDataNode(\"foo\", Scope.SCENARIO, properties=properties)          dn.write(              pd.DataFrame(                  [                      {\"foo\": 1, \"bar\": 1},                      {\"foo\": 1, \"bar\": 2},                      {\"foo\": 1, \"bar\": 3},                      {\"foo\": 2, \"bar\": 1},                      {\"foo\": 2, \"bar\": 2},                      {\"foo\": 2, \"bar\": 3},                  ]              )          )            # Test datanode indexing and slicing          assert np.array_equal(dn[0], np.array([1, 1]))          assert np.array_equal(dn[1], np.array([1, 2]))          assert np.array_equal(dn[:3], np.array([[1, 1], [1, 2], [1, 3]]))          assert np.array_equal(dn[:, 0], np.array([1, 1, 1, 2, 2, 2]))          assert np.array_equal(dn[1:4, :1], np.array([[1], [1], [2]]))            # Test filter data          assert np.array_equal(dn.filter((\"foo\", 1, Operator.EQUAL)), np.array([[1, 1], [1, 2], [1, 3]]))          assert np.array_equal(dn[dn[:, 0] == 1], np.array([[1, 1], [1, 2], [1, 3]]))            assert np.array_equal(dn.filter((\"foo\", 1, Operator.NOT_EQUAL)), np.array([[2, 1], [2, 2], [2, 3]]))          assert np.array_equal(dn[dn[:, 0] != 1], np.array([[2, 1], [2, 2], [2, 3]]))            assert np.array_equal(dn.filter((\"bar\", 2, Operator.EQUAL)), np.array([[1, 2], [2, 2]]))          assert np.array_equal(dn[dn[:, 1] == 2], np.array([[1, 2], [2, 2]]))            assert np.array_equal(              dn.filter([(\"bar\", 1, Operator.EQUAL), (\"bar\", 2, Operator.EQUAL)], JoinOperator.OR),              np.array([[1, 1], [1, 2], [2, 1], [2, 2]]),          )          assert np.array_equal(dn[(dn[:, 1] == 1) | (dn[:, 1] == 2)], np.array([[1, 1], [1, 2], [2, 1], [2, 2]]))        def test_filter_does_not_read_all_entities(self, tmp_sqlite_sqlite3_file_path):          folder_path, db_name, file_extension = tmp_sqlite_sqlite3_file_path          properties = {              \"db_engine\": \"sqlite\",              \"read_query\": \"SELECT * FROM example\",              \"write_query_builder\": my_write_query_builder_with_pandas,              \"db_name\": db_name,              \"sqlite_folder_path\": folder_path,              \"sqlite_file_extension\": file_extension,              \"exposed_type\": \"numpy\",          }          dn = SQLDataNode(\"foo\", Scope.SCENARIO, properties=properties)            # SQLDataNode.filter() should not call the MongoCollectionDataNode._read() method          with patch.object(SQLDataNode, \"_read\") as read_mock:              dn.filter((\"foo\", 1, Operator.EQUAL))              dn.filter((\"bar\", 2, Operator.NOT_EQUAL))              dn.filter([(\"bar\", 1, Operator.EQUAL), (\"bar\", 2, Operator.EQUAL)], JoinOperator.OR)                assert read_mock[\"_read\"].call_count == 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.  import os  import pathlib    import pytest    from src.taipy.core._version._version_manager import _VersionManager  from src.taipy.core.config.data_node_config import DataNodeConfig  from src.taipy.core.data._data_manager import _DataManager  from src.taipy.core.data.csv import CSVDataNode  from src.taipy.core.data.data_node_id import DataNodeId  from src.taipy.core.data.in_memory import InMemoryDataNode  from src.taipy.core.data.pickle import PickleDataNode  from src.taipy.core.exceptions.exceptions import InvalidDataNodeType, ModelNotFound  from taipy.config.common.scope import Scope  from taipy.config.config import Config  from tests.core.utils.named_temporary_file import NamedTemporaryFile      def file_exists(file_path: str) -> bool:      return os.path.exists(file_path)      class TestDataManager:      def test_create_data_node_and_modify_properties_does_not_modify_config(self):          dn_config = Config.configure_data_node(id=\"name\", foo=\"bar\")          dn = _DataManager._create_and_set(dn_config, None, None)          assert dn_config.properties.get(\"foo\") == \"bar\"          assert dn_config.properties.get(\"baz\") is None            dn.properties[\"baz\"] = \"qux\"          _DataManager._set(dn)          assert dn_config.properties.get(\"foo\") == \"bar\"          assert dn_config.properties.get(\"baz\") is None          assert dn.properties.get(\"foo\") == \"bar\"          assert dn.properties.get(\"baz\") == \"qux\"        def test_create_data_node_with_name_provided(self):          dn_config = Config.configure_data_node(id=\"dn\", foo=\"bar\", name=\"acb\")          dn = _DataManager._create_and_set(dn_config, None, None)          assert dn.name == \"acb\"        def test_create_and_get_csv_data_node(self):          # Test we can instantiate a CsvDataNode from DataNodeConfig with :          # - a csv type          # - a default scenario scope          # - No owner_id          csv_dn_config = Config.configure_data_node(id=\"foo\", storage_type=\"csv\", path=\"bar\", has_header=True)          csv_dn = _DataManager._create_and_set(csv_dn_config, None, None)            assert isinstance(csv_dn, CSVDataNode)          assert isinstance(_DataManager._get(csv_dn.id), CSVDataNode)            assert _DataManager._exists(csv_dn.id)          assert _DataManager._get(csv_dn.id) is not None          assert _DataManager._get(csv_dn.id).id == csv_dn.id          assert _DataManager._get(csv_dn.id).config_id == \"foo\"          assert _DataManager._get(csv_dn.id).config_id == csv_dn.config_id          assert _DataManager._get(csv_dn.id).scope == Scope.SCENARIO          assert _DataManager._get(csv_dn.id).scope == csv_dn.scope          assert _DataManager._get(csv_dn.id).owner_id is None          assert _DataManager._get(csv_dn.id).owner_id == csv_dn.owner_id          assert _DataManager._get(csv_dn.id).parent_ids == set()          assert _DataManager._get(csv_dn.id).parent_ids == csv_dn.parent_ids          assert _DataManager._get(csv_dn.id).last_edit_date is None          assert _DataManager._get(csv_dn.id).last_edit_date == csv_dn.last_edit_date          assert _DataManager._get(csv_dn.id).job_ids == []          assert _DataManager._get(csv_dn.id).job_ids == csv_dn.job_ids          assert not _DataManager._get(csv_dn.id).is_ready_for_reading          assert _DataManager._get(csv_dn.id).is_ready_for_reading == csv_dn.is_ready_for_reading          assert len(_DataManager._get(csv_dn.id).properties) == 4          assert _DataManager._get(csv_dn.id).properties.get(\"path\") == \"bar\"          assert _DataManager._get(csv_dn.id).properties.get(\"encoding\") == \"utf-8\"          assert _DataManager._get(csv_dn.id).properties.get(\"has_header\") is True          assert _DataManager._get(csv_dn.id).properties.get(\"exposed_type\") == \"pandas\"          assert _DataManager._get(csv_dn.id).properties == csv_dn.properties          assert _DataManager._get(csv_dn.id).edit_in_progress is False          assert _DataManager._get(csv_dn.id)._editor_id is None          assert _DataManager._get(csv_dn.id)._editor_expiration_date is None            assert _DataManager._get(csv_dn) is not None          assert _DataManager._get(csv_dn).id == csv_dn.id          assert _DataManager._get(csv_dn).config_id == \"foo\"          assert _DataManager._get(csv_dn).config_id == csv_dn.config_id          assert _DataManager._get(csv_dn).scope == Scope.SCENARIO          assert _DataManager._get(csv_dn).scope == csv_dn.scope          assert _DataManager._get(csv_dn).owner_id is None          assert _DataManager._get(csv_dn).owner_id == csv_dn.owner_id          assert _DataManager._get(csv_dn).parent_ids == set()          assert _DataManager._get(csv_dn).parent_ids == csv_dn.parent_ids          assert _DataManager._get(csv_dn).last_edit_date is None          assert _DataManager._get(csv_dn).last_edit_date == csv_dn.last_edit_date          assert _DataManager._get(csv_dn).job_ids == []          assert _DataManager._get(csv_dn).job_ids == csv_dn.job_ids          assert not _DataManager._get(csv_dn).is_ready_for_reading          assert _DataManager._get(csv_dn).is_ready_for_reading == csv_dn.is_ready_for_reading          assert len(_DataManager._get(csv_dn).properties) == 4          assert _DataManager._get(csv_dn).properties.get(\"path\") == \"bar\"          assert _DataManager._get(csv_dn).properties.get(\"encoding\") == \"utf-8\"          assert _DataManager._get(csv_dn).properties.get(\"has_header\") is True          assert _DataManager._get(csv_dn.id).properties.get(\"exposed_type\") == \"pandas\"          assert _DataManager._get(csv_dn).properties == csv_dn.properties          assert _DataManager._get(csv_dn.id).edit_in_progress is False          assert _DataManager._get(csv_dn.id)._editor_id is None          assert _DataManager._get(csv_dn.id)._editor_expiration_date is None        def test_edit_and_get_data_node(self):          config = Config.configure_pickle_data_node(id=\"foo\")          dn = _DataManager._create_and_set(config, None, None)            assert _DataManager._get(dn.id).last_edit_date is None          assert len(_DataManager._get(dn.id).properties) == 1          assert _DataManager._get(dn.id).properties.get(\"is_generated\")          assert not _DataManager._get(dn.id).edit_in_progress          assert _DataManager._get(dn.id)._editor_id is None          assert _DataManager._get(dn.id)._editor_expiration_date is None            dn.lock_edit(\"foo\")            assert _DataManager._get(dn.id).last_edit_date is None          assert len(_DataManager._get(dn.id).properties) == 1          assert _DataManager._get(dn.id).properties.get(\"is_generated\")          assert _DataManager._get(dn.id).edit_in_progress          assert _DataManager._get(dn.id).editor_id == \"foo\"          assert _DataManager._get(dn.id).editor_expiration_date is not None            dn.unlock_edit(\"foo\")            assert _DataManager._get(dn.id).last_edit_date is None          assert len(_DataManager._get(dn.id).properties) == 1          assert _DataManager._get(dn.id).properties.get(\"is_generated\")          assert not _DataManager._get(dn.id).edit_in_progress          assert _DataManager._get(dn.id).editor_id is None          assert _DataManager._get(dn.id).editor_expiration_date is None        def test_create_and_get_in_memory_data_node(self):          # Test we can instantiate an InMemoryDataNode from DataNodeConfig with :          # - an in_memory type          # - a scenario scope          # - an owner id          # - some default data          in_memory_dn_config = Config.configure_data_node(              id=\"baz\", storage_type=\"in_memory\", scope=Scope.SCENARIO, default_data=\"qux\", other_data=\"foo\"          )          in_mem_dn = _DataManager._create_and_set(in_memory_dn_config, \"Scenario_id\", {\"task_id\"})            assert isinstance(in_mem_dn, InMemoryDataNode)          assert isinstance(_DataManager._get(in_mem_dn.id), InMemoryDataNode)            assert _DataManager._exists(in_mem_dn.id)          assert _DataManager._get(in_mem_dn.id) is not None          assert _DataManager._get(in_mem_dn.id).id == in_mem_dn.id          assert _DataManager._get(in_mem_dn.id).config_id == \"baz\"          assert _DataManager._get(in_mem_dn.id).config_id == in_mem_dn.config_id          assert _DataManager._get(in_mem_dn.id).scope == Scope.SCENARIO          assert _DataManager._get(in_mem_dn.id).scope == in_mem_dn.scope          assert _DataManager._get(in_mem_dn.id).owner_id == \"Scenario_id\"          assert _DataManager._get(in_mem_dn.id).owner_id == in_mem_dn.owner_id          assert _DataManager._get(in_mem_dn.id).parent_ids == {\"task_id\"}          assert _DataManager._get(in_mem_dn.id).parent_ids == in_mem_dn.parent_ids          assert _DataManager._get(in_mem_dn.id).last_edit_date is not None          assert _DataManager._get(in_mem_dn.id).last_edit_date == in_mem_dn.last_edit_date          assert _DataManager._get(in_mem_dn.id).job_ids == []          assert _DataManager._get(in_mem_dn.id).job_ids == in_mem_dn.job_ids          assert _DataManager._get(in_mem_dn.id).is_ready_for_reading          assert _DataManager._get(in_mem_dn.id).is_ready_for_reading == in_mem_dn.is_ready_for_reading          assert len(_DataManager._get(in_mem_dn.id).properties) == 1          assert _DataManager._get(in_mem_dn.id).properties.get(\"other_data\") == \"foo\"          assert _DataManager._get(in_mem_dn.id).properties == in_mem_dn.properties            assert _DataManager._get(in_mem_dn) is not None          assert _DataManager._get(in_mem_dn).id == in_mem_dn.id          assert _DataManager._get(in_mem_dn).config_id == \"baz\"          assert _DataManager._get(in_mem_dn).config_id == in_mem_dn.config_id          assert _DataManager._get(in_mem_dn).scope == Scope.SCENARIO          assert _DataManager._get(in_mem_dn).scope == in_mem_dn.scope          assert _DataManager._get(in_mem_dn).owner_id == \"Scenario_id\"          assert _DataManager._get(in_mem_dn).owner_id == in_mem_dn.owner_id          assert _DataManager._get(in_mem_dn).parent_ids == {\"task_id\"}          assert _DataManager._get(in_mem_dn).parent_ids == in_mem_dn.parent_ids          assert _DataManager._get(in_mem_dn).last_edit_date is not None          assert _DataManager._get(in_mem_dn).last_edit_date == in_mem_dn.last_edit_date          assert _DataManager._get(in_mem_dn).job_ids == []          assert _DataManager._get(in_mem_dn).job_ids == in_mem_dn.job_ids          assert _DataManager._get(in_mem_dn).is_ready_for_reading          assert _DataManager._get(in_mem_dn).is_ready_for_reading == in_mem_dn.is_ready_for_reading          assert len(_DataManager._get(in_mem_dn).properties) == 1          assert _DataManager._get(in_mem_dn).properties.get(\"other_data\") == \"foo\"          assert _DataManager._get(in_mem_dn).properties == in_mem_dn.properties        def test_create_and_get_pickle_data_node(self):          # Test we can instantiate a PickleDataNode from DataNodeConfig with :          # - an in_memory type          # - a business cycle scope          # - No owner id          # - no default data          dn_config = Config.configure_data_node(id=\"plop\", storage_type=\"pickle\", scope=Scope.CYCLE)          pickle_dn = _DataManager._create_and_set(dn_config, None, {\"task_id_1\", \"task_id_2\"})            assert isinstance(pickle_dn, PickleDataNode)          assert isinstance(_DataManager._get(pickle_dn.id), PickleDataNode)            assert _DataManager._exists(pickle_dn.id)          assert _DataManager._get(pickle_dn.id) is not None          assert _DataManager._get(pickle_dn.id).id == pickle_dn.id          assert _DataManager._get(pickle_dn.id).config_id == \"plop\"          assert _DataManager._get(pickle_dn.id).config_id == pickle_dn.config_id          assert _DataManager._get(pickle_dn.id).scope == Scope.CYCLE          assert _DataManager._get(pickle_dn.id).scope == pickle_dn.scope          assert _DataManager._get(pickle_dn.id).owner_id is None          assert _DataManager._get(pickle_dn.id).owner_id == pickle_dn.owner_id          assert _DataManager._get(pickle_dn.id).parent_ids == {\"task_id_1\", \"task_id_2\"}          assert _DataManager._get(pickle_dn.id).parent_ids == pickle_dn.parent_ids          assert _DataManager._get(pickle_dn.id).last_edit_date is None          assert _DataManager._get(pickle_dn.id).last_edit_date == pickle_dn.last_edit_date          assert _DataManager._get(pickle_dn.id).job_ids == []          assert _DataManager._get(pickle_dn.id).job_ids == pickle_dn.job_ids          assert not _DataManager._get(pickle_dn.id).is_ready_for_reading          assert _DataManager._get(pickle_dn.id).is_ready_for_reading == pickle_dn.is_ready_for_reading          assert len(_DataManager._get(pickle_dn.id).properties) == 1          assert _DataManager._get(pickle_dn.id).properties == pickle_dn.properties            assert _DataManager._get(pickle_dn) is not None          assert _DataManager._get(pickle_dn).id == pickle_dn.id          assert _DataManager._get(pickle_dn).config_id == \"plop\"          assert _DataManager._get(pickle_dn).config_id == pickle_dn.config_id          assert _DataManager._get(pickle_dn).scope == Scope.CYCLE          assert _DataManager._get(pickle_dn).scope == pickle_dn.scope          assert _DataManager._get(pickle_dn).owner_id is None          assert _DataManager._get(pickle_dn).owner_id == pickle_dn.owner_id          assert _DataManager._get(pickle_dn).parent_ids == {\"task_id_1\", \"task_id_2\"}          assert _DataManager._get(pickle_dn).parent_ids == pickle_dn.parent_ids          assert _DataManager._get(pickle_dn).last_edit_date is None          assert _DataManager._get(pickle_dn).last_edit_date == pickle_dn.last_edit_date          assert _DataManager._get(pickle_dn).job_ids == []          assert _DataManager._get(pickle_dn).job_ids == pickle_dn.job_ids          assert not _DataManager._get(pickle_dn).is_ready_for_reading          assert _DataManager._get(pickle_dn).is_ready_for_reading == pickle_dn.is_ready_for_reading          assert len(_DataManager._get(pickle_dn).properties) == 1          assert _DataManager._get(pickle_dn).properties == pickle_dn.properties        def test_create_raises_exception_with_wrong_type(self):          wrong_type_dn_config = DataNodeConfig(id=\"foo\", storage_type=\"bar\", scope=DataNodeConfig._DEFAULT_SCOPE)          with pytest.raises(InvalidDataNodeType):              _DataManager._create_and_set(wrong_type_dn_config, None, None)        def test_create_from_same_config_generates_new_data_node_and_new_id(self):          dn_config = Config.configure_data_node(id=\"foo\", storage_type=\"in_memory\")          dn = _DataManager._create_and_set(dn_config, None, None)          dn_2 = _DataManager._create_and_set(dn_config, None, None)          assert dn_2.id != dn.id        def test_create_uses_overridden_attributes_in_config_file(self):          Config.override(os.path.join(pathlib.Path(__file__).parent.resolve(), \"data_sample/config.toml\"))            csv_dn_cfg = Config.configure_data_node(id=\"foo\", storage_type=\"csv\", path=\"bar\", has_header=True)          csv_dn = _DataManager._create_and_set(csv_dn_cfg, None, None)          assert csv_dn.config_id == \"foo\"          assert isinstance(csv_dn, CSVDataNode)          assert csv_dn._path == \"path_from_config_file\"          assert csv_dn.has_header            csv_dn_cfg = Config.configure_data_node(id=\"baz\", storage_type=\"csv\", path=\"bar\", has_header=True)          csv_dn = _DataManager._create_and_set(csv_dn_cfg, None, None)          assert csv_dn.config_id == \"baz\"          assert isinstance(csv_dn, CSVDataNode)          assert csv_dn._path == \"bar\"          assert csv_dn.has_header        def test_get_if_not_exists(self):          with pytest.raises(ModelNotFound):              _DataManager._repository._load(\"test_data_node_2\")        def test_get_all(self):          assert len(_DataManager._get_all()) == 0          dn_config_1 = Config.configure_data_node(id=\"foo\", storage_type=\"in_memory\")          _DataManager._create_and_set(dn_config_1, None, None)          assert len(_DataManager._get_all()) == 1          dn_config_2 = Config.configure_data_node(id=\"baz\", storage_type=\"in_memory\")          _DataManager._create_and_set(dn_config_2, None, None)          _DataManager._create_and_set(dn_config_2, None, None)          assert len(_DataManager._get_all()) == 3          assert len([dn for dn in _DataManager._get_all() if dn.config_id == \"foo\"]) == 1          assert len([dn for dn in _DataManager._get_all() if dn.config_id == \"baz\"]) == 2        def test_get_all_on_multiple_versions_environment(self):          # Create 5 data nodes with 2 versions each          # Only version 1.0 has the data node with config_id = \"config_id_1\"          # Only version 2.0 has the data node with config_id = \"config_id_6\"          for version in range(1, 3):              for i in range(5):                  _DataManager._set(                      InMemoryDataNode(                          f\"config_id_{i + version}\",                          Scope.SCENARIO,                          id=DataNodeId(f\"id{i}_v{version}\"),                          version=f\"{version}.0\",                      )                  )            _VersionManager._set_experiment_version(\"1.0\")          assert len(_DataManager._get_all()) == 5          assert len(_DataManager._get_all_by(filters=[{\"version\": \"1.0\", \"config_id\": \"config_id_1\"}])) == 1          assert len(_DataManager._get_all_by(filters=[{\"version\": \"1.0\", \"config_id\": \"config_id_6\"}])) == 0            _VersionManager._set_development_version(\"1.0\")          assert len(_DataManager._get_all()) == 5          assert len(_DataManager._get_all_by(filters=[{\"version\": \"1.0\", \"config_id\": \"config_id_1\"}])) == 1          assert len(_DataManager._get_all_by(filters=[{\"version\": \"1.0\", \"config_id\": \"config_id_6\"}])) == 0            _VersionManager._set_experiment_version(\"2.0\")          assert len(_DataManager._get_all()) == 5          assert len(_DataManager._get_all_by(filters=[{\"version\": \"2.0\", \"config_id\": \"config_id_1\"}])) == 0          assert len(_DataManager._get_all_by(filters=[{\"version\": \"2.0\", \"config_id\": \"config_id_6\"}])) == 1            _VersionManager._set_development_version(\"2.0\")          assert len(_DataManager._get_all()) == 5          assert len(_DataManager._get_all_by(filters=[{\"version\": \"2.0\", \"config_id\": \"config_id_1\"}])) == 0          assert len(_DataManager._get_all_by(filters=[{\"version\": \"2.0\", \"config_id\": \"config_id_6\"}])) == 1        def test_set(self):          dn = InMemoryDataNode(              \"config_id\",              Scope.SCENARIO,              id=DataNodeId(\"id\"),              owner_id=None,              parent_ids={\"task_id_1\"},              last_edit_date=None,              edits=[],              edit_in_progress=False,              properties={\"foo\": \"bar\"},          )          assert len(_DataManager._get_all()) == 0          assert not _DataManager._exists(dn.id)          _DataManager._set(dn)          assert len(_DataManager._get_all()) == 1          assert _DataManager._exists(dn.id)            # changing data node attribute          dn.config_id = \"foo\"          assert dn.config_id == \"foo\"          _DataManager._set(dn)          assert len(_DataManager._get_all()) == 1          assert dn.config_id == \"foo\"          assert _DataManager._get(dn.id).config_id == \"foo\"        def test_delete(self):          dn_1 = InMemoryDataNode(\"config_id\", Scope.SCENARIO, id=\"id_1\")          dn_2 = InMemoryDataNode(\"config_id\", Scope.SCENARIO, id=\"id_2\")          dn_3 = InMemoryDataNode(\"config_id\", Scope.SCENARIO, id=\"id_3\")          assert len(_DataManager._get_all()) == 0          _DataManager._set(dn_1)          _DataManager._set(dn_2)          _DataManager._set(dn_3)          assert len(_DataManager._get_all()) == 3          assert all(_DataManager._exists(dn.id) for dn in [dn_1, dn_2, dn_3])          _DataManager._delete(dn_1.id)          assert len(_DataManager._get_all()) == 2          assert _DataManager._get(dn_2.id).id == dn_2.id          assert _DataManager._get(dn_3.id).id == dn_3.id          assert _DataManager._get(dn_1.id) is None          assert all(_DataManager._exists(dn.id) for dn in [dn_2, dn_3])          assert not _DataManager._exists(dn_1.id)          _DataManager._delete_all()          assert len(_DataManager._get_all()) == 0          assert not any(_DataManager._exists(dn.id) for dn in [dn_2, dn_3])        def test_get_or_create(self):          def _get_or_create_dn(config, *args):              return _DataManager._bulk_get_or_create([config], *args)[config]            _DataManager._delete_all()            global_dn_config = Config.configure_data_node(              id=\"test_data_node\", storage_type=\"in_memory\", scope=Scope.GLOBAL, data=\"In memory Data Node\"          )          cycle_dn_config = Config.configure_data_node(              id=\"test_data_node1\", storage_type=\"in_memory\", scope=Scope.CYCLE, data=\"In memory Data Node\"          )          scenario_dn_config = Config.configure_data_node(              id=\"test_data_node2\", storage_type=\"in_memory\", scope=Scope.SCENARIO, data=\"In memory scenario\"          )            assert len(_DataManager._get_all()) == 0          global_dn = _get_or_create_dn(global_dn_config, None, None)          assert len(_DataManager._get_all()) == 1          global_dn_bis = _get_or_create_dn(global_dn_config, None)          assert len(_DataManager._get_all()) == 1          assert global_dn.id == global_dn_bis.id            scenario_dn = _get_or_create_dn(scenario_dn_config, None, \"scenario_id\")          assert len(_DataManager._get_all()) == 2          scenario_dn_bis = _get_or_create_dn(scenario_dn_config, None, \"scenario_id\")          assert len(_DataManager._get_all()) == 2          assert scenario_dn.id == scenario_dn_bis.id          scenario_dn_ter = _get_or_create_dn(scenario_dn_config, None, \"scenario_id\")          assert len(_DataManager._get_all()) == 2          assert scenario_dn.id == scenario_dn_bis.id          assert scenario_dn_bis.id == scenario_dn_ter.id          scenario_dn_quater = _get_or_create_dn(scenario_dn_config, None, \"scenario_id_2\")          assert len(_DataManager._get_all()) == 3          assert scenario_dn.id == scenario_dn_bis.id          assert scenario_dn_bis.id == scenario_dn_ter.id          assert scenario_dn_ter.id != scenario_dn_quater.id            assert len(_DataManager._get_all()) == 3          cycle_dn = _get_or_create_dn(cycle_dn_config, \"cycle_id\", None)          assert len(_DataManager._get_all()) == 4          cycle_dn_1 = _get_or_create_dn(cycle_dn_config, \"cycle_id\", None)          assert len(_DataManager._get_all()) == 4          assert cycle_dn.id == cycle_dn_1.id          cycle_dn_2 = _get_or_create_dn(cycle_dn_config, \"cycle_id\", \"scenario_id\")          assert len(_DataManager._get_all()) == 4          assert cycle_dn.id == cycle_dn_2.id          cycle_dn_3 = _get_or_create_dn(cycle_dn_config, \"cycle_id\", None)          assert len(_DataManager._get_all()) == 4          assert cycle_dn.id == cycle_dn_3.id          cycle_dn_4 = _get_or_create_dn(cycle_dn_config, \"cycle_id\", \"scenario_id\")          assert len(_DataManager._get_all()) == 4          assert cycle_dn.id == cycle_dn_4.id          cycle_dn_5 = _get_or_create_dn(cycle_dn_config, \"cycle_id\", \"scenario_id_2\")          assert len(_DataManager._get_all()) == 4          assert cycle_dn.id == cycle_dn_5.id            assert cycle_dn_1.id == cycle_dn_2.id          assert cycle_dn_2.id == cycle_dn_3.id          assert cycle_dn_3.id == cycle_dn_4.id          assert cycle_dn_4.id == cycle_dn_5.id        def test_ensure_persistence_of_data_node(self):          dm = _DataManager()          dm._delete_all()            dn_config_1 = Config.configure_data_node(              id=\"data_node_1\", storage_type=\"in_memory\", data=\"In memory sequence 2\"          )          dn_config_2 = Config.configure_data_node(              id=\"data_node_2\", storage_type=\"in_memory\", data=\"In memory sequence 2\"          )            dm._bulk_get_or_create([dn_config_1, dn_config_2])            assert len(dm._get_all()) == 2            # Delete the DataManager to ensure it's get from the storage system          del dm          dm = _DataManager()          dm._bulk_get_or_create([dn_config_1])          assert len(dm._get_all()) == 2            dm._delete_all()        def test_clean_generated_pickle_files(self, pickle_file_path):          user_pickle_dn_config = Config.configure_data_node(              id=\"d1\", storage_type=\"pickle\", path=pickle_file_path, default_data=\"d\"          )          generated_pickle_dn_1_config = Config.configure_data_node(id=\"d2\", storage_type=\"pickle\", default_data=\"d\")          generated_pickle_dn_2_config = Config.configure_data_node(id=\"d3\", storage_type=\"pickle\", default_data=\"d\")            dns = _DataManager._bulk_get_or_create(              [user_pickle_dn_config, generated_pickle_dn_1_config, generated_pickle_dn_2_config]          )            user_pickle_dn = dns[user_pickle_dn_config]          generated_pickle_dn_1 = dns[generated_pickle_dn_1_config]          generated_pickle_dn_2 = dns[generated_pickle_dn_2_config]            _DataManager._clean_pickle_file(user_pickle_dn.id)          assert file_exists(user_pickle_dn.path)            _DataManager._clean_pickle_files([generated_pickle_dn_1, generated_pickle_dn_2])          assert not file_exists(generated_pickle_dn_1.path)          assert not file_exists(generated_pickle_dn_2.path)        def test_delete_does_clean_generated_pickle_files(self, pickle_file_path):          user_pickle_dn_config = Config.configure_data_node(              id=\"d1\", storage_type=\"pickle\", path=pickle_file_path, default_data=\"d\"          )          generated_pickle_dn_config_1 = Config.configure_data_node(id=\"d2\", storage_type=\"pickle\", default_data=\"d\")          generated_pickle_dn_config_2 = Config.configure_data_node(id=\"d3\", storage_type=\"pickle\", default_data=\"d\")          generated_pickle_dn_config_3 = Config.configure_data_node(id=\"d4\", storage_type=\"pickle\", default_data=\"d\")            dns = _DataManager._bulk_get_or_create(              [                  user_pickle_dn_config,                  generated_pickle_dn_config_1,                  generated_pickle_dn_config_2,                  generated_pickle_dn_config_3,              ]          )            user_pickle_dn = dns[user_pickle_dn_config]          generated_pickle_dn_1 = dns[generated_pickle_dn_config_1]          generated_pickle_dn_2 = dns[generated_pickle_dn_config_2]          generated_pickle_dn_3 = dns[generated_pickle_dn_config_3]            _DataManager._delete(user_pickle_dn.id)          assert file_exists(user_pickle_dn.path)            _DataManager._delete_many([generated_pickle_dn_1.id, generated_pickle_dn_2.id])          assert not file_exists(generated_pickle_dn_1.path)          assert not file_exists(generated_pickle_dn_2.path)            _DataManager._delete_all()          assert not file_exists(generated_pickle_dn_3.path)        def test_create_dn_from_loaded_config_no_scope(self):          file_config = NamedTemporaryFile(              \"\"\"              [TAIPY]                [DATA_NODE.a]              default_data = \"4:int\"                [DATA_NODE.b]                [TASK.t]              function = \"math.sqrt:function\"              inputs = [ \"a:SECTION\",]              outputs = [ \"b:SECTION\",]              skippable = \"False:bool\"                [SCENARIO.s]              tasks = [ \"t:SECTION\",]              sequences.s_sequence = [ \"t:SECTION\",]                [SCENARIO.s.comparators]              \"\"\"          )          from src.taipy import core as tp            Config.override(file_config.filename)          tp.create_scenario(Config.scenarios[\"s\"])          tp.create_scenario(Config.scenarios[\"s\"])            assert len(tp.get_data_nodes()) == 4        def test_create_dn_from_loaded_config_no_storage_type(self):          file_config = NamedTemporaryFile(              \"\"\"              [TAIPY]                [DATA_NODE.input]              scope = \"SCENARIO:SCOPE\"              default_data = \"21:int\"                [DATA_NODE.output]              storage_type = \"in_memory\"              scope = \"SCENARIO:SCOPE\"                [TASK.double]              inputs = [ \"input:SECTION\",]              function = \"math.sqrt:function\"              outputs = [ \"output:SECTION\",]              skippable = \"False:bool\"                [SCENARIO.my_scenario]              tasks = [ \"double:SECTION\",]              sequences.my_sequence = [ \"double:SECTION\",]                [SCENARIO.my_scenario.comparators]              \"\"\"          )          from src.taipy import core as tp            Config.override(file_config.filename)          scenario = tp.create_scenario(Config.scenarios[\"my_scenario\"])            assert isinstance(scenario.input, PickleDataNode)          assert isinstance(scenario.output, InMemoryDataNode)        def test_create_dn_from_loaded_config_modified_default_config(self):          file_config = NamedTemporaryFile(              \"\"\"              [TAIPY]                [DATA_NODE.input]              scope = \"SCENARIO:SCOPE\"              default_path=\"fake/path.csv\"                [DATA_NODE.output]              storage_type = \"in_memory\"              scope = \"SCENARIO:SCOPE\"                [TASK.double]              inputs = [ \"input:SECTION\",]              function = \"math.sqrt:function\"              outputs = [ \"output:SECTION\",]              skippable = \"False:bool\"                [SCENARIO.my_scenario]              tasks = [ \"double:SECTION\",]              sequences.my_sequence = [ \"double:SECTION\",]                [SCENARIO.my_scenario.comparators]              \"\"\"          )          from src.taipy import core as tp            Config.set_default_data_node_configuration(storage_type=\"csv\")          Config.override(file_config.filename)          scenario = tp.create_scenario(Config.scenarios[\"my_scenario\"])            assert isinstance(scenario.input, CSVDataNode)          assert isinstance(scenario.output, InMemoryDataNode)        def test_get_tasks_by_config_id(self):          dn_config_1 = Config.configure_data_node(\"dn_1\", scope=Scope.SCENARIO)          dn_config_2 = Config.configure_data_node(\"dn_2\", scope=Scope.SCENARIO)          dn_config_3 = Config.configure_data_node(\"dn_3\", scope=Scope.SCENARIO)            dn_1_1 = _DataManager._create_and_set(dn_config_1, None, None)          dn_1_2 = _DataManager._create_and_set(dn_config_1, None, None)          dn_1_3 = _DataManager._create_and_set(dn_config_1, None, None)          assert len(_DataManager._get_all()) == 3            dn_2_1 = _DataManager._create_and_set(dn_config_2, None, None)          dn_2_2 = _DataManager._create_and_set(dn_config_2, None, None)          assert len(_DataManager._get_all()) == 5            dn_3_1 = _DataManager._create_and_set(dn_config_3, None, None)          assert len(_DataManager._get_all()) == 6            dn_1_datanodes = _DataManager._get_by_config_id(dn_config_1.id)          assert len(dn_1_datanodes) == 3          assert sorted([dn_1_1.id, dn_1_2.id, dn_1_3.id]) == sorted([sequence.id for sequence in dn_1_datanodes])            dn_2_datanodes = _DataManager._get_by_config_id(dn_config_2.id)          assert len(dn_2_datanodes) == 2          assert sorted([dn_2_1.id, dn_2_2.id]) == sorted([sequence.id for sequence in dn_2_datanodes])            dn_3_datanodes = _DataManager._get_by_config_id(dn_config_3.id)          assert len(dn_3_datanodes) == 1          assert sorted([dn_3_1.id]) == sorted([sequence.id for sequence in dn_3_datanodes])        def test_get_data_nodes_by_config_id_in_multiple_versions_environment(self):          dn_config_1 = Config.configure_data_node(\"dn_1\", scope=Scope.SCENARIO)          dn_config_2 = Config.configure_data_node(\"dn_2\", scope=Scope.SCENARIO)            _VersionManager._set_experiment_version(\"1.0\")          _DataManager._create_and_set(dn_config_1, None, None)          _DataManager._create_and_set(dn_config_1, None, None)          _DataManager._create_and_set(dn_config_1, None, None)          _DataManager._create_and_set(dn_config_2, None, None)          _DataManager._create_and_set(dn_config_2, None, None)            assert len(_DataManager._get_by_config_id(dn_config_1.id)) == 3          assert len(_DataManager._get_by_config_id(dn_config_2.id)) == 2            _VersionManager._set_experiment_version(\"2.0\")          _DataManager._create_and_set(dn_config_1, None, None)          _DataManager._create_and_set(dn_config_1, None, None)          _DataManager._create_and_set(dn_config_1, None, None)          _DataManager._create_and_set(dn_config_2, None, None)          _DataManager._create_and_set(dn_config_2, None, None)            assert len(_DataManager._get_by_config_id(dn_config_1.id)) == 3          assert len(_DataManager._get_by_config_id(dn_config_2.id)) == 2 "}
{"text": "from typing import Dict, List    import numpy as np  import pandas as pd  import pytest    from src.taipy.core.data.operator import JoinOperator, Operator    from .utils import (      CustomClass,      FakeCustomDataNode,      FakeDataframeDataNode,      FakeDataNode,      FakeListDataNode,      FakeMultiSheetExcelCustomDataNode,      FakeMultiSheetExcelDataFrameDataNode,      FakeNumpyarrayDataNode,  )      def test_filter_pandas_exposed_type(default_data_frame):      dn = FakeDataNode(\"fake_dn\")      dn.write(\"Any data\")        with pytest.raises(NotImplementedError):          dn.filter(((\"any\", 0, Operator.EQUAL)), JoinOperator.OR)      with pytest.raises(NotImplementedError):          dn.filter(((\"any\", 0, Operator.NOT_EQUAL)), JoinOperator.OR)      with pytest.raises(NotImplementedError):          dn.filter(((\"any\", 0, Operator.LESS_THAN)), JoinOperator.AND)      with pytest.raises(NotImplementedError):          dn.filter(((\"any\", 0, Operator.LESS_OR_EQUAL)), JoinOperator.AND)      with pytest.raises(NotImplementedError):          dn.filter(((\"any\", 0, Operator.GREATER_THAN)))      with pytest.raises(NotImplementedError):          dn.filter((\"any\", 0, Operator.GREATER_OR_EQUAL))        df_dn = FakeDataframeDataNode(\"fake_dataframe_dn\", default_data_frame)        COLUMN_NAME_1 = \"a\"      COLUMN_NAME_2 = \"b\"      assert len(df_dn.filter((COLUMN_NAME_1, 1, Operator.EQUAL))) == len(          default_data_frame[default_data_frame[COLUMN_NAME_1] == 1]      )      assert len(df_dn.filter((COLUMN_NAME_1, 1, Operator.NOT_EQUAL))) == len(          default_data_frame[default_data_frame[COLUMN_NAME_1] != 1]      )      assert len(df_dn.filter([(COLUMN_NAME_1, 1, Operator.EQUAL)])) == len(          default_data_frame[default_data_frame[COLUMN_NAME_1] == 1]      )      assert len(df_dn.filter([(COLUMN_NAME_1, 1, Operator.NOT_EQUAL)])) == len(          default_data_frame[default_data_frame[COLUMN_NAME_1] != 1]      )      assert len(df_dn.filter([(COLUMN_NAME_1, 1, Operator.LESS_THAN)])) == len(          default_data_frame[default_data_frame[COLUMN_NAME_1] < 1]      )      assert len(df_dn.filter([(COLUMN_NAME_1, 1, Operator.LESS_OR_EQUAL)])) == len(          default_data_frame[default_data_frame[COLUMN_NAME_1] <= 1]      )      assert len(df_dn.filter([(COLUMN_NAME_1, 1, Operator.GREATER_THAN)])) == len(          default_data_frame[default_data_frame[COLUMN_NAME_1] > 1]      )      assert len(df_dn.filter([(COLUMN_NAME_1, 1, Operator.GREATER_OR_EQUAL)])) == len(          default_data_frame[default_data_frame[COLUMN_NAME_1] >= 1]      )      assert len(df_dn.filter([(COLUMN_NAME_1, -1000, Operator.LESS_OR_EQUAL)])) == 0      assert len(df_dn.filter([(COLUMN_NAME_1, 1000, Operator.GREATER_OR_EQUAL)])) == 0      assert len(df_dn.filter([(COLUMN_NAME_1, 4, Operator.EQUAL), (COLUMN_NAME_1, 5, Operator.EQUAL)])) == len(          default_data_frame[(default_data_frame[COLUMN_NAME_1] == 4) & (default_data_frame[COLUMN_NAME_1] == 5)]      )      assert len(          df_dn.filter([(COLUMN_NAME_1, 4, Operator.EQUAL), (COLUMN_NAME_2, 5, Operator.EQUAL)], JoinOperator.OR)      ) == len(default_data_frame[(default_data_frame[COLUMN_NAME_1] == 4) | (default_data_frame[COLUMN_NAME_2] == 5)])      assert len(          df_dn.filter(              [(COLUMN_NAME_1, 1, Operator.GREATER_THAN), (COLUMN_NAME_2, 3, Operator.GREATER_THAN)], JoinOperator.AND          )      ) == len(default_data_frame[(default_data_frame[COLUMN_NAME_1] > 1) & (default_data_frame[COLUMN_NAME_2] > 3)])      assert len(          df_dn.filter(              [(COLUMN_NAME_1, 2, Operator.GREATER_THAN), (COLUMN_NAME_1, 3, Operator.GREATER_THAN)], JoinOperator.OR          )      ) == len(default_data_frame[(default_data_frame[COLUMN_NAME_1] > 2) | (default_data_frame[COLUMN_NAME_1] > 3)])      assert len(          df_dn.filter(              [(COLUMN_NAME_1, 10, Operator.GREATER_THAN), (COLUMN_NAME_1, -10, Operator.LESS_THAN)], JoinOperator.AND          )      ) == len(default_data_frame[(default_data_frame[COLUMN_NAME_1] > 10) | (default_data_frame[COLUMN_NAME_1] < -10)])      assert len(          df_dn.filter(              [(COLUMN_NAME_1, 10, Operator.GREATER_THAN), (COLUMN_NAME_1, -10, Operator.LESS_THAN)], JoinOperator.OR          )      ) == len(default_data_frame[(default_data_frame[COLUMN_NAME_1] > 10) | (default_data_frame[COLUMN_NAME_1] < -10)])      def test_filter_list():      list_dn = FakeListDataNode(\"fake_list_dn\")        KEY_NAME = \"value\"        assert len(list_dn.filter((KEY_NAME, 4, Operator.EQUAL))) == 1      assert len(list_dn.filter((KEY_NAME, 4, Operator.NOT_EQUAL))) == 9      assert len(list_dn.filter([(KEY_NAME, 4, Operator.EQUAL)])) == 1      assert len(list_dn.filter([(KEY_NAME, 4, Operator.NOT_EQUAL)])) == 9      assert len(list_dn.filter([(KEY_NAME, 4, Operator.LESS_THAN)])) == 4      assert len(list_dn.filter([(KEY_NAME, 4, Operator.LESS_OR_EQUAL)])) == 5      assert len(list_dn.filter([(KEY_NAME, 4, Operator.GREATER_THAN)])) == 5      assert len(list_dn.filter([(KEY_NAME, 4, Operator.GREATER_OR_EQUAL)])) == 6      assert len(list_dn.filter([(KEY_NAME, -1000, Operator.LESS_OR_EQUAL)])) == 0      assert len(list_dn.filter([(KEY_NAME, 1000, Operator.GREATER_OR_EQUAL)])) == 0        assert len(list_dn.filter([(KEY_NAME, 4, Operator.EQUAL), (KEY_NAME, 5, Operator.EQUAL)])) == 0      assert len(list_dn.filter([(KEY_NAME, 4, Operator.EQUAL), (KEY_NAME, 5, Operator.EQUAL)], JoinOperator.OR)) == 2      assert len(list_dn.filter([(KEY_NAME, 4, Operator.EQUAL), (KEY_NAME, 11, Operator.EQUAL)], JoinOperator.AND)) == 0      assert len(list_dn.filter([(KEY_NAME, 4, Operator.EQUAL), (KEY_NAME, 11, Operator.EQUAL)], JoinOperator.OR)) == 1        assert (          len(list_dn.filter([(KEY_NAME, -10, Operator.LESS_OR_EQUAL), (KEY_NAME, 11, Operator.GREATER_OR_EQUAL)])) == 0      )      assert (          len(              list_dn.filter(                  [                      (KEY_NAME, 4, Operator.GREATER_OR_EQUAL),                      (KEY_NAME, 6, Operator.GREATER_OR_EQUAL),                  ],                  JoinOperator.AND,              )          )          == 4      )      assert (          len(              list_dn.filter(                  [                      (KEY_NAME, 4, Operator.GREATER_OR_EQUAL),                      (KEY_NAME, 6, Operator.GREATER_OR_EQUAL),                      (KEY_NAME, 11, Operator.EQUAL),                  ],                  JoinOperator.AND,              )          )          == 0      )      assert (          len(              list_dn.filter(                  [                      (KEY_NAME, 4, Operator.GREATER_OR_EQUAL),                      (KEY_NAME, 6, Operator.GREATER_OR_EQUAL),                      (KEY_NAME, 11, Operator.EQUAL),                  ],                  JoinOperator.OR,              )          )          == 6      )      def test_filter_numpy_exposed_type(default_data_frame):      default_array = default_data_frame.to_numpy()        df_dn = FakeNumpyarrayDataNode(\"fake_dataframe_dn\", default_array)        assert len(df_dn.filter((0, 1, Operator.EQUAL))) == len(default_array[default_array[:, 0] == 1])      assert len(df_dn.filter((0, 1, Operator.NOT_EQUAL))) == len(default_array[default_array[:, 0] != 1])      assert len(df_dn.filter([(0, 1, Operator.EQUAL)])) == len(default_array[default_array[:, 0] == 1])      assert len(df_dn.filter([(0, 1, Operator.NOT_EQUAL)])) == len(default_array[default_array[:, 0] != 1])      assert len(df_dn.filter([(0, 1, Operator.LESS_THAN)])) == len(default_array[default_array[:, 0] < 1])      assert len(df_dn.filter([(0, 1, Operator.LESS_OR_EQUAL)])) == len(default_array[default_array[:, 0] <= 1])      assert len(df_dn.filter([(0, 1, Operator.GREATER_THAN)])) == len(default_array[default_array[:, 0] > 1])      assert len(df_dn.filter([(0, 1, Operator.GREATER_OR_EQUAL)])) == len(default_array[default_array[:, 0] >= 1])      assert len(df_dn.filter([(0, -1000, Operator.LESS_OR_EQUAL)])) == 0      assert len(df_dn.filter([(0, 1000, Operator.GREATER_OR_EQUAL)])) == 0      assert len(df_dn.filter([(0, 4, Operator.EQUAL), (0, 5, Operator.EQUAL)])) == len(          default_array[(default_array[:, 0] == 4) & (default_array[:, 0] == 5)]      )      assert len(df_dn.filter([(0, 4, Operator.EQUAL), (1, 5, Operator.EQUAL)], JoinOperator.OR)) == len(          default_array[(default_array[:, 0] == 4) | (default_array[:, 1] == 5)]      )      assert len(df_dn.filter([(0, 1, Operator.GREATER_THAN), (1, 3, Operator.GREATER_THAN)], JoinOperator.AND)) == len(          default_array[(default_array[:, 0] > 1) & (default_array[:, 1] > 3)]      )      assert len(df_dn.filter([(0, 2, Operator.GREATER_THAN), (0, 3, Operator.GREATER_THAN)], JoinOperator.OR)) == len(          default_array[(default_array[:, 0] > 2) | (default_array[:, 0] > 3)]      )      assert len(df_dn.filter([(0, 10, Operator.GREATER_THAN), (0, -10, Operator.LESS_THAN)], JoinOperator.AND)) == len(          default_array[(default_array[:, 0] > 10) | (default_array[:, 0] < -10)]      )      assert len(df_dn.filter([(0, 10, Operator.GREATER_THAN), (0, -10, Operator.LESS_THAN)], JoinOperator.OR)) == len(          default_array[(default_array[:, 0] > 10) | (default_array[:, 0] < -10)]      )      def test_filter_by_get_item(default_data_frame):      # get item for DataFrame data_type      default_data_frame[1] = [100, 100]      df_dn = FakeDataframeDataNode(\"fake_dataframe_dn\", default_data_frame)        filtered_df_dn = df_dn[\"a\"]      assert isinstance(filtered_df_dn, pd.Series)      assert len(filtered_df_dn) == len(default_data_frame[\"a\"])      assert filtered_df_dn.to_dict() == default_data_frame[\"a\"].to_dict()        filtered_df_dn = df_dn[1]      assert isinstance(filtered_df_dn, pd.Series)      assert len(filtered_df_dn) == len(default_data_frame[1])      assert filtered_df_dn.to_dict() == default_data_frame[1].to_dict()        filtered_df_dn = df_dn[0:2]      assert isinstance(filtered_df_dn, pd.DataFrame)      assert filtered_df_dn.shape == default_data_frame[0:2].shape      assert len(filtered_df_dn) == 2        bool_df = default_data_frame.copy(deep=True) > 4      filtered_df_dn = df_dn[bool_df]      assert isinstance(filtered_df_dn, pd.DataFrame)        bool_1d_index = [True, False]      filtered_df_dn = df_dn[bool_1d_index]      assert isinstance(filtered_df_dn, pd.DataFrame)      assert filtered_df_dn.to_dict() == default_data_frame[bool_1d_index].to_dict()      assert len(filtered_df_dn) == 1        filtered_df_dn = df_dn[[\"a\", \"b\"]]      assert isinstance(filtered_df_dn, pd.DataFrame)      assert filtered_df_dn.shape == default_data_frame[[\"a\", \"b\"]].shape      assert filtered_df_dn.to_dict() == default_data_frame[[\"a\", \"b\"]].to_dict()        # get item for custom data_type      custom_dn = FakeCustomDataNode(\"fake_custom_dn\")        filtered_custom_dn = custom_dn[\"a\"]      assert isinstance(filtered_custom_dn, List)      assert len(filtered_custom_dn) == 10      assert filtered_custom_dn == [i for i in range(10)]        filtered_custom_dn = custom_dn[0:5]      assert isinstance(filtered_custom_dn, List)      assert all([isinstance(x, CustomClass) for x in filtered_custom_dn])      assert len(filtered_custom_dn) == 5        bool_1d_index = [True if i < 5 else False for i in range(10)]      filtered_custom_dn = custom_dn[bool_1d_index]      assert isinstance(filtered_custom_dn, List)      assert len(filtered_custom_dn) == 5      assert filtered_custom_dn == custom_dn._read()[:5]        filtered_custom_dn = custom_dn[[\"a\", \"b\"]]      assert isinstance(filtered_custom_dn, List)      assert all([isinstance(x, Dict) for x in filtered_custom_dn])      assert len(filtered_custom_dn) == 10      assert filtered_custom_dn == [{\"a\": i, \"b\": i * 2} for i in range(10)]        # get item for Multi-sheet Excel data_type      multi_sheet_excel_df_dn = FakeMultiSheetExcelDataFrameDataNode(\"fake_multi_sheet_excel_df_dn\", default_data_frame)      filtered_multi_sheet_excel_df_dn = multi_sheet_excel_df_dn[\"Sheet1\"]      assert isinstance(filtered_multi_sheet_excel_df_dn, pd.DataFrame)      assert len(filtered_multi_sheet_excel_df_dn) == len(default_data_frame)      assert np.array_equal(filtered_multi_sheet_excel_df_dn.to_numpy(), default_data_frame.to_numpy())        multi_sheet_excel_custom_dn = FakeMultiSheetExcelCustomDataNode(\"fake_multi_sheet_excel_df_dn\")      filtered_multi_sheet_excel_custom_dn = multi_sheet_excel_custom_dn[\"Sheet1\"]      assert isinstance(filtered_multi_sheet_excel_custom_dn, List)      assert len(filtered_multi_sheet_excel_custom_dn) == 10      expected_value = [CustomClass(i, i * 2) for i in range(10)]      assert all(          [              expected.a == filtered.a and expected.b == filtered.b              for expected, filtered in zip(expected_value, filtered_multi_sheet_excel_custom_dn)          ]      ) "}
{"text": "import os  import pathlib  from datetime import datetime  from importlib import util  from time import sleep    import modin.pandas as modin_pd  import numpy as np  import pandas as pd  import pytest  from modin.pandas.test.utils import df_equals  from pandas.testing import assert_frame_equal    from src.taipy.core.data._data_manager import _DataManager  from src.taipy.core.data.data_node_id import DataNodeId  from src.taipy.core.data.operator import JoinOperator, Operator  from src.taipy.core.data.parquet import ParquetDataNode  from src.taipy.core.exceptions.exceptions import (      InvalidExposedType,      NoData,      UnknownCompressionAlgorithm,      UnknownParquetEngine,  )  from taipy.config.common.scope import Scope  from taipy.config.config import Config  from taipy.config.exceptions.exceptions import InvalidConfigurationId      @pytest.fixture(scope=\"function\", autouse=True)  def cleanup():      yield      path = os.path.join(pathlib.Path(__file__).parent.resolve(), \"data_sample/temp.parquet\")      if os.path.isfile(path):          os.remove(path)      class MyCustomObject:      def __init__(self, id, integer, text):          self.id = id          self.integer = integer          self.text = text      class MyOtherCustomObject:      def __init__(self, id, sentence):          self.id = id          self.sentence = sentence      def create_custom_class(**kwargs):      return MyOtherCustomObject(id=kwargs[\"id\"], sentence=kwargs[\"text\"])      class TestParquetDataNode:      __engine = [\"pyarrow\"]      if util.find_spec(\"fastparquet\"):          __engine.append(\"fastparquet\")        def test_create(self):          path = \"data/node/path\"          compression = \"snappy\"          dn = ParquetDataNode(              \"foo_bar\", Scope.SCENARIO, properties={\"path\": path, \"compression\": compression, \"name\": \"super name\"}          )          assert isinstance(dn, ParquetDataNode)          assert dn.storage_type() == \"parquet\"          assert dn.config_id == \"foo_bar\"          assert dn.name == \"super name\"          assert dn.scope == Scope.SCENARIO          assert dn.id is not None          assert dn.owner_id is None          assert dn.last_edit_date is None          assert dn.job_ids == []          assert not dn.is_ready_for_reading          assert dn.path == path          assert dn.exposed_type == \"pandas\"          assert dn.compression == \"snappy\"          assert dn.engine == \"pyarrow\"            with pytest.raises(InvalidConfigurationId):              dn = ParquetDataNode(\"foo bar\", Scope.SCENARIO, properties={\"path\": path, \"name\": \"super name\"})        def test_get_user_properties(self, parquet_file_path):          dn_1 = ParquetDataNode(\"dn_1\", Scope.SCENARIO, properties={\"path\": parquet_file_path})          assert dn_1._get_user_properties() == {}            dn_2 = ParquetDataNode(              \"dn_2\",              Scope.SCENARIO,              properties={                  \"exposed_type\": \"numpy\",                  \"default_data\": \"foo\",                  \"default_path\": parquet_file_path,                  \"engine\": \"pyarrow\",                  \"compression\": \"snappy\",                  \"read_kwargs\": {\"columns\": [\"a\", \"b\"]},                  \"write_kwargs\": {\"index\": False},                  \"foo\": \"bar\",              },          )            # exposed_type, default_data, default_path, path, engine, compression, read_kwargs, write_kwargs          # are filtered out          assert dn_2._get_user_properties() == {\"foo\": \"bar\"}        def test_new_parquet_data_node_with_existing_file_is_ready_for_reading(self, parquet_file_path):          not_ready_dn_cfg = Config.configure_data_node(              \"not_ready_data_node_config_id\", \"parquet\", path=\"NOT_EXISTING.parquet\"          )          not_ready_dn = _DataManager._bulk_get_or_create([not_ready_dn_cfg])[not_ready_dn_cfg]          assert not not_ready_dn.is_ready_for_reading            ready_dn_cfg = Config.configure_data_node(\"ready_data_node_config_id\", \"parquet\", path=parquet_file_path)          ready_dn = _DataManager._bulk_get_or_create([ready_dn_cfg])[ready_dn_cfg]          assert ready_dn.is_ready_for_reading        @pytest.mark.parametrize(          [\"properties\", \"exists\"],          [              ({}, False),              ({\"default_data\": {\"a\": [\"foo\", \"bar\"]}}, True),          ],      )      def test_create_with_default_data(self, properties, exists):          dn = ParquetDataNode(\"foo\", Scope.SCENARIO, DataNodeId(\"dn_id\"), properties=properties)          assert os.path.exists(dn.path) is exists        @pytest.mark.parametrize(\"engine\", __engine)      def test_read_file(self, engine, parquet_file_path):          not_existing_parquet = ParquetDataNode(              \"foo\", Scope.SCENARIO, properties={\"path\": \"nonexistent.parquet\", \"engine\": engine}          )          with pytest.raises(NoData):              assert not_existing_parquet.read() is None              not_existing_parquet.read_or_raise()            df = pd.read_parquet(parquet_file_path)          # Create ParquetDataNode without exposed_type (Default is pandas.DataFrame)          parquet_data_node_as_pandas = ParquetDataNode(              \"bar\", Scope.SCENARIO, properties={\"path\": parquet_file_path, \"engine\": engine}          )          data_pandas = parquet_data_node_as_pandas.read()          assert isinstance(data_pandas, pd.DataFrame)          assert len(data_pandas) == 2          assert data_pandas.equals(df)          assert np.array_equal(data_pandas.to_numpy(), df.to_numpy())            # Create ParquetDataNode with modin exposed_type          parquet_data_node_as_modin = ParquetDataNode(              \"bar\", Scope.SCENARIO, properties={\"path\": parquet_file_path, \"exposed_type\": \"modin\", \"engine\": engine}          )          data_modin = parquet_data_node_as_modin.read()          assert isinstance(data_modin, modin_pd.DataFrame)          assert len(data_modin) == 2          assert data_modin.equals(df)          assert np.array_equal(data_modin.to_numpy(), df.to_numpy())            # Create ParquetDataNode with numpy exposed_type          parquet_data_node_as_numpy = ParquetDataNode(              \"bar\", Scope.SCENARIO, properties={\"path\": parquet_file_path, \"exposed_type\": \"numpy\", \"engine\": engine}          )          data_numpy = parquet_data_node_as_numpy.read()          assert isinstance(data_numpy, np.ndarray)          assert len(data_numpy) == 2          assert np.array_equal(data_numpy, df.to_numpy())        @pytest.mark.parametrize(\"engine\", __engine)      def test_read_folder(self, engine):          parquet_folder_path = os.path.join(pathlib.Path(__file__).parent.resolve(), \"data_sample/parquet_example\")            df = pd.read_parquet(parquet_folder_path)          parquet_data_node_as_pandas = ParquetDataNode(              \"bar\", Scope.SCENARIO, properties={\"path\": parquet_folder_path, \"engine\": engine}          )          data_pandas = parquet_data_node_as_pandas.read()          assert isinstance(data_pandas, pd.DataFrame)          assert len(data_pandas) == 5          assert data_pandas.equals(df)          assert np.array_equal(data_pandas.to_numpy(), df.to_numpy())        def test_set_path(self):          dn = ParquetDataNode(\"foo\", Scope.SCENARIO, properties={\"path\": \"foo.parquet\"})          assert dn.path == \"foo.parquet\"          dn.path = \"bar.parquet\"          assert dn.path == \"bar.parquet\"        @pytest.mark.parametrize(\"engine\", __engine)      def test_read_write_after_modify_path(self, engine):          path = os.path.join(pathlib.Path(__file__).parent.resolve(), \"data_sample/example.parquet\")          new_path = os.path.join(pathlib.Path(__file__).parent.resolve(), \"data_sample/temp.parquet\")          dn = ParquetDataNode(\"foo\", Scope.SCENARIO, properties={\"path\": path, \"engine\": engine})          read_data = dn.read()          assert read_data is not None          dn.path = new_path          with pytest.raises(FileNotFoundError):              dn.read()          dn.write(read_data)          assert dn.read().equals(read_data)        def test_read_custom_exposed_type(self):          example_parquet_path = os.path.join(pathlib.Path(__file__).parent.resolve(), \"data_sample/example.parquet\")            dn = ParquetDataNode(              \"foo\", Scope.SCENARIO, properties={\"path\": example_parquet_path, \"exposed_type\": MyCustomObject}          )          assert all([isinstance(obj, MyCustomObject) for obj in dn.read()])            dn = ParquetDataNode(              \"foo\", Scope.SCENARIO, properties={\"path\": example_parquet_path, \"exposed_type\": create_custom_class}          )          assert all([isinstance(obj, MyOtherCustomObject) for obj in dn.read()])        def test_raise_error_unknown_parquet_engine(self):          path = os.path.join(pathlib.Path(__file__).parent.resolve(), \"data_sample/example.parquet\")          with pytest.raises(UnknownParquetEngine):              ParquetDataNode(\"foo\", Scope.SCENARIO, properties={\"path\": path, \"engine\": \"foo\"})        def test_raise_error_unknown_compression_algorithm(self):          path = os.path.join(pathlib.Path(__file__).parent.resolve(), \"data_sample/example.parquet\")          with pytest.raises(UnknownCompressionAlgorithm):              ParquetDataNode(\"foo\", Scope.SCENARIO, properties={\"path\": path, \"compression\": \"foo\"})        def test_raise_error_invalid_exposed_type(self):          path = os.path.join(pathlib.Path(__file__).parent.resolve(), \"data_sample/example.parquet\")          with pytest.raises(InvalidExposedType):              ParquetDataNode(\"foo\", Scope.SCENARIO, properties={\"path\": path, \"exposed_type\": \"foo\"})        def test_read_empty_data(self, tmpdir_factory):          temp_file_path = str(tmpdir_factory.mktemp(\"data\").join(\"temp.parquet\"))          empty_df = pd.DataFrame([])          empty_df.to_parquet(temp_file_path)            # Pandas          dn = ParquetDataNode(\"foo\", Scope.SCENARIO, properties={\"path\": temp_file_path, \"exposed_type\": \"pandas\"})          assert dn.read().equals(empty_df)            # Numpy          dn = ParquetDataNode(\"foo\", Scope.SCENARIO, properties={\"path\": temp_file_path, \"exposed_type\": \"numpy\"})          assert np.array_equal(dn.read(), empty_df.to_numpy())            # Custom          dn = ParquetDataNode(\"foo\", Scope.SCENARIO, properties={\"path\": temp_file_path, \"exposed_type\": MyCustomObject})          assert dn.read() == []        def test_get_system_file_modified_date_instead_of_last_edit_date(self, tmpdir_factory):          temp_file_path = str(tmpdir_factory.mktemp(\"data\").join(\"temp.parquet\"))          pd.DataFrame([]).to_parquet(temp_file_path)          dn = ParquetDataNode(\"foo\", Scope.SCENARIO, properties={\"path\": temp_file_path, \"exposed_type\": \"pandas\"})            dn.write(pd.DataFrame(data={\"col1\": [1, 2], \"col2\": [3, 4]}))          previous_edit_date = dn.last_edit_date            sleep(0.1)            pd.DataFrame(pd.DataFrame(data={\"col1\": [5, 6], \"col2\": [7, 8]})).to_parquet(temp_file_path)          new_edit_date = datetime.fromtimestamp(os.path.getmtime(temp_file_path))            assert previous_edit_date < dn.last_edit_date          assert new_edit_date == dn.last_edit_date            sleep(0.1)            dn.write(pd.DataFrame(data={\"col1\": [9, 10], \"col2\": [10, 12]}))          assert new_edit_date < dn.last_edit_date          os.unlink(temp_file_path)        def test_get_system_folder_modified_date_instead_of_last_edit_date(self, tmpdir_factory):          temp_folder_path = tmpdir_factory.mktemp(\"data\").strpath          temp_file_path = os.path.join(temp_folder_path, \"temp.parquet\")          pd.DataFrame([]).to_parquet(temp_file_path)            dn = ParquetDataNode(\"foo\", Scope.SCENARIO, properties={\"path\": temp_folder_path})          initial_edit_date = dn.last_edit_date            # Sleep so that the file can be created successfully on Ubuntu          sleep(0.1)            pd.DataFrame(pd.DataFrame(data={\"col1\": [1, 2], \"col2\": [3, 4]})).to_parquet(temp_file_path)          first_edit_date = datetime.fromtimestamp(os.path.getmtime(temp_file_path))          assert dn.last_edit_date > initial_edit_date          assert dn.last_edit_date == first_edit_date            sleep(0.1)            pd.DataFrame(pd.DataFrame(data={\"col1\": [5, 6], \"col2\": [7, 8]})).to_parquet(temp_file_path)          second_edit_date = datetime.fromtimestamp(os.path.getmtime(temp_file_path))          assert dn.last_edit_date > first_edit_date          assert dn.last_edit_date == second_edit_date            os.unlink(temp_file_path)        @pytest.mark.skipif(not util.find_spec(\"fastparquet\"), reason=\"Append parquet requires fastparquet to be installed\")      @pytest.mark.parametrize(          \"content\",          [              ([{\"a\": 11, \"b\": 22, \"c\": 33}, {\"a\": 44, \"b\": 55, \"c\": 66}]),              (pd.DataFrame([{\"a\": 11, \"b\": 22, \"c\": 33}, {\"a\": 44, \"b\": 55, \"c\": 66}])),          ],      )      def test_append_pandas(self, parquet_file_path, default_data_frame, content):          dn = ParquetDataNode(\"foo\", Scope.SCENARIO, properties={\"path\": parquet_file_path})          assert_frame_equal(dn.read(), default_data_frame)            dn.append(content)          assert_frame_equal(              dn.read(),              pd.concat([default_data_frame, pd.DataFrame(content, columns=[\"a\", \"b\", \"c\"])]).reset_index(drop=True),          )        @pytest.mark.skipif(not util.find_spec(\"fastparquet\"), reason=\"Append parquet requires fastparquet to be installed\")      @pytest.mark.parametrize(          \"content\",          [              ([{\"a\": 11, \"b\": 22, \"c\": 33}, {\"a\": 44, \"b\": 55, \"c\": 66}]),              (pd.DataFrame([{\"a\": 11, \"b\": 22, \"c\": 33}, {\"a\": 44, \"b\": 55, \"c\": 66}])),          ],      )      def test_append_modin(self, parquet_file_path, default_data_frame, content):          dn = ParquetDataNode(\"foo\", Scope.SCENARIO, properties={\"path\": parquet_file_path, \"exposed_type\": \"modin\"})          df_equals(dn.read(), modin_pd.DataFrame(default_data_frame))            dn.append(content)          df_equals(              dn.read(),              modin_pd.concat([default_data_frame, pd.DataFrame(content, columns=[\"a\", \"b\", \"c\"])]).reset_index(                  drop=True              ),          )        @pytest.mark.parametrize(          \"data\",          [              [{\"a\": 11, \"b\": 22, \"c\": 33}, {\"a\": 44, \"b\": 55, \"c\": 66}],              pd.DataFrame([{\"a\": 11, \"b\": 22, \"c\": 33}, {\"a\": 44, \"b\": 55, \"c\": 66}]),              modin_pd.DataFrame([{\"a\": 11, \"b\": 22, \"c\": 33}, {\"a\": 44, \"b\": 55, \"c\": 66}]),          ],      )      def test_write_to_disk(self, tmpdir_factory, data):          temp_file_path = str(tmpdir_factory.mktemp(\"data\").join(\"temp.parquet\"))          dn = ParquetDataNode(\"foo\", Scope.SCENARIO, properties={\"path\": temp_file_path})          dn.write(data)            assert pathlib.Path(temp_file_path).exists()          assert isinstance(dn.read(), pd.DataFrame)        def test_filter_pandas_exposed_type(self, parquet_file_path):          dn = ParquetDataNode(\"foo\", Scope.SCENARIO, properties={\"path\": parquet_file_path, \"exposed_type\": \"pandas\"})          dn.write(              [                  {\"foo\": 1, \"bar\": 1},                  {\"foo\": 1, \"bar\": 2},                  {\"foo\": 1},                  {\"foo\": 2, \"bar\": 2},                  {\"bar\": 2},              ]          )            # Test datanode indexing and slicing          assert dn[\"foo\"].equals(pd.Series([1, 1, 1, 2, None]))          assert dn[\"bar\"].equals(pd.Series([1, 2, None, 2, 2]))          assert dn[:2].equals(pd.DataFrame([{\"foo\": 1.0, \"bar\": 1.0}, {\"foo\": 1.0, \"bar\": 2.0}]))            # Test filter data          filtered_by_filter_method = dn.filter((\"foo\", 1, Operator.EQUAL))          filtered_by_indexing = dn[dn[\"foo\"] == 1]          expected_data = pd.DataFrame([{\"foo\": 1.0, \"bar\": 1.0}, {\"foo\": 1.0, \"bar\": 2.0}, {\"foo\": 1.0}])          assert_frame_equal(filtered_by_filter_method.reset_index(drop=True), expected_data)          assert_frame_equal(filtered_by_indexing.reset_index(drop=True), expected_data)            filtered_by_filter_method = dn.filter((\"foo\", 1, Operator.NOT_EQUAL))          filtered_by_indexing = dn[dn[\"foo\"] != 1]          expected_data = pd.DataFrame([{\"foo\": 2.0, \"bar\": 2.0}, {\"bar\": 2.0}])          assert_frame_equal(filtered_by_filter_method.reset_index(drop=True), expected_data)          assert_frame_equal(filtered_by_indexing.reset_index(drop=True), expected_data)            filtered_by_filter_method = dn.filter((\"bar\", 2, Operator.EQUAL))          filtered_by_indexing = dn[dn[\"bar\"] == 2]          expected_data = pd.DataFrame([{\"foo\": 1.0, \"bar\": 2.0}, {\"foo\": 2.0, \"bar\": 2.0}, {\"bar\": 2.0}])          assert_frame_equal(filtered_by_filter_method.reset_index(drop=True), expected_data)          assert_frame_equal(filtered_by_indexing.reset_index(drop=True), expected_data)            filtered_by_filter_method = dn.filter([(\"bar\", 1, Operator.EQUAL), (\"bar\", 2, Operator.EQUAL)], JoinOperator.OR)          filtered_by_indexing = dn[(dn[\"bar\"] == 1) | (dn[\"bar\"] == 2)]          expected_data = pd.DataFrame(              [                  {\"foo\": 1.0, \"bar\": 1.0},                  {\"foo\": 1.0, \"bar\": 2.0},                  {\"foo\": 2.0, \"bar\": 2.0},                  {\"bar\": 2.0},              ]          )          assert_frame_equal(filtered_by_filter_method.reset_index(drop=True), expected_data)          assert_frame_equal(filtered_by_indexing.reset_index(drop=True), expected_data)        def test_filter_modin_exposed_type(self, parquet_file_path):          dn = ParquetDataNode(\"foo\", Scope.SCENARIO, properties={\"path\": parquet_file_path, \"exposed_type\": \"modin\"})          dn.write(              [                  {\"foo\": 1, \"bar\": 1},                  {\"foo\": 1, \"bar\": 2},                  {\"foo\": 1},                  {\"foo\": 2, \"bar\": 2},                  {\"bar\": 2},              ]          )            # Test datanode indexing and slicing          assert dn[\"foo\"].equals(modin_pd.Series([1, 1, 1, 2, None]))          assert dn[\"bar\"].equals(modin_pd.Series([1, 2, None, 2, 2]))          assert dn[:2].equals(modin_pd.DataFrame([{\"foo\": 1.0, \"bar\": 1.0}, {\"foo\": 1.0, \"bar\": 2.0}]))            # Test filter data          filtered_by_filter_method = dn.filter((\"foo\", 1, Operator.EQUAL))          filtered_by_indexing = dn[dn[\"foo\"] == 1]          expected_data = modin_pd.DataFrame([{\"foo\": 1.0, \"bar\": 1.0}, {\"foo\": 1.0, \"bar\": 2.0}, {\"foo\": 1.0}])          df_equals(filtered_by_filter_method.reset_index(drop=True), expected_data)          df_equals(filtered_by_indexing.reset_index(drop=True), expected_data)            filtered_by_filter_method = dn.filter((\"foo\", 1, Operator.NOT_EQUAL))          filtered_by_indexing = dn[dn[\"foo\"] != 1]          expected_data = modin_pd.DataFrame([{\"foo\": 2.0, \"bar\": 2.0}, {\"bar\": 2.0}])          df_equals(filtered_by_filter_method.reset_index(drop=True), expected_data)          df_equals(filtered_by_indexing.reset_index(drop=True), expected_data)            filtered_by_filter_method = dn.filter((\"bar\", 2, Operator.EQUAL))          filtered_by_indexing = dn[dn[\"bar\"] == 2]          expected_data = modin_pd.DataFrame([{\"foo\": 1.0, \"bar\": 2.0}, {\"foo\": 2.0, \"bar\": 2.0}, {\"bar\": 2.0}])          df_equals(filtered_by_filter_method.reset_index(drop=True), expected_data)          df_equals(filtered_by_indexing.reset_index(drop=True), expected_data)            filtered_by_filter_method = dn.filter([(\"bar\", 1, Operator.EQUAL), (\"bar\", 2, Operator.EQUAL)], JoinOperator.OR)          filtered_by_indexing = dn[(dn[\"bar\"] == 1) | (dn[\"bar\"] == 2)]          expected_data = modin_pd.DataFrame(              [                  {\"foo\": 1.0, \"bar\": 1.0},                  {\"foo\": 1.0, \"bar\": 2.0},                  {\"foo\": 2.0, \"bar\": 2.0},                  {\"bar\": 2.0},              ]          )          df_equals(filtered_by_filter_method.reset_index(drop=True), expected_data)          df_equals(filtered_by_indexing.reset_index(drop=True), expected_data)        def test_filter_numpy_exposed_type(self, parquet_file_path):          dn = ParquetDataNode(\"foo\", Scope.SCENARIO, properties={\"path\": parquet_file_path, \"exposed_type\": \"numpy\"})          dn.write(              [                  [1, 1],                  [1, 2],                  [1, 3],                  [2, 1],                  [2, 2],                  [2, 3],              ]          )            # Test datanode indexing and slicing          assert np.array_equal(dn[0], np.array([1, 1]))          assert np.array_equal(dn[1], np.array([1, 2]))          assert np.array_equal(dn[:3], np.array([[1, 1], [1, 2], [1, 3]]))          assert np.array_equal(dn[:, 0], np.array([1, 1, 1, 2, 2, 2]))          assert np.array_equal(dn[1:4, :1], np.array([[1], [1], [2]]))            # Test filter data          assert np.array_equal(dn.filter((0, 1, Operator.EQUAL)), np.array([[1, 1], [1, 2], [1, 3]]))          assert np.array_equal(dn[dn[:, 0] == 1], np.array([[1, 1], [1, 2], [1, 3]]))            assert np.array_equal(dn.filter((0, 1, Operator.NOT_EQUAL)), np.array([[2, 1], [2, 2], [2, 3]]))          assert np.array_equal(dn[dn[:, 0] != 1], np.array([[2, 1], [2, 2], [2, 3]]))            assert np.array_equal(dn.filter((1, 2, Operator.EQUAL)), np.array([[1, 2], [2, 2]]))          assert np.array_equal(dn[dn[:, 1] == 2], np.array([[1, 2], [2, 2]]))            assert np.array_equal(              dn.filter([(1, 1, Operator.EQUAL), (1, 2, Operator.EQUAL)], JoinOperator.OR),              np.array([[1, 1], [1, 2], [2, 1], [2, 2]]),          )          assert np.array_equal(dn[(dn[:, 1] == 1) | (dn[:, 1] == 2)], np.array([[1, 1], [1, 2], [2, 1], [2, 2]]))        @pytest.mark.parametrize(\"engine\", __engine)      def test_pandas_parquet_config_kwargs(self, engine, tmpdir_factory):          read_kwargs = {\"filters\": [(\"integer\", \"<\", 10)], \"columns\": [\"integer\"]}          temp_file_path = str(tmpdir_factory.mktemp(\"data\").join(\"temp.parquet\"))          dn = ParquetDataNode(              \"foo\", Scope.SCENARIO, properties={\"path\": temp_file_path, \"engine\": engine, \"read_kwargs\": read_kwargs}          )            df = pd.read_csv(os.path.join(pathlib.Path(__file__).parent.resolve(), \"data_sample/example.csv\"))          dn.write(df)            assert set(pd.read_parquet(temp_file_path).columns) == {\"id\", \"integer\", \"text\"}          print(dn.read())          assert set(dn.read().columns) == set(read_kwargs[\"columns\"])            # !!! filter doesn't work with `fastparquet` without partition_cols          if engine == \"pyarrow\":              assert len(dn.read()) != len(df)              assert len(dn.read()) == 2        @pytest.mark.parametrize(\"engine\", __engine)      def test_kwarg_precedence(self, engine, tmpdir_factory, default_data_frame):          # Precedence:          # 1. Class read/write methods          # 2. Defined in read_kwargs and write_kwargs, in properties          # 3. Defined top-level in properties            temp_file_path = str(tmpdir_factory.mktemp(\"data\").join(\"temp.parquet\"))          temp_file_2_path = str(tmpdir_factory.mktemp(\"data\").join(\"temp_2.parquet\"))          df = default_data_frame.copy(deep=True)            # Write          # 3          comp3 = \"snappy\"          dn = ParquetDataNode(              \"foo\", Scope.SCENARIO, properties={\"path\": temp_file_path, \"engine\": engine, \"compression\": comp3}          )          dn.write(df)          df.to_parquet(path=temp_file_2_path, compression=comp3, engine=engine)          with open(temp_file_2_path, \"rb\") as tf:              with pathlib.Path(temp_file_path).open(\"rb\") as f:                  assert f.read() == tf.read()            # 3 and 2          comp2 = \"gzip\"          dn = ParquetDataNode(              \"foo\",              Scope.SCENARIO,              properties={                  \"path\": temp_file_path,                  \"engine\": engine,                  \"compression\": comp3,                  \"write_kwargs\": {\"compression\": comp2},              },          )          dn.write(df)          df.to_parquet(path=temp_file_2_path, compression=comp2, engine=engine)          with open(temp_file_2_path, \"rb\") as tf:              with pathlib.Path(temp_file_path).open(\"rb\") as f:                  assert f.read() == tf.read()            # 3, 2 and 1          comp1 = \"brotli\"          dn = ParquetDataNode(              \"foo\",              Scope.SCENARIO,              properties={                  \"path\": temp_file_path,                  \"engine\": engine,                  \"compression\": comp3,                  \"write_kwargs\": {\"compression\": comp2},              },          )          dn.write_with_kwargs(df, compression=comp1)          df.to_parquet(path=temp_file_2_path, compression=comp1, engine=engine)          with open(temp_file_2_path, \"rb\") as tf:              with pathlib.Path(temp_file_path).open(\"rb\") as f:                  assert f.read() == tf.read()            # Read          df.to_parquet(temp_file_path, engine=engine)          # 2          cols2 = [\"a\", \"b\"]          dn = ParquetDataNode(              \"foo\",              Scope.SCENARIO,              properties={\"path\": temp_file_path, \"engine\": engine, \"read_kwargs\": {\"columns\": cols2}},          )          assert set(dn.read().columns) == set(cols2)            # 1          cols1 = [\"a\"]          dn = ParquetDataNode(              \"foo\",              Scope.SCENARIO,              properties={\"path\": temp_file_path, \"engine\": engine, \"read_kwargs\": {\"columns\": cols2}},          )          assert set(dn.read_with_kwargs(columns=cols1).columns) == set(cols1)        def test_partition_cols(self, tmpdir_factory, default_data_frame: pd.DataFrame):          temp_dir_path = str(tmpdir_factory.mktemp(\"data\").join(\"temp_dir\"))            write_kwargs = {\"partition_cols\": [\"a\", \"b\"]}          dn = ParquetDataNode(              \"foo\", Scope.SCENARIO, properties={\"path\": temp_dir_path, \"write_kwargs\": write_kwargs}          )  # type: ignore          dn.write(default_data_frame)            assert pathlib.Path(temp_dir_path).is_dir()          # dtypes change during round-trip with partition_cols          pd.testing.assert_frame_equal(              dn.read().sort_index(axis=1),              default_data_frame.sort_index(axis=1),              check_dtype=False,              check_categorical=False,          )        def test_read_with_kwargs_never_written(self):          path = \"data/node/path\"          dn = ParquetDataNode(\"foo\", Scope.SCENARIO, properties={\"path\": path})          assert dn.read_with_kwargs() is None "}
{"text": "from importlib import util  from unittest.mock import patch    import modin.pandas as modin_pd  import numpy as np  import pandas as pd  import pytest  from modin.pandas.test.utils import df_equals  from pandas.testing import assert_frame_equal    from src.taipy.core.data.data_node_id import DataNodeId  from src.taipy.core.data.operator import JoinOperator, Operator  from src.taipy.core.data.sql_table import SQLTableDataNode  from src.taipy.core.exceptions.exceptions import InvalidExposedType, MissingRequiredProperty  from taipy.config.common.scope import Scope      class MyCustomObject:      def __init__(self, foo=None, bar=None, *args, **kwargs):          self.foo = foo          self.bar = bar          self.args = args          self.kwargs = kwargs      class TestSQLTableDataNode:      __pandas_properties = [          {              \"db_name\": \"taipy\",              \"db_engine\": \"sqlite\",              \"table_name\": \"example\",              \"db_extra_args\": {                  \"TrustServerCertificate\": \"yes\",                  \"other\": \"value\",              },          },      ]        __modin_properties = [          {              \"db_name\": \"taipy\",              \"db_engine\": \"sqlite\",              \"table_name\": \"example\",              \"exposed_type\": \"modin\",              \"db_extra_args\": {                  \"TrustServerCertificate\": \"yes\",                  \"other\": \"value\",              },          },      ]        if util.find_spec(\"pyodbc\"):          __pandas_properties.append(              {                  \"db_username\": \"sa\",                  \"db_password\": \"Passw0rd\",                  \"db_name\": \"taipy\",                  \"db_engine\": \"mssql\",                  \"table_name\": \"example\",                  \"db_extra_args\": {                      \"TrustServerCertificate\": \"yes\",                  },              },          )          __modin_properties.append(              {                  \"db_username\": \"sa\",                  \"db_password\": \"Passw0rd\",                  \"db_name\": \"taipy\",                  \"db_engine\": \"mssql\",                  \"table_name\": \"example\",                  \"exposed_type\": \"modin\",                  \"db_extra_args\": {                      \"TrustServerCertificate\": \"yes\",                  },              },          )        if util.find_spec(\"pymysql\"):          __pandas_properties.append(              {                  \"db_username\": \"sa\",                  \"db_password\": \"Passw0rd\",                  \"db_name\": \"taipy\",                  \"db_engine\": \"mysql\",                  \"table_name\": \"example\",                  \"db_extra_args\": {                      \"TrustServerCertificate\": \"yes\",                  },              },          )          __modin_properties.append(              {                  \"db_username\": \"sa\",                  \"db_password\": \"Passw0rd\",                  \"db_name\": \"taipy\",                  \"db_engine\": \"mysql\",                  \"table_name\": \"example\",                  \"exposed_type\": \"modin\",                  \"db_extra_args\": {                      \"TrustServerCertificate\": \"yes\",                  },              },          )        if util.find_spec(\"psycopg2\"):          __pandas_properties.append(              {                  \"db_username\": \"sa\",                  \"db_password\": \"Passw0rd\",                  \"db_name\": \"taipy\",                  \"db_engine\": \"postgresql\",                  \"table_name\": \"example\",                  \"db_extra_args\": {                      \"TrustServerCertificate\": \"yes\",                  },              },          )          __modin_properties.append(              {                  \"db_username\": \"sa\",                  \"db_password\": \"Passw0rd\",                  \"db_name\": \"taipy\",                  \"db_engine\": \"postgresql\",                  \"table_name\": \"example\",                  \"exposed_type\": \"modin\",                  \"db_extra_args\": {                      \"TrustServerCertificate\": \"yes\",                  },              },          )        @pytest.mark.parametrize(\"pandas_properties\", __pandas_properties)      @pytest.mark.parametrize(\"modin_properties\", __modin_properties)      def test_create(self, pandas_properties, modin_properties):          dn = SQLTableDataNode(              \"foo_bar\",              Scope.SCENARIO,              properties=pandas_properties,          )          assert isinstance(dn, SQLTableDataNode)          assert dn.storage_type() == \"sql_table\"          assert dn.config_id == \"foo_bar\"          assert dn.scope == Scope.SCENARIO          assert dn.id is not None          assert dn.owner_id is None          assert dn.job_ids == []          assert dn.is_ready_for_reading          assert dn.exposed_type == \"pandas\"          assert dn.table_name == \"example\"          assert dn._get_base_read_query() == \"SELECT * FROM example\"            dn = SQLTableDataNode(              \"foo_bar\",              Scope.SCENARIO,              properties=modin_properties,          )          assert isinstance(dn, SQLTableDataNode)          assert dn.storage_type() == \"sql_table\"          assert dn.config_id == \"foo_bar\"          assert dn.scope == Scope.SCENARIO          assert dn.id is not None          assert dn.owner_id is None          assert dn.job_ids == []          assert dn.is_ready_for_reading          assert dn.exposed_type == \"modin\"          assert dn.table_name == \"example\"          assert dn._get_base_read_query() == \"SELECT * FROM example\"        @pytest.mark.parametrize(\"properties\", __pandas_properties)      def test_get_user_properties(self, properties):          custom_properties = properties.copy()          custom_properties[\"foo\"] = \"bar\"          dn = SQLTableDataNode(              \"foo_bar\",              Scope.SCENARIO,              properties=custom_properties,          )          assert dn._get_user_properties() == {\"foo\": \"bar\"}        @pytest.mark.parametrize(          \"properties\",          [              {},              {\"db_username\": \"foo\"},              {\"db_username\": \"foo\", \"db_password\": \"foo\"},              {\"db_username\": \"foo\", \"db_password\": \"foo\", \"db_name\": \"foo\"},          ],      )      def test_create_with_missing_parameters(self, properties):          with pytest.raises(MissingRequiredProperty):              SQLTableDataNode(\"foo\", Scope.SCENARIO, DataNodeId(\"dn_id\"))          with pytest.raises(MissingRequiredProperty):              SQLTableDataNode(\"foo\", Scope.SCENARIO, DataNodeId(\"dn_id\"), properties=properties)        @patch(\"src.taipy.core.data.sql_table.SQLTableDataNode._read_as\", return_value=\"custom\")      @patch(\"src.taipy.core.data.sql_table.SQLTableDataNode._read_as_pandas_dataframe\", return_value=\"pandas\")      @patch(\"src.taipy.core.data.sql_table.SQLTableDataNode._read_as_modin_dataframe\", return_value=\"modin\")      @patch(\"src.taipy.core.data.sql_table.SQLTableDataNode._read_as_numpy\", return_value=\"numpy\")      @pytest.mark.parametrize(\"pandas_properties\", __pandas_properties)      @pytest.mark.parametrize(\"modin_properties\", __modin_properties)      def test_read(          self,          mock_read_as,          mock_read_as_pandas_dataframe,          mock_read_as_modin_dataframe,          mock_read_as_numpy,          pandas_properties,          modin_properties,      ):          custom_properties = pandas_properties.copy()          # Create SQLTableDataNode without exposed_type (Default is pandas.DataFrame)          sql_data_node_as_pandas = SQLTableDataNode(              \"foo\",              Scope.SCENARIO,              properties=pandas_properties,          )            assert sql_data_node_as_pandas.read() == \"pandas\"            custom_properties.pop(\"db_extra_args\")          custom_properties[\"exposed_type\"] = MyCustomObject          # Create the same SQLTableDataNode but with custom exposed_type          sql_data_node_as_custom_object = SQLTableDataNode(\"foo\", Scope.SCENARIO, properties=custom_properties)          assert sql_data_node_as_custom_object.read() == \"custom\"            # Create the same SQLDataSource but with numpy exposed_type          custom_properties[\"exposed_type\"] = \"numpy\"          sql_data_source_as_numpy_object = SQLTableDataNode(\"foo\", Scope.SCENARIO, properties=custom_properties)            assert sql_data_source_as_numpy_object.read() == \"numpy\"            # Create the same SQLDataSource but with modin exposed_type          sql_data_source_as_modin_object = SQLTableDataNode(\"foo\", Scope.SCENARIO, properties=modin_properties)          assert sql_data_source_as_modin_object.properties[\"exposed_type\"] == \"modin\"          assert sql_data_source_as_modin_object.read() == \"modin\"        @pytest.mark.parametrize(\"pandas_properties\", __pandas_properties)      def test_read_as(self, pandas_properties):          custom_properties = pandas_properties.copy()            custom_properties.pop(\"db_extra_args\")          custom_properties[\"exposed_type\"] = MyCustomObject          sql_data_node = SQLTableDataNode(\"foo\", Scope.SCENARIO, properties=custom_properties)            with patch(\"sqlalchemy.engine.Engine.connect\") as engine_mock:              cursor_mock = engine_mock.return_value.__enter__.return_value              cursor_mock.execute.return_value = [                  {\"foo\": \"baz\", \"bar\": \"qux\"},                  {\"foo\": \"quux\", \"bar\": \"quuz\"},                  {\"foo\": \"corge\"},                  {\"bar\": \"grault\"},                  {\"KWARGS_KEY\": \"KWARGS_VALUE\"},                  {},              ]              data = sql_data_node._read_as()            assert isinstance(data, list)          assert isinstance(data[0], MyCustomObject)          assert isinstance(data[1], MyCustomObject)          assert isinstance(data[2], MyCustomObject)          assert isinstance(data[3], MyCustomObject)          assert isinstance(data[4], MyCustomObject)          assert isinstance(data[5], MyCustomObject)            assert data[0].foo == \"baz\"          assert data[0].bar == \"qux\"          assert data[1].foo == \"quux\"          assert data[1].bar == \"quuz\"          assert data[2].foo == \"corge\"          assert data[2].bar is None          assert data[3].foo is None          assert data[3].bar == \"grault\"          assert data[4].foo is None          assert data[4].bar is None          assert data[4].kwargs[\"KWARGS_KEY\"] == \"KWARGS_VALUE\"          assert data[5].foo is None          assert data[5].bar is None          assert len(data[5].args) == 0          assert len(data[5].kwargs) == 0            with patch(\"sqlalchemy.engine.Engine.connect\") as engine_mock:              cursor_mock = engine_mock.return_value.__enter__.return_value              cursor_mock.execute.return_value = []              data_2 = sql_data_node._read_as()          assert isinstance(data_2, list)          assert len(data_2) == 0        @pytest.mark.parametrize(          \"data,written_data,called_func\",          [              ([{\"a\": 1, \"b\": 2}, {\"a\": 3, \"b\": 4}], [{\"a\": 1, \"b\": 2}, {\"a\": 3, \"b\": 4}], \"__insert_dicts\"),              ({\"a\": 1, \"b\": 2}, [{\"a\": 1, \"b\": 2}], \"__insert_dicts\"),              ([(1, 2), (3, 4)], [(1, 2), (3, 4)], \"__insert_tuples\"),              ([[1, 2], [3, 4]], [[1, 2], [3, 4]], \"__insert_tuples\"),              ((1, 2), [(1, 2)], \"__insert_tuples\"),              ([1, 2, 3, 4], [(1,), (2,), (3,), (4,)], \"__insert_tuples\"),              (\"foo\", [(\"foo\",)], \"__insert_tuples\"),              (None, [(None,)], \"__insert_tuples\"),              (np.array([1, 2, 3, 4]), [(1,), (2,), (3,), (4,)], \"__insert_tuples\"),              (np.array([np.array([1, 2]), np.array([3, 4])]), [[1, 2], [3, 4]], \"__insert_tuples\"),          ],      )      @pytest.mark.parametrize(\"pandas_properties\", __pandas_properties)      def test_write_1(self, data, written_data, called_func, pandas_properties):          custom_properties = pandas_properties.copy()          custom_properties.pop(\"db_extra_args\")          dn = SQLTableDataNode(\"foo\", Scope.SCENARIO, properties=custom_properties)            with patch(\"sqlalchemy.engine.Engine.connect\") as engine_mock, patch(              \"src.taipy.core.data.sql_table.SQLTableDataNode._create_table\"          ) as create_table_mock:              cursor_mock = engine_mock.return_value.__enter__.return_value              cursor_mock.execute.side_effect = None                with patch(f\"src.taipy.core.data.sql_table.SQLTableDataNode._SQLTableDataNode{called_func}\") as mck:                  dn.write(data)                  mck.assert_called_once_with(written_data, create_table_mock.return_value, cursor_mock, True)        @pytest.mark.parametrize(\"pandas_properties\", __pandas_properties)      def test_raise_error_invalid_exposed_type(self, pandas_properties):          custom_properties = pandas_properties.copy()          custom_properties.pop(\"db_extra_args\")          custom_properties[\"exposed_type\"] = \"foo\"          with pytest.raises(InvalidExposedType):              SQLTableDataNode(\"foo\", Scope.SCENARIO, properties=custom_properties)        @pytest.mark.parametrize(\"pandas_properties\", __pandas_properties)      @pytest.mark.parametrize(\"modin_properties\", __modin_properties)      def test_write_dataframe(self, pandas_properties, modin_properties):          # test write pandas dataframe          custom_properties = pandas_properties.copy()          custom_properties.pop(\"db_extra_args\")          dn = SQLTableDataNode(\"foo\", Scope.SCENARIO, properties=custom_properties)            df = pd.DataFrame({\"a\": [1, 2, 3, 4], \"b\": [5, 6, 7, 8]})          with patch(\"sqlalchemy.engine.Engine.connect\") as engine_mock, patch(              \"src.taipy.core.data.sql_table.SQLTableDataNode._create_table\"          ):              cursor_mock = engine_mock.return_value.__enter__.return_value              cursor_mock.execute.side_effect = None                with patch(\"src.taipy.core.data.sql_table.SQLTableDataNode._SQLTableDataNode__insert_dataframe\") as mck:                  dn.write(df)                  assert mck.call_args[0][0].equals(df)            # test write modin dataframe          custom_properties = modin_properties.copy()          custom_properties.pop(\"db_extra_args\")          dn = SQLTableDataNode(\"foo\", Scope.SCENARIO, properties=custom_properties)            df = modin_pd.DataFrame({\"a\": [1, 2, 3, 4], \"b\": [5, 6, 7, 8]})          with patch(\"sqlalchemy.engine.Engine.connect\") as engine_mock, patch(              \"src.taipy.core.data.sql_table.SQLTableDataNode._create_table\"          ):              cursor_mock = engine_mock.return_value.__enter__.return_value              cursor_mock.execute.side_effect = None                with patch(\"src.taipy.core.data.sql_table.SQLTableDataNode._SQLTableDataNode__insert_dataframe\") as mck:                  dn.write(df)                  assert mck.call_args[0][0].equals(df)        @pytest.mark.parametrize(          \"data\",          [              [],              np.array([]),          ],      )      @pytest.mark.parametrize(\"pandas_properties\", __pandas_properties)      def test_write_empty_list(self, data, pandas_properties):          custom_properties = pandas_properties.copy()          custom_properties.pop(\"db_extra_args\")          dn = SQLTableDataNode(\"foo\", Scope.SCENARIO, properties=custom_properties)            with patch(\"sqlalchemy.engine.Engine.connect\") as engine_mock, patch(              \"src.taipy.core.data.sql_table.SQLTableDataNode._create_table\"          ) as create_table_mock:              cursor_mock = engine_mock.return_value.__enter__.return_value              cursor_mock.execute.side_effect = None                with patch(\"src.taipy.core.data.sql_table.SQLTableDataNode._SQLTableDataNode__delete_all_rows\") as mck:                  dn.write(data)                  mck.assert_called_once_with(create_table_mock.return_value, cursor_mock, True)        @pytest.mark.parametrize(\"pandas_properties\", __pandas_properties)      @patch(\"pandas.read_sql_query\")      def test_engine_cache(self, _, pandas_properties):          dn = SQLTableDataNode(              \"foo\",              Scope.SCENARIO,              properties=pandas_properties,          )            assert dn._engine is None            with patch(\"sqlalchemy.engine.Engine.connect\") as engine_mock, patch(              \"src.taipy.core.data.sql_table.SQLTableDataNode._create_table\"          ):              cursor_mock = engine_mock.return_value.__enter__.return_value              cursor_mock.execute.side_effect = None                dn.read()              assert dn._engine is not None                dn.db_username = \"foo\"              assert dn._engine is None                dn.write(1)              assert dn._engine is not None                dn.some_random_attribute_that_does_not_related_to_engine = \"foo\"              assert dn._engine is not None        @pytest.mark.parametrize(          \"tmp_sqlite_path\",          [              \"tmp_sqlite_db_file_path\",              \"tmp_sqlite_sqlite3_file_path\",          ],      )      def test_sqlite_read_file_with_different_extension(self, tmp_sqlite_path, request):          tmp_sqlite_path = request.getfixturevalue(tmp_sqlite_path)          folder_path, db_name, file_extension = tmp_sqlite_path          properties = {              \"db_engine\": \"sqlite\",              \"table_name\": \"example\",              \"db_name\": db_name,              \"sqlite_folder_path\": folder_path,              \"sqlite_file_extension\": file_extension,          }            dn = SQLTableDataNode(\"sqlite_dn\", Scope.SCENARIO, properties=properties)          data = dn.read()            assert data.equals(pd.DataFrame([{\"foo\": 1, \"bar\": 2}, {\"foo\": 3, \"bar\": 4}]))        def test_sqlite_append_pandas(self, tmp_sqlite_sqlite3_file_path):          folder_path, db_name, file_extension = tmp_sqlite_sqlite3_file_path          properties = {              \"db_engine\": \"sqlite\",              \"table_name\": \"example\",              \"db_name\": db_name,              \"sqlite_folder_path\": folder_path,              \"sqlite_file_extension\": file_extension,          }            dn = SQLTableDataNode(\"sqlite_dn\", Scope.SCENARIO, properties=properties)          original_data = pd.DataFrame([{\"foo\": 1, \"bar\": 2}, {\"foo\": 3, \"bar\": 4}])          data = dn.read()          assert_frame_equal(data, original_data)            append_data_1 = pd.DataFrame([{\"foo\": 5, \"bar\": 6}, {\"foo\": 7, \"bar\": 8}])          dn.append(append_data_1)          assert_frame_equal(dn.read(), pd.concat([original_data, append_data_1]).reset_index(drop=True))        def test_sqlite_append_modin(self, tmp_sqlite_sqlite3_file_path):          folder_path, db_name, file_extension = tmp_sqlite_sqlite3_file_path          properties = {              \"db_engine\": \"sqlite\",              \"table_name\": \"example\",              \"db_name\": db_name,              \"sqlite_folder_path\": folder_path,              \"sqlite_file_extension\": file_extension,              \"exposed_type\": \"modin\",          }            dn = SQLTableDataNode(\"sqlite_dn\", Scope.SCENARIO, properties=properties)          original_data = modin_pd.DataFrame([{\"foo\": 1, \"bar\": 2}, {\"foo\": 3, \"bar\": 4}])          data = dn.read()          df_equals(data, original_data)            append_data_1 = modin_pd.DataFrame([{\"foo\": 5, \"bar\": 6}, {\"foo\": 7, \"bar\": 8}])          dn.append(append_data_1)          df_equals(dn.read(), modin_pd.concat([original_data, append_data_1]).reset_index(drop=True))        def test_filter_pandas_exposed_type(self, tmp_sqlite_sqlite3_file_path):          folder_path, db_name, file_extension = tmp_sqlite_sqlite3_file_path          properties = {              \"db_engine\": \"sqlite\",              \"table_name\": \"example\",              \"db_name\": db_name,              \"sqlite_folder_path\": folder_path,              \"sqlite_file_extension\": file_extension,              \"exposed_type\": \"pandas\",          }          dn = SQLTableDataNode(\"foo\", Scope.SCENARIO, properties=properties)          dn.write(              pd.DataFrame(                  [                      {\"foo\": 1, \"bar\": 1},                      {\"foo\": 1, \"bar\": 2},                      {\"foo\": 1, \"bar\": 3},                      {\"foo\": 2, \"bar\": 1},                      {\"foo\": 2, \"bar\": 2},                      {\"foo\": 2, \"bar\": 3},                  ]              )          )            # Test datanode indexing and slicing          assert dn[\"foo\"].equals(pd.Series([1, 1, 1, 2, 2, 2]))          assert dn[\"bar\"].equals(pd.Series([1, 2, 3, 1, 2, 3]))          assert dn[:2].equals(pd.DataFrame([{\"foo\": 1, \"bar\": 1}, {\"foo\": 1, \"bar\": 2}]))            # Test filter data          filtered_by_filter_method = dn.filter((\"foo\", 1, Operator.EQUAL))          filtered_by_indexing = dn[dn[\"foo\"] == 1]          expected_data = pd.DataFrame([{\"foo\": 1, \"bar\": 1}, {\"foo\": 1, \"bar\": 2}, {\"foo\": 1, \"bar\": 3}])          assert_frame_equal(filtered_by_filter_method.reset_index(drop=True), expected_data)          assert_frame_equal(filtered_by_indexing.reset_index(drop=True), expected_data)            filtered_by_filter_method = dn.filter((\"foo\", 1, Operator.NOT_EQUAL))          filtered_by_indexing = dn[dn[\"foo\"] != 1]          expected_data = pd.DataFrame([{\"foo\": 2, \"bar\": 1}, {\"foo\": 2, \"bar\": 2}, {\"foo\": 2, \"bar\": 3}])          assert_frame_equal(filtered_by_filter_method.reset_index(drop=True), expected_data)          assert_frame_equal(filtered_by_indexing.reset_index(drop=True), expected_data)            filtered_by_filter_method = dn.filter([(\"bar\", 1, Operator.EQUAL), (\"bar\", 2, Operator.EQUAL)], JoinOperator.OR)          filtered_by_indexing = dn[(dn[\"bar\"] == 1) | (dn[\"bar\"] == 2)]          expected_data = pd.DataFrame(              [                  {\"foo\": 1, \"bar\": 1},                  {\"foo\": 1, \"bar\": 2},                  {\"foo\": 2, \"bar\": 1},                  {\"foo\": 2, \"bar\": 2},              ]          )          assert_frame_equal(filtered_by_filter_method.reset_index(drop=True), expected_data)          assert_frame_equal(filtered_by_indexing.reset_index(drop=True), expected_data)        def test_filter_modin_exposed_type(self, tmp_sqlite_sqlite3_file_path):          folder_path, db_name, file_extension = tmp_sqlite_sqlite3_file_path          properties = {              \"db_engine\": \"sqlite\",              \"table_name\": \"example\",              \"db_name\": db_name,              \"sqlite_folder_path\": folder_path,              \"sqlite_file_extension\": file_extension,              \"exposed_type\": \"modin\",          }          dn = SQLTableDataNode(\"foo\", Scope.SCENARIO, properties=properties)          dn.write(              pd.DataFrame(                  [                      {\"foo\": 1, \"bar\": 1},                      {\"foo\": 1, \"bar\": 2},                      {\"foo\": 1, \"bar\": 3},                      {\"foo\": 2, \"bar\": 1},                      {\"foo\": 2, \"bar\": 2},                      {\"foo\": 2, \"bar\": 3},                  ]              )          )            # Test datanode indexing and slicing          assert dn[\"foo\"].equals(pd.Series([1, 1, 1, 2, 2, 2]))          assert dn[\"bar\"].equals(pd.Series([1, 2, 3, 1, 2, 3]))          assert dn[:2].equals(modin_pd.DataFrame([{\"foo\": 1, \"bar\": 1}, {\"foo\": 1, \"bar\": 2}]))            # Test filter data          filtered_by_filter_method = dn.filter((\"foo\", 1, Operator.EQUAL))          filtered_by_indexing = dn[dn[\"foo\"] == 1]          expected_data = modin_pd.DataFrame([{\"foo\": 1, \"bar\": 1}, {\"foo\": 1, \"bar\": 2}, {\"foo\": 1, \"bar\": 3}])          df_equals(filtered_by_filter_method.reset_index(drop=True), expected_data)          df_equals(filtered_by_indexing.reset_index(drop=True), expected_data)            filtered_by_filter_method = dn.filter((\"foo\", 1, Operator.NOT_EQUAL))          filtered_by_indexing = dn[dn[\"foo\"] != 1]          expected_data = modin_pd.DataFrame([{\"foo\": 2, \"bar\": 1}, {\"foo\": 2, \"bar\": 2}, {\"foo\": 2, \"bar\": 3}])          df_equals(filtered_by_filter_method.reset_index(drop=True), expected_data)          df_equals(filtered_by_indexing.reset_index(drop=True), expected_data)            filtered_by_filter_method = dn.filter([(\"bar\", 1, Operator.EQUAL), (\"bar\", 2, Operator.EQUAL)], JoinOperator.OR)          filtered_by_indexing = dn[(dn[\"bar\"] == 1) | (dn[\"bar\"] == 2)]          expected_data = modin_pd.DataFrame(              [                  {\"foo\": 1, \"bar\": 1},                  {\"foo\": 1, \"bar\": 2},                  {\"foo\": 2, \"bar\": 1},                  {\"foo\": 2, \"bar\": 2},              ]          )          df_equals(filtered_by_filter_method.reset_index(drop=True), expected_data)          df_equals(filtered_by_indexing.reset_index(drop=True), expected_data)        def test_filter_numpy_exposed_type(self, tmp_sqlite_sqlite3_file_path):          folder_path, db_name, file_extension = tmp_sqlite_sqlite3_file_path          properties = {              \"db_engine\": \"sqlite\",              \"table_name\": \"example\",              \"db_name\": db_name,              \"sqlite_folder_path\": folder_path,              \"sqlite_file_extension\": file_extension,              \"exposed_type\": \"numpy\",          }          dn = SQLTableDataNode(\"foo\", Scope.SCENARIO, properties=properties)          dn.write(              pd.DataFrame(                  [                      {\"foo\": 1, \"bar\": 1},                      {\"foo\": 1, \"bar\": 2},                      {\"foo\": 1, \"bar\": 3},                      {\"foo\": 2, \"bar\": 1},                      {\"foo\": 2, \"bar\": 2},                      {\"foo\": 2, \"bar\": 3},                  ]              )          )            # Test datanode indexing and slicing          assert np.array_equal(dn[0], np.array([1, 1]))          assert np.array_equal(dn[1], np.array([1, 2]))          assert np.array_equal(dn[:3], np.array([[1, 1], [1, 2], [1, 3]]))          assert np.array_equal(dn[:, 0], np.array([1, 1, 1, 2, 2, 2]))          assert np.array_equal(dn[1:4, :1], np.array([[1], [1], [2]]))            # Test filter data          assert np.array_equal(dn.filter((\"foo\", 1, Operator.EQUAL)), np.array([[1, 1], [1, 2], [1, 3]]))          assert np.array_equal(dn[dn[:, 0] == 1], np.array([[1, 1], [1, 2], [1, 3]]))            assert np.array_equal(dn.filter((\"foo\", 1, Operator.NOT_EQUAL)), np.array([[2, 1], [2, 2], [2, 3]]))          assert np.array_equal(dn[dn[:, 0] != 1], np.array([[2, 1], [2, 2], [2, 3]]))            assert np.array_equal(dn.filter((\"bar\", 2, Operator.EQUAL)), np.array([[1, 2], [2, 2]]))          assert np.array_equal(dn[dn[:, 1] == 2], np.array([[1, 2], [2, 2]]))            assert np.array_equal(              dn.filter([(\"bar\", 1, Operator.EQUAL), (\"bar\", 2, Operator.EQUAL)], JoinOperator.OR),              np.array([[1, 1], [1, 2], [2, 1], [2, 2]]),          )          assert np.array_equal(dn[(dn[:, 1] == 1) | (dn[:, 1] == 2)], np.array([[1, 1], [1, 2], [2, 1], [2, 2]]))        def test_filter_does_not_read_all_entities(self, tmp_sqlite_sqlite3_file_path):          folder_path, db_name, file_extension = tmp_sqlite_sqlite3_file_path          properties = {              \"db_engine\": \"sqlite\",              \"table_name\": \"example\",              \"db_name\": db_name,              \"sqlite_folder_path\": folder_path,              \"sqlite_file_extension\": file_extension,              \"exposed_type\": \"numpy\",          }          dn = SQLTableDataNode(\"foo\", Scope.SCENARIO, properties=properties)            # SQLTableDataNode.filter() should not call the MongoCollectionDataNode._read() method          with patch.object(SQLTableDataNode, \"_read\") as read_mock:              dn.filter((\"foo\", 1, Operator.EQUAL))              dn.filter((\"bar\", 2, Operator.NOT_EQUAL))              dn.filter([(\"bar\", 1, Operator.EQUAL), (\"bar\", 2, Operator.EQUAL)], JoinOperator.OR)                assert read_mock[\"_read\"].call_count == 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  from datetime import datetime, timedelta  from time import sleep  from unittest import mock    import pytest    import src.taipy.core as tp  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.data.data_node import DataNode  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 DataNodeIsBeingEdited, NoData  from src.taipy.core.job.job_id import JobId  from taipy.config import Config  from taipy.config.common.scope import Scope  from taipy.config.exceptions.exceptions import InvalidConfigurationId    from .utils import FakeDataNode      def funct_a_b(input: str):      print(\"task_a_b\")      return \"B\"      def funct_b_c(input: str):      print(\"task_b_c\")      return \"C\"      def funct_b_d(input: str):      print(\"task_b_d\")      return \"D\"      class TestDataNode:      def test_create_with_default_values(self):          dn = DataNode(\"foo_bar\")          assert dn.config_id == \"foo_bar\"          assert dn.scope == Scope.SCENARIO          assert dn.id is not None          assert dn.name is None          assert dn.owner_id is None          assert dn.parent_ids == set()          assert dn.last_edit_date is None          assert dn.job_ids == []          assert not dn.is_ready_for_reading          assert len(dn.properties) == 0        def test_create(self):          a_date = datetime.now()          dn = DataNode(              \"foo_bar\",              Scope.SCENARIO,              DataNodeId(\"an_id\"),              \"a_scenario_id\",              {\"a_parent_id\"},              a_date,              [dict(job_id=\"a_job_id\")],              edit_in_progress=False,              prop=\"erty\",              name=\"a name\",          )          assert dn.config_id == \"foo_bar\"          assert dn.scope == Scope.SCENARIO          assert dn.id == \"an_id\"          assert dn.name == \"a name\"          assert dn.owner_id == \"a_scenario_id\"          assert dn.parent_ids == {\"a_parent_id\"}          assert dn.last_edit_date == a_date          assert dn.job_ids == [\"a_job_id\"]          assert dn.is_ready_for_reading          assert len(dn.properties) == 2          assert dn.properties == {\"prop\": \"erty\", \"name\": \"a name\"}            with pytest.raises(InvalidConfigurationId):              DataNode(\"foo bar\")        def test_read_write(self):          dn = FakeDataNode(\"foo_bar\")          with pytest.raises(NoData):              assert dn.read() is None              dn.read_or_raise()          assert dn.write_has_been_called == 0          assert dn.read_has_been_called == 0          assert not dn.is_ready_for_reading          assert dn.last_edit_date is None          assert dn.job_ids == []          assert dn.edits == []            dn.write(\"Any data\")          assert dn.write_has_been_called == 1          assert dn.read_has_been_called == 0          assert dn.last_edit_date is not None          first_edition = dn.last_edit_date          assert dn.is_ready_for_reading          assert dn.job_ids == []          assert len(dn.edits) == 1          assert dn.get_last_edit()[\"timestamp\"] == dn.last_edit_date            sleep(0.1)            dn.write(\"Any other data\", job_id := JobId(\"a_job_id\"))          assert dn.write_has_been_called == 2          assert dn.read_has_been_called == 0          second_edition = dn.last_edit_date          assert first_edition < second_edition          assert dn.is_ready_for_reading          assert dn.job_ids == [job_id]          assert len(dn.edits) == 2          assert dn.get_last_edit()[\"timestamp\"] == dn.last_edit_date            dn.read()          assert dn.write_has_been_called == 2          assert dn.read_has_been_called == 1          second_edition = dn.last_edit_date          assert first_edition < second_edition          assert dn.is_ready_for_reading          assert dn.job_ids == [job_id]        def test_lock_initialization(self):          dn = InMemoryDataNode(\"dn\", Scope.SCENARIO)          assert not dn.edit_in_progress          assert dn._editor_id is None          assert dn._editor_expiration_date is None        def test_locked_dn_unlockable_only_by_same_editor(self):          dn = InMemoryDataNode(\"dn\", Scope.SCENARIO)          dn.lock_edit(\"user_1\")          assert dn.edit_in_progress          assert dn._editor_id == \"user_1\"          assert dn._editor_expiration_date is not None          with pytest.raises(DataNodeIsBeingEdited):              dn.lock_edit(\"user_2\")          with pytest.raises(DataNodeIsBeingEdited):              dn.unlock_edit(\"user_2\")          dn.unlock_edit(\"user_1\")          assert not dn.edit_in_progress          assert dn._editor_id is None          assert dn._editor_expiration_date is None        def test_none_editor_can_lock_a_locked_dn(self):          dn = InMemoryDataNode(\"dn\", Scope.SCENARIO)          dn.lock_edit(\"user\")          assert dn.edit_in_progress          assert dn._editor_id == \"user\"          assert dn._editor_expiration_date is not None          dn.lock_edit()          assert dn.edit_in_progress          assert dn._editor_id is None          assert dn._editor_expiration_date is None        def test_none_editor_can_unlock_a_locked_dn(self):          dn = InMemoryDataNode(\"dn\", Scope.SCENARIO)          dn.lock_edit(\"user\")          assert dn.edit_in_progress          assert dn._editor_id == \"user\"          assert dn._editor_expiration_date is not None          dn.unlock_edit()          assert not dn.edit_in_progress          assert dn._editor_id is None          assert dn._editor_expiration_date is None            dn.lock_edit()          assert dn.edit_in_progress          assert dn._editor_id is None          assert dn._editor_expiration_date is None          dn.unlock_edit()          assert not dn.edit_in_progress          assert dn._editor_id is None          assert dn._editor_expiration_date is None        def test_ready_for_reading(self):          dn = InMemoryDataNode(\"foo_bar\", Scope.CYCLE)          assert dn.last_edit_date is None          assert not dn.is_ready_for_reading          assert dn.job_ids == []            dn.lock_edit()          assert dn.last_edit_date is None          assert not dn.is_ready_for_reading          assert dn.job_ids == []            dn.unlock_edit()          assert dn.last_edit_date is None          assert not dn.is_ready_for_reading          assert dn.job_ids == []            dn.lock_edit()          assert dn.last_edit_date is None          assert not dn.is_ready_for_reading          assert dn.job_ids == []            dn.write(\"toto\", job_id := JobId(\"a_job_id\"))          assert dn.last_edit_date is not None          assert dn.is_ready_for_reading          assert dn.job_ids == [job_id]        def test_is_valid_no_validity_period(self):          # Test Never been writen          dn = InMemoryDataNode(\"foo\", Scope.SCENARIO, DataNodeId(\"id\"), \"name\", \"owner_id\")          assert not dn.is_valid            # test has been writen          dn.write(\"My data\")          assert dn.is_valid        def test_is_valid_with_30_min_validity_period(self):          # Test Never been writen          dn = InMemoryDataNode(              \"foo\", Scope.SCENARIO, DataNodeId(\"id\"), \"name\", \"owner_id\", validity_period=timedelta(minutes=30)          )          assert dn.is_valid is False            # Has been writen less than 30 minutes ago          dn.write(\"My data\")          assert dn.is_valid is True            # Has been writen more than 30 minutes ago          dn.last_edit_date = datetime.now() + timedelta(days=-1)          assert dn.is_valid is False        def test_is_valid_with_5_days_validity_period(self):          # Test Never been writen          dn = InMemoryDataNode(\"foo\", Scope.SCENARIO, validity_period=timedelta(days=5))          assert dn.is_valid is False            # Has been writen less than 30 minutes ago          dn.write(\"My data\")          assert dn.is_valid is True            # Has been writen more than 30 minutes ago          dn._last_edit_date = datetime.now() - timedelta(days=6)          _DataManager()._set(dn)          assert dn.is_valid is False        def test_is_up_to_date(self, current_datetime):          dn_confg_1 = Config.configure_in_memory_data_node(\"dn_1\")          dn_confg_2 = Config.configure_in_memory_data_node(\"dn_2\")          dn_confg_3 = Config.configure_in_memory_data_node(\"dn_3\", scope=Scope.GLOBAL)          task_config_1 = Config.configure_task(\"t1\", print, [dn_confg_1], [dn_confg_2])          task_config_2 = Config.configure_task(\"t2\", print, [dn_confg_2], [dn_confg_3])          scenario_config = Config.configure_scenario(\"sc\", [task_config_1, task_config_2])            scenario_1 = tp.create_scenario(scenario_config)          assert len(_DataManager._get_all()) == 3            dn_1_1 = scenario_1.data_nodes[\"dn_1\"]          dn_2_1 = scenario_1.data_nodes[\"dn_2\"]          dn_3_1 = scenario_1.data_nodes[\"dn_3\"]            assert dn_1_1.last_edit_date is None          assert dn_2_1.last_edit_date is None          assert dn_3_1.last_edit_date is None            dn_1_1.last_edit_date = current_datetime + timedelta(1)          dn_2_1.last_edit_date = current_datetime + timedelta(2)          dn_3_1.last_edit_date = current_datetime + timedelta(3)          assert dn_1_1.is_up_to_date          assert dn_2_1.is_up_to_date          assert dn_3_1.is_up_to_date            dn_2_1.last_edit_date = current_datetime + timedelta(4)          assert dn_1_1.is_up_to_date          assert dn_2_1.is_up_to_date          assert not dn_3_1.is_up_to_date            dn_1_1.last_edit_date = current_datetime + timedelta(5)          assert dn_1_1.is_up_to_date          assert not dn_2_1.is_up_to_date          assert not dn_3_1.is_up_to_date            dn_1_1.last_edit_date = current_datetime + timedelta(1)          dn_2_1.last_edit_date = current_datetime + timedelta(2)          dn_3_1.last_edit_date = current_datetime + timedelta(3)        def test_is_up_to_date_across_scenarios(self, current_datetime):          dn_confg_1 = Config.configure_in_memory_data_node(\"dn_1\", scope=Scope.SCENARIO)          dn_confg_2 = Config.configure_in_memory_data_node(\"dn_2\", scope=Scope.SCENARIO)          dn_confg_3 = Config.configure_in_memory_data_node(\"dn_3\", scope=Scope.GLOBAL)          task_config_1 = Config.configure_task(\"t1\", print, [dn_confg_1], [dn_confg_2])          task_config_2 = Config.configure_task(\"t2\", print, [dn_confg_2], [dn_confg_3])          scenario_config = Config.configure_scenario(\"sc\", [task_config_1, task_config_2])            scenario_1 = tp.create_scenario(scenario_config)          scenario_2 = tp.create_scenario(scenario_config)          assert len(_DataManager._get_all()) == 5            dn_1_1 = scenario_1.data_nodes[\"dn_1\"]          dn_2_1 = scenario_1.data_nodes[\"dn_2\"]          dn_1_2 = scenario_2.data_nodes[\"dn_1\"]          dn_2_2 = scenario_2.data_nodes[\"dn_2\"]          dn_3 = scenario_1.data_nodes[\"dn_3\"]          assert dn_3 == scenario_2.data_nodes[\"dn_3\"]            assert dn_1_1.last_edit_date is None          assert dn_2_1.last_edit_date is None          assert dn_1_2.last_edit_date is None          assert dn_2_2.last_edit_date is None          assert dn_3.last_edit_date is None            dn_1_1.last_edit_date = current_datetime + timedelta(1)          dn_2_1.last_edit_date = current_datetime + timedelta(2)          dn_1_2.last_edit_date = current_datetime + timedelta(3)          dn_2_2.last_edit_date = current_datetime + timedelta(4)          dn_3.last_edit_date = current_datetime + timedelta(5)          assert dn_1_1.is_up_to_date          assert dn_2_1.is_up_to_date          assert dn_1_2.is_up_to_date          assert dn_2_2.is_up_to_date          assert dn_3.is_up_to_date            dn_2_1.last_edit_date = current_datetime + timedelta(6)          assert dn_1_1.is_up_to_date          assert dn_2_1.is_up_to_date          assert dn_1_2.is_up_to_date          assert dn_2_2.is_up_to_date          assert not dn_3.is_up_to_date            dn_2_1.last_edit_date = current_datetime + timedelta(2)          dn_2_2.last_edit_date = current_datetime + timedelta(6)          assert dn_1_1.is_up_to_date          assert dn_2_1.is_up_to_date          assert dn_1_2.is_up_to_date          assert dn_2_2.is_up_to_date          assert not dn_3.is_up_to_date            dn_2_2.last_edit_date = current_datetime + timedelta(4)          dn_1_1.last_edit_date = current_datetime + timedelta(6)          assert dn_1_1.is_up_to_date          assert not dn_2_1.is_up_to_date          assert dn_1_2.is_up_to_date          assert dn_2_2.is_up_to_date          assert not dn_3.is_up_to_date            dn_1_2.last_edit_date = current_datetime + timedelta(6)          assert dn_1_1.is_up_to_date          assert not dn_2_1.is_up_to_date          assert dn_1_2.is_up_to_date          assert not dn_2_2.is_up_to_date          assert not dn_3.is_up_to_date        def test_do_not_recompute_data_node_valid_but_continue_sequence_execution(self):          Config.configure_job_executions(mode=JobConfig._DEVELOPMENT_MODE)            a = Config.configure_data_node(\"A\", \"pickle\", default_data=\"A\")          b = Config.configure_data_node(\"B\", \"pickle\")          c = Config.configure_data_node(\"C\", \"pickle\")          d = Config.configure_data_node(\"D\", \"pickle\")            task_a_b = Config.configure_task(\"task_a_b\", funct_a_b, input=a, output=b, skippable=True)          task_b_c = Config.configure_task(\"task_b_c\", funct_b_c, input=b, output=c)          task_b_d = Config.configure_task(\"task_b_d\", funct_b_d, input=b, output=d)          scenario_cfg = Config.configure_scenario(\"scenario\", [task_a_b, task_b_c, task_b_d])            _OrchestratorFactory._build_dispatcher()            scenario = tp.create_scenario(scenario_cfg)          scenario.submit()          assert scenario.A.read() == \"A\"          assert scenario.B.read() == \"B\"          assert scenario.C.read() == \"C\"          assert scenario.D.read() == \"D\"            scenario.submit()            assert len(tp.get_jobs()) == 6          jobs_and_status = [(job.task.config_id, job.status) for job in tp.get_jobs()]          assert (\"task_a_b\", tp.Status.COMPLETED) in jobs_and_status          assert (\"task_a_b\", tp.Status.SKIPPED) in jobs_and_status          assert (\"task_b_c\", tp.Status.COMPLETED) in jobs_and_status          assert (\"task_b_d\", tp.Status.COMPLETED) in jobs_and_status        def test_data_node_update_after_writing(self):          dn = FakeDataNode(\"foo\")            _DataManager._set(dn)          assert not _DataManager._get(dn.id).is_ready_for_reading          dn.write(\"Any data\")            assert dn.is_ready_for_reading          assert _DataManager._get(dn.id).is_ready_for_reading        def test_expiration_date_raise_if_never_write(self):          dn = FakeDataNode(\"foo\")            with pytest.raises(NoData):              dn.expiration_date        def test_validity_null_if_never_write(self):          dn = FakeDataNode(\"foo\")            assert dn.validity_period is None        def test_auto_set_and_reload(self, current_datetime):          dn_1 = InMemoryDataNode(              \"foo\",              scope=Scope.GLOBAL,              id=DataNodeId(\"an_id\"),              owner_id=None,              parent_ids=None,              last_edit_date=current_datetime,              edits=[dict(job_id=\"a_job_id\")],              edit_in_progress=False,              validity_period=None,              properties={                  \"name\": \"foo\",              },          )            dm = _DataManager()          dm._set(dn_1)            dn_2 = dm._get(dn_1)            # auto set & reload on scope attribute          assert dn_1.scope == Scope.GLOBAL          assert dn_2.scope == Scope.GLOBAL          dn_1.scope = Scope.CYCLE          assert dn_1.scope == Scope.CYCLE          assert dn_2.scope == Scope.CYCLE          dn_2.scope = Scope.SCENARIO          assert dn_1.scope == Scope.SCENARIO          assert dn_2.scope == Scope.SCENARIO            new_datetime = current_datetime + timedelta(1)          new_datetime_1 = current_datetime + timedelta(3)            # auto set & reload on last_edit_date attribute          assert dn_1.last_edit_date == current_datetime          assert dn_2.last_edit_date == current_datetime          dn_1.last_edit_date = new_datetime_1          assert dn_1.last_edit_date == new_datetime_1          assert dn_2.last_edit_date == new_datetime_1          dn_2.last_edit_date = new_datetime          assert dn_1.last_edit_date == new_datetime          assert dn_2.last_edit_date == new_datetime            # auto set & reload on name attribute          assert dn_1.name == \"foo\"          assert dn_2.name == \"foo\"          dn_1.name = \"fed\"          assert dn_1.name == \"fed\"          assert dn_2.name == \"fed\"          dn_2.name = \"def\"          assert dn_1.name == \"def\"          assert dn_2.name == \"def\"            # auto set & reload on parent_ids attribute (set() object does not have auto set yet)          assert dn_1.parent_ids == set()          assert dn_2.parent_ids == set()          dn_1._parent_ids.update([\"sc2\"])          _DataManager._set(dn_1)          assert dn_1.parent_ids == {\"sc2\"}          assert dn_2.parent_ids == {\"sc2\"}          dn_2._parent_ids.clear()          dn_2._parent_ids.update([\"sc1\"])          _DataManager._set(dn_2)          assert dn_1.parent_ids == {\"sc1\"}          assert dn_2.parent_ids == {\"sc1\"}            # auto set & reload on edit_in_progress attribute          assert not dn_2.edit_in_progress          assert not dn_1.edit_in_progress          dn_1.edit_in_progress = True          assert dn_1.edit_in_progress          assert dn_2.edit_in_progress          dn_2.unlock_edit()          assert not dn_1.edit_in_progress          assert not dn_2.edit_in_progress          dn_1.lock_edit()          assert dn_1.edit_in_progress          assert dn_2.edit_in_progress            # auto set & reload on validity_period attribute          time_period_1 = timedelta(1)          time_period_2 = timedelta(5)          assert dn_1.validity_period is None          assert dn_2.validity_period is None          dn_1.validity_period = time_period_1          assert dn_1.validity_period == time_period_1          assert dn_2.validity_period == time_period_1          dn_2.validity_period = time_period_2          assert dn_1.validity_period == time_period_2          assert dn_2.validity_period == time_period_2            # auto set & reload on properties attribute          assert dn_1.properties == {\"name\": \"def\"}          assert dn_2.properties == {\"name\": \"def\"}          dn_1._properties[\"qux\"] = 4          assert dn_1.properties[\"qux\"] == 4          assert dn_2.properties[\"qux\"] == 4            assert dn_1.properties == {\"qux\": 4, \"name\": \"def\"}          assert dn_2.properties == {\"qux\": 4, \"name\": \"def\"}          dn_2._properties[\"qux\"] = 5          assert dn_1.properties[\"qux\"] == 5          assert dn_2.properties[\"qux\"] == 5            dn_1.properties[\"temp_key_1\"] = \"temp_value_1\"          dn_1.properties[\"temp_key_2\"] = \"temp_value_2\"          assert dn_1.properties == {              \"name\": \"def\",              \"qux\": 5,              \"temp_key_1\": \"temp_value_1\",              \"temp_key_2\": \"temp_value_2\",          }          assert dn_2.properties == {              \"name\": \"def\",              \"qux\": 5,              \"temp_key_1\": \"temp_value_1\",              \"temp_key_2\": \"temp_value_2\",          }          dn_1.properties.pop(\"temp_key_1\")          assert \"temp_key_1\" not in dn_1.properties.keys()          assert \"temp_key_1\" not in dn_1.properties.keys()          assert dn_1.properties == {              \"name\": \"def\",              \"qux\": 5,              \"temp_key_2\": \"temp_value_2\",          }          assert dn_2.properties == {              \"name\": \"def\",              \"qux\": 5,              \"temp_key_2\": \"temp_value_2\",          }          dn_2.properties.pop(\"temp_key_2\")          assert dn_1.properties == {              \"qux\": 5,              \"name\": \"def\",          }          assert dn_2.properties == {              \"qux\": 5,              \"name\": \"def\",          }          assert \"temp_key_2\" not in dn_1.properties.keys()          assert \"temp_key_2\" not in dn_2.properties.keys()            dn_1.properties[\"temp_key_3\"] = 0          assert dn_1.properties == {              \"qux\": 5,              \"temp_key_3\": 0,              \"name\": \"def\",          }          assert dn_2.properties == {              \"qux\": 5,              \"temp_key_3\": 0,              \"name\": \"def\",          }          dn_1.properties.update({\"temp_key_3\": 1})          assert dn_1.properties == {              \"qux\": 5,              \"temp_key_3\": 1,              \"name\": \"def\",          }          assert dn_2.properties == {              \"qux\": 5,              \"temp_key_3\": 1,              \"name\": \"def\",          }          dn_1.properties.update(dict())          assert dn_1.properties == {              \"qux\": 5,              \"temp_key_3\": 1,              \"name\": \"def\",          }          assert dn_2.properties == {              \"qux\": 5,              \"temp_key_3\": 1,              \"name\": \"def\",          }          dn_1.properties[\"temp_key_4\"] = 0          dn_1.properties[\"temp_key_5\"] = 0            dn_1.last_edit_date = new_datetime            assert len(dn_1.job_ids) == 1          assert len(dn_2.job_ids) == 1            with dn_1 as dn:              assert dn.config_id == \"foo\"              assert dn.owner_id is None              assert dn.scope == Scope.SCENARIO              assert dn.last_edit_date == new_datetime              assert dn.name == \"def\"              assert dn.edit_in_progress              assert dn.validity_period == time_period_2              assert len(dn.job_ids) == 1              assert dn._is_in_context              assert dn.properties[\"qux\"] == 5              assert dn.properties[\"temp_key_3\"] == 1              assert dn.properties[\"temp_key_4\"] == 0              assert dn.properties[\"temp_key_5\"] == 0                new_datetime_2 = new_datetime + timedelta(5)                dn.scope = Scope.CYCLE              dn.last_edit_date = new_datetime_2              dn.name = \"abc\"              dn.edit_in_progress = False              dn.validity_period = None              dn.properties[\"qux\"] = 9              dn.properties.pop(\"temp_key_3\")              dn.properties.pop(\"temp_key_4\")              dn.properties.update({\"temp_key_4\": 1})              dn.properties.update({\"temp_key_5\": 2})              dn.properties.pop(\"temp_key_5\")              dn.properties.update(dict())                assert dn.config_id == \"foo\"              assert dn.owner_id is None              assert dn.scope == Scope.SCENARIO              assert dn.last_edit_date == new_datetime              assert dn.name == \"def\"              assert dn.edit_in_progress              assert dn.validity_period == time_period_2              assert len(dn.job_ids) == 1              assert dn.properties[\"qux\"] == 5              assert dn.properties[\"temp_key_3\"] == 1              assert dn.properties[\"temp_key_4\"] == 0              assert dn.properties[\"temp_key_5\"] == 0            assert dn_1.config_id == \"foo\"          assert dn_1.owner_id is None          assert dn_1.scope == Scope.CYCLE          assert dn_1.last_edit_date == new_datetime_2          assert dn_1.name == \"abc\"          assert not dn_1.edit_in_progress          assert dn_1.validity_period is None          assert not dn_1._is_in_context          assert len(dn_1.job_ids) == 1          assert dn_1.properties[\"qux\"] == 9          assert \"temp_key_3\" not in dn_1.properties.keys()          assert dn_1.properties[\"temp_key_4\"] == 1          assert \"temp_key_5\" not in dn_1.properties.keys()        def test_get_parents(self, data_node):          with mock.patch(\"src.taipy.core.get_parents\") as mck:              data_node.get_parents()              mck.assert_called_once_with(data_node)        def test_cacheable_deprecated_false(self):          dn = FakeDataNode(\"foo\")          with pytest.warns(DeprecationWarning):              dn.cacheable          assert dn.cacheable is False        def test_cacheable_deprecated_true(self):          dn = FakeDataNode(\"foo\", properties={\"cacheable\": True})          with pytest.warns(DeprecationWarning):              dn.cacheable          assert dn.cacheable is True        def test_data_node_with_env_variable_value_not_stored(self):          dn_config = Config.configure_data_node(\"A\", prop=\"ENV[FOO]\")          with mock.patch.dict(os.environ, {\"FOO\": \"bar\"}):              dn = _DataManager._bulk_get_or_create([dn_config])[dn_config]              assert dn._properties.data[\"prop\"] == \"ENV[FOO]\"              assert dn.properties[\"prop\"] == \"bar\"              assert dn.prop == \"bar\"        def test_path_populated_with_config_default_path(self):          dn_config = Config.configure_data_node(\"data_node\", \"pickle\", default_path=\"foo.p\")          assert dn_config.default_path == \"foo.p\"          data_node = _DataManager._bulk_get_or_create([dn_config])[dn_config]          assert data_node.path == \"foo.p\"          data_node.path = \"baz.p\"          assert data_node.path == \"baz.p\"        def test_track_edit(self):          dn_config = Config.configure_data_node(\"A\")          data_node = _DataManager._bulk_get_or_create([dn_config])[dn_config]            data_node.write(data=\"1\", job_id=\"job_1\")          data_node.write(data=\"2\", job_id=\"job_1\")          data_node.write(data=\"3\", job_id=\"job_1\")            assert len(data_node.edits) == 3          assert len(data_node.job_ids) == 3          assert data_node.edits[-1] == data_node.get_last_edit()          assert data_node.last_edit_date == data_node.get_last_edit().get(\"timestamp\")            date = datetime(2050, 1, 1, 12, 12)          data_node.write(data=\"4\", timestamp=date, message=\"This is a comment on this edit\", env=\"staging\")            assert len(data_node.edits) == 4          assert len(data_node.job_ids) == 3          assert data_node.edits[-1] == data_node.get_last_edit()            last_edit = data_node.get_last_edit()          assert last_edit[\"message\"] == \"This is a comment on this edit\"          assert last_edit[\"env\"] == \"staging\"          assert last_edit[\"timestamp\"] == date        def test_label(self):          a_date = datetime.now()          dn = DataNode(              \"foo_bar\",              Scope.SCENARIO,              DataNodeId(\"an_id\"),              \"a_scenario_id\",              {\"a_parent_id\"},              a_date,              [dict(job_id=\"a_job_id\")],              edit_in_progress=False,              prop=\"erty\",              name=\"a name\",          )          with mock.patch(\"src.taipy.core.get\") as get_mck:                class MockOwner:                  label = \"owner_label\"                    def get_label(self):                      return self.label                get_mck.return_value = MockOwner()              assert dn.get_label() == \"owner_label > \" + dn.name              assert dn.get_simple_label() == dn.name        def test_explicit_label(self):          a_date = datetime.now()          dn = DataNode(              \"foo_bar\",              Scope.SCENARIO,              DataNodeId(\"an_id\"),              \"a_scenario_id\",              {\"a_parent_id\"},              a_date,              [dict(job_id=\"a_job_id\")],              edit_in_progress=False,              label=\"a label\",              name=\"a name\",          )          assert dn.get_label() == \"a label\"          assert dn.get_simple_label() == \"a label\"        def test_change_data_node_name(self):          cgf = Config.configure_data_node(\"foo\", scope=Scope.GLOBAL)          dn = tp.create_global_data_node(cgf)            dn.name = \"bar\"          assert dn.name == \"bar\"            # This new syntax will be the only one allowed: https://github.com/Avaiga/taipy-core/issues/806          dn.properties[\"name\"] = \"baz\"          assert dn.name == \"baz\" "}
{"text": "import os  import pathlib  from datetime import datetime  from time import sleep    import modin.pandas as modin_pd  import numpy as np  import pandas as pd  import pytest  from modin.pandas.test.utils import df_equals  from pandas.testing import assert_frame_equal    from src.taipy.core.data._data_manager import _DataManager  from src.taipy.core.data.csv import CSVDataNode  from src.taipy.core.data.data_node_id import DataNodeId  from src.taipy.core.data.operator import JoinOperator, Operator  from src.taipy.core.exceptions.exceptions import InvalidExposedType, NoData  from taipy.config.common.scope import Scope  from taipy.config.config import Config  from taipy.config.exceptions.exceptions import InvalidConfigurationId      @pytest.fixture(scope=\"function\", autouse=True)  def cleanup():      yield      path = os.path.join(pathlib.Path(__file__).parent.resolve(), \"data_sample/temp.csv\")      if os.path.isfile(path):          os.remove(path)      class MyCustomObject:      def __init__(self, id, integer, text):          self.id = id          self.integer = integer          self.text = text      class TestCSVDataNode:      def test_create(self):          path = \"data/node/path\"          dn = CSVDataNode(              \"foo_bar\", Scope.SCENARIO, properties={\"path\": path, \"has_header\": False, \"name\": \"super name\"}          )          assert isinstance(dn, CSVDataNode)          assert dn.storage_type() == \"csv\"          assert dn.config_id == \"foo_bar\"          assert dn.name == \"super name\"          assert dn.scope == Scope.SCENARIO          assert dn.id is not None          assert dn.owner_id is None          assert dn.last_edit_date is None          assert dn.job_ids == []          assert not dn.is_ready_for_reading          assert dn.path == path          assert dn.has_header is False          assert dn.exposed_type == \"pandas\"            with pytest.raises(InvalidConfigurationId):              dn = CSVDataNode(                  \"foo bar\", Scope.SCENARIO, properties={\"path\": path, \"has_header\": False, \"name\": \"super name\"}              )        def test_get_user_properties(self, csv_file):          dn_1 = CSVDataNode(\"dn_1\", Scope.SCENARIO, properties={\"path\": \"data/node/path\"})          assert dn_1._get_user_properties() == {}            dn_2 = CSVDataNode(              \"dn_2\",              Scope.SCENARIO,              properties={                  \"exposed_type\": \"numpy\",                  \"default_data\": \"foo\",                  \"default_path\": csv_file,                  \"has_header\": False,                  \"foo\": \"bar\",              },          )            # exposed_type, default_data, default_path, path, has_header, sheet_name are filtered out          assert dn_2._get_user_properties() == {\"foo\": \"bar\"}        def test_new_csv_data_node_with_existing_file_is_ready_for_reading(self):          not_ready_dn_cfg = Config.configure_data_node(\"not_ready_data_node_config_id\", \"csv\", path=\"NOT_EXISTING.csv\")          not_ready_dn = _DataManager._bulk_get_or_create([not_ready_dn_cfg])[not_ready_dn_cfg]          assert not not_ready_dn.is_ready_for_reading            path = os.path.join(pathlib.Path(__file__).parent.resolve(), \"data_sample/example.csv\")          ready_dn_cfg = Config.configure_data_node(\"ready_data_node_config_id\", \"csv\", path=path)          ready_dn = _DataManager._bulk_get_or_create([ready_dn_cfg])[ready_dn_cfg]          assert ready_dn.is_ready_for_reading        @pytest.mark.parametrize(          [\"properties\", \"exists\"],          [              ({}, False),              ({\"default_data\": [\"foo\", \"bar\"]}, True),          ],      )      def test_create_with_default_data(self, properties, exists):          dn = CSVDataNode(\"foo\", Scope.SCENARIO, DataNodeId(\"dn_id\"), properties=properties)          assert os.path.exists(dn.path) is exists        def test_read_with_header(self):          not_existing_csv = CSVDataNode(\"foo\", Scope.SCENARIO, properties={\"path\": \"WRONG.csv\", \"has_header\": True})          with pytest.raises(NoData):              assert not_existing_csv.read() is None              not_existing_csv.read_or_raise()            path = os.path.join(pathlib.Path(__file__).parent.resolve(), \"data_sample/example.csv\")          # # Create CSVDataNode without exposed_type (Default is pandas.DataFrame)          csv_data_node_as_pandas = CSVDataNode(\"bar\", Scope.SCENARIO, properties={\"path\": path})          data_pandas = csv_data_node_as_pandas.read()          assert isinstance(data_pandas, pd.DataFrame)          assert len(data_pandas) == 10          assert np.array_equal(data_pandas.to_numpy(), pd.read_csv(path).to_numpy())            # Create CSVDataNode with modin exposed_type          csv_data_node_as_modin = CSVDataNode(\"bar\", Scope.SCENARIO, properties={\"path\": path, \"exposed_type\": \"modin\"})          data_modin = csv_data_node_as_modin.read()          assert isinstance(data_modin, modin_pd.DataFrame)          assert len(data_modin) == 10          assert np.array_equal(data_modin.to_numpy(), modin_pd.read_csv(path).to_numpy())            # Create CSVDataNode with numpy exposed_type          csv_data_node_as_numpy = CSVDataNode(              \"bar\", Scope.SCENARIO, properties={\"path\": path, \"has_header\": True, \"exposed_type\": \"numpy\"}          )          data_numpy = csv_data_node_as_numpy.read()          assert isinstance(data_numpy, np.ndarray)          assert len(data_numpy) == 10          assert np.array_equal(data_numpy, pd.read_csv(path).to_numpy())            # Create the same CSVDataNode but with custom exposed_type          csv_data_node_as_custom_object = CSVDataNode(              \"bar\", Scope.SCENARIO, properties={\"path\": path, \"exposed_type\": MyCustomObject}          )          data_custom = csv_data_node_as_custom_object.read()          assert isinstance(data_custom, list)          assert len(data_custom) == 10            for (index, row_pandas), row_custom in zip(data_pandas.iterrows(), data_custom):              assert isinstance(row_custom, MyCustomObject)              assert row_pandas[\"id\"] == row_custom.id              assert str(row_pandas[\"integer\"]) == row_custom.integer              assert row_pandas[\"text\"] == row_custom.text        def test_read_without_header(self):          not_existing_csv = CSVDataNode(\"foo\", Scope.SCENARIO, properties={\"path\": \"WRONG.csv\", \"has_header\": False})          with pytest.raises(NoData):              assert not_existing_csv.read() is None              not_existing_csv.read_or_raise()            path = os.path.join(pathlib.Path(__file__).parent.resolve(), \"data_sample/example.csv\")          # Create CSVDataNode without exposed_type (Default is pandas.DataFrame)          csv_data_node_as_pandas = CSVDataNode(\"bar\", Scope.SCENARIO, properties={\"path\": path, \"has_header\": False})          data_pandas = csv_data_node_as_pandas.read()          assert isinstance(data_pandas, pd.DataFrame)          assert len(data_pandas) == 11          assert np.array_equal(data_pandas.to_numpy(), pd.read_csv(path, header=None).to_numpy())            # Create CSVDataNode with modin exposed_type          csv_data_node_as_modin = CSVDataNode(              \"baz\", Scope.SCENARIO, properties={\"path\": path, \"has_header\": False, \"exposed_type\": \"modin\"}          )          data_modin = csv_data_node_as_modin.read()          assert isinstance(data_modin, modin_pd.DataFrame)          assert len(data_modin) == 11          assert np.array_equal(data_modin.to_numpy(), modin_pd.read_csv(path, header=None).to_numpy())            # Create CSVDataNode with numpy exposed_type          csv_data_node_as_numpy = CSVDataNode(              \"qux\", Scope.SCENARIO, properties={\"path\": path, \"has_header\": False, \"exposed_type\": \"numpy\"}          )          data_numpy = csv_data_node_as_numpy.read()          assert isinstance(data_numpy, np.ndarray)          assert len(data_numpy) == 11          assert np.array_equal(data_numpy, pd.read_csv(path, header=None).to_numpy())            # Create the same CSVDataNode but with custom exposed_type          csv_data_node_as_custom_object = CSVDataNode(              \"quux\", Scope.SCENARIO, properties={\"path\": path, \"has_header\": False, \"exposed_type\": MyCustomObject}          )          data_custom = csv_data_node_as_custom_object.read()          assert isinstance(data_custom, list)          assert len(data_custom) == 11            for (index, row_pandas), row_custom in zip(data_pandas.iterrows(), data_custom):              assert isinstance(row_custom, MyCustomObject)              assert row_pandas[0] == row_custom.id              assert str(row_pandas[1]) == row_custom.integer              assert row_pandas[2] == row_custom.text        @pytest.mark.parametrize(          \"content\",          [              ([{\"a\": 11, \"b\": 22, \"c\": 33}, {\"a\": 44, \"b\": 55, \"c\": 66}]),              (pd.DataFrame([{\"a\": 11, \"b\": 22, \"c\": 33}, {\"a\": 44, \"b\": 55, \"c\": 66}])),              ([[11, 22, 33], [44, 55, 66]]),          ],      )      def test_append(self, csv_file, default_data_frame, content):          csv_dn = CSVDataNode(\"foo\", Scope.SCENARIO, properties={\"path\": csv_file})          assert_frame_equal(csv_dn.read(), default_data_frame)            csv_dn.append(content)          assert_frame_equal(              csv_dn.read(),              pd.concat([default_data_frame, pd.DataFrame(content, columns=[\"a\", \"b\", \"c\"])]).reset_index(drop=True),          )        @pytest.mark.parametrize(          \"content\",          [              ([{\"a\": 11, \"b\": 22, \"c\": 33}, {\"a\": 44, \"b\": 55, \"c\": 66}]),              (pd.DataFrame([{\"a\": 11, \"b\": 22, \"c\": 33}, {\"a\": 44, \"b\": 55, \"c\": 66}])),              ([[11, 22, 33], [44, 55, 66]]),          ],      )      def test_append_modin(self, csv_file, default_data_frame, content):          csv_dn = CSVDataNode(\"foo\", Scope.SCENARIO, properties={\"path\": csv_file, \"exposed_type\": \"modin\"})          df_equals(csv_dn.read(), modin_pd.DataFrame(default_data_frame))            csv_dn.append(content)          df_equals(              csv_dn.read(),              modin_pd.concat([default_data_frame, pd.DataFrame(content, columns=[\"a\", \"b\", \"c\"])]).reset_index(                  drop=True              ),          )        @pytest.mark.parametrize(          \"content,columns\",          [              ([{\"a\": 11, \"b\": 22, \"c\": 33}, {\"a\": 44, \"b\": 55, \"c\": 66}], None),              ([[11, 22, 33], [44, 55, 66]], None),              ([[11, 22, 33], [44, 55, 66]], [\"e\", \"f\", \"g\"]),          ],      )      def test_write(self, csv_file, default_data_frame, content, columns):          csv_dn = CSVDataNode(\"foo\", Scope.SCENARIO, properties={\"path\": csv_file})          assert np.array_equal(csv_dn.read().values, default_data_frame.values)          if not columns:              csv_dn.write(content)              df = pd.DataFrame(content)          else:              csv_dn.write_with_column_names(content, columns)              df = pd.DataFrame(content, columns=columns)          assert np.array_equal(csv_dn.read().values, df.values)            csv_dn.write(None)          assert len(csv_dn.read()) == 0        def test_write_with_different_encoding(self, csv_file):          data = pd.DataFrame([{\"\u2265a\": 1, \"b\": 2}])            utf8_dn = CSVDataNode(\"utf8_dn\", Scope.SCENARIO, properties={\"default_path\": csv_file})          utf16_dn = CSVDataNode(\"utf16_dn\", Scope.SCENARIO, properties={\"default_path\": csv_file, \"encoding\": \"utf-16\"})            # If a file is written with utf-8 encoding, it can only be read with utf-8, not utf-16 encoding          utf8_dn.write(data)          assert np.array_equal(utf8_dn.read(), data)          with pytest.raises(UnicodeError):              utf16_dn.read()            # If a file is written with utf-16 encoding, it can only be read with utf-16, not utf-8 encoding          utf16_dn.write(data)          assert np.array_equal(utf16_dn.read(), data)          with pytest.raises(UnicodeError):              utf8_dn.read()        @pytest.mark.parametrize(          \"content,columns\",          [              ([{\"a\": 11, \"b\": 22, \"c\": 33}, {\"a\": 44, \"b\": 55, \"c\": 66}], None),              ([[11, 22, 33], [44, 55, 66]], None),              ([[11, 22, 33], [44, 55, 66]], [\"e\", \"f\", \"g\"]),          ],      )      def test_write_modin(self, csv_file, default_data_frame, content, columns):          default_data_frame = modin_pd.DataFrame(default_data_frame)          csv_dn = CSVDataNode(\"foo\", Scope.SCENARIO, properties={\"path\": csv_file, \"exposed_type\": \"modin\"})          assert np.array_equal(csv_dn.read().values, default_data_frame.values)          if not columns:              csv_dn.write(content)              df = pd.DataFrame(content)          else:              csv_dn.write_with_column_names(content, columns)              df = pd.DataFrame(content, columns=columns)          assert np.array_equal(csv_dn.read().values, df.values)            csv_dn.write(None)          assert len(csv_dn.read()) == 0        def test_write_modin_with_different_encoding(self, csv_file):          data = pd.DataFrame([{\"\u2265a\": 1, \"b\": 2}])            utf8_dn = CSVDataNode(\"utf8_dn\", Scope.SCENARIO, properties={\"path\": csv_file, \"exposed_type\": \"modin\"})          utf16_dn = CSVDataNode(              \"utf16_dn\", Scope.SCENARIO, properties={\"path\": csv_file, \"exposed_type\": \"modin\", \"encoding\": \"utf-16\"}          )            # If a file is written with utf-8 encoding, it can only be read with utf-8, not utf-16 encoding          utf8_dn.write(data)          assert np.array_equal(utf8_dn.read(), data)          with pytest.raises(UnicodeError):              utf16_dn.read()            # If a file is written with utf-16 encoding, it can only be read with utf-16, not utf-8 encoding          utf16_dn.write(data)          assert np.array_equal(utf16_dn.read(), data)          with pytest.raises(UnicodeError):              utf8_dn.read()        def test_set_path(self):          dn = CSVDataNode(\"foo\", Scope.SCENARIO, properties={\"default_path\": \"foo.csv\"})          assert dn.path == \"foo.csv\"          dn.path = \"bar.csv\"          assert dn.path == \"bar.csv\"        def test_read_write_after_modify_path(self):          path = os.path.join(pathlib.Path(__file__).parent.resolve(), \"data_sample/example.csv\")          new_path = os.path.join(pathlib.Path(__file__).parent.resolve(), \"data_sample/temp.csv\")          dn = CSVDataNode(\"foo\", Scope.SCENARIO, properties={\"default_path\": path})          read_data = dn.read()          assert read_data is not None          dn.path = new_path          with pytest.raises(FileNotFoundError):              dn.read()          dn.write(read_data)          assert dn.read().equals(read_data)        def test_pandas_exposed_type(self):          path = os.path.join(pathlib.Path(__file__).parent.resolve(), \"data_sample/example.csv\")          dn = CSVDataNode(\"foo\", Scope.SCENARIO, properties={\"path\": path, \"exposed_type\": \"pandas\"})          assert isinstance(dn.read(), pd.DataFrame)        def test_filter_pandas_exposed_type(self, csv_file):          dn = CSVDataNode(\"foo\", Scope.SCENARIO, properties={\"path\": csv_file, \"exposed_type\": \"pandas\"})          dn.write(              [                  {\"foo\": 1, \"bar\": 1},                  {\"foo\": 1, \"bar\": 2},                  {\"foo\": 1},                  {\"foo\": 2, \"bar\": 2},                  {\"bar\": 2},              ]          )            # Test datanode indexing and slicing          assert dn[\"foo\"].equals(pd.Series([1, 1, 1, 2, None]))          assert dn[\"bar\"].equals(pd.Series([1, 2, None, 2, 2]))          assert dn[:2].equals(pd.DataFrame([{\"foo\": 1.0, \"bar\": 1.0}, {\"foo\": 1.0, \"bar\": 2.0}]))            # Test filter data          filtered_by_filter_method = dn.filter((\"foo\", 1, Operator.EQUAL))          filtered_by_indexing = dn[dn[\"foo\"] == 1]          expected_data = pd.DataFrame([{\"foo\": 1.0, \"bar\": 1.0}, {\"foo\": 1.0, \"bar\": 2.0}, {\"foo\": 1.0}])          assert_frame_equal(filtered_by_filter_method.reset_index(drop=True), expected_data)          assert_frame_equal(filtered_by_indexing.reset_index(drop=True), expected_data)            filtered_by_filter_method = dn.filter((\"foo\", 1, Operator.NOT_EQUAL))          filtered_by_indexing = dn[dn[\"foo\"] != 1]          expected_data = pd.DataFrame([{\"foo\": 2.0, \"bar\": 2.0}, {\"bar\": 2.0}])          assert_frame_equal(filtered_by_filter_method.reset_index(drop=True), expected_data)          assert_frame_equal(filtered_by_indexing.reset_index(drop=True), expected_data)            filtered_by_filter_method = dn.filter((\"bar\", 2, Operator.EQUAL))          filtered_by_indexing = dn[dn[\"bar\"] == 2]          expected_data = pd.DataFrame([{\"foo\": 1.0, \"bar\": 2.0}, {\"foo\": 2.0, \"bar\": 2.0}, {\"bar\": 2.0}])          assert_frame_equal(filtered_by_filter_method.reset_index(drop=True), expected_data)          assert_frame_equal(filtered_by_indexing.reset_index(drop=True), expected_data)            filtered_by_filter_method = dn.filter([(\"bar\", 1, Operator.EQUAL), (\"bar\", 2, Operator.EQUAL)], JoinOperator.OR)          filtered_by_indexing = dn[(dn[\"bar\"] == 1) | (dn[\"bar\"] == 2)]          expected_data = pd.DataFrame(              [                  {\"foo\": 1.0, \"bar\": 1.0},                  {\"foo\": 1.0, \"bar\": 2.0},                  {\"foo\": 2.0, \"bar\": 2.0},                  {\"bar\": 2.0},              ]          )          assert_frame_equal(filtered_by_filter_method.reset_index(drop=True), expected_data)          assert_frame_equal(filtered_by_indexing.reset_index(drop=True), expected_data)        def test_filter_modin_exposed_type(self, csv_file):          dn = CSVDataNode(\"foo\", Scope.SCENARIO, properties={\"path\": csv_file, \"exposed_type\": \"modin\"})          dn.write(              [                  {\"foo\": 1, \"bar\": 1},                  {\"foo\": 1, \"bar\": 2},                  {\"foo\": 1},                  {\"foo\": 2, \"bar\": 2},                  {\"bar\": 2},              ]          )            # Test datanode indexing and slicing          assert dn[\"foo\"].equals(modin_pd.Series([1, 1, 1, 2, None]))          assert dn[\"bar\"].equals(modin_pd.Series([1, 2, None, 2, 2]))          assert dn[:2].equals(modin_pd.DataFrame([{\"foo\": 1.0, \"bar\": 1.0}, {\"foo\": 1.0, \"bar\": 2.0}]))            # Test filter data          filtered_by_filter_method = dn.filter((\"foo\", 1, Operator.EQUAL))          filtered_by_indexing = dn[dn[\"foo\"] == 1]          expected_data = modin_pd.DataFrame([{\"foo\": 1.0, \"bar\": 1.0}, {\"foo\": 1.0, \"bar\": 2.0}, {\"foo\": 1.0}])          df_equals(filtered_by_filter_method.reset_index(drop=True), expected_data)          df_equals(filtered_by_indexing.reset_index(drop=True), expected_data)            filtered_by_filter_method = dn.filter((\"foo\", 1, Operator.NOT_EQUAL))          filtered_by_indexing = dn[dn[\"foo\"] != 1]          expected_data = modin_pd.DataFrame([{\"foo\": 2.0, \"bar\": 2.0}, {\"bar\": 2.0}])          df_equals(filtered_by_filter_method.reset_index(drop=True), expected_data)          df_equals(filtered_by_indexing.reset_index(drop=True), expected_data)            filtered_by_filter_method = dn.filter((\"bar\", 2, Operator.EQUAL))          filtered_by_indexing = dn[dn[\"bar\"] == 2]          expected_data = modin_pd.DataFrame([{\"foo\": 1.0, \"bar\": 2.0}, {\"foo\": 2.0, \"bar\": 2.0}, {\"bar\": 2.0}])          df_equals(filtered_by_filter_method.reset_index(drop=True), expected_data)          df_equals(filtered_by_indexing.reset_index(drop=True), expected_data)            filtered_by_filter_method = dn.filter([(\"bar\", 1, Operator.EQUAL), (\"bar\", 2, Operator.EQUAL)], JoinOperator.OR)          filtered_by_indexing = dn[(dn[\"bar\"] == 1) | (dn[\"bar\"] == 2)]          expected_data = modin_pd.DataFrame(              [                  {\"foo\": 1.0, \"bar\": 1.0},                  {\"foo\": 1.0, \"bar\": 2.0},                  {\"foo\": 2.0, \"bar\": 2.0},                  {\"bar\": 2.0},              ]          )          df_equals(filtered_by_filter_method.reset_index(drop=True), expected_data)          df_equals(filtered_by_indexing.reset_index(drop=True), expected_data)        def test_filter_numpy_exposed_type(self, csv_file):          dn = CSVDataNode(\"foo\", Scope.SCENARIO, properties={\"path\": csv_file, \"exposed_type\": \"numpy\"})          dn.write(              [                  [1, 1],                  [1, 2],                  [1, 3],                  [2, 1],                  [2, 2],                  [2, 3],              ]          )            # Test datanode indexing and slicing          assert np.array_equal(dn[0], np.array([1, 1]))          assert np.array_equal(dn[1], np.array([1, 2]))          assert np.array_equal(dn[:3], np.array([[1, 1], [1, 2], [1, 3]]))          assert np.array_equal(dn[:, 0], np.array([1, 1, 1, 2, 2, 2]))          assert np.array_equal(dn[1:4, :1], np.array([[1], [1], [2]]))            # Test filter data          assert np.array_equal(dn.filter((0, 1, Operator.EQUAL)), np.array([[1, 1], [1, 2], [1, 3]]))          assert np.array_equal(dn[dn[:, 0] == 1], np.array([[1, 1], [1, 2], [1, 3]]))            assert np.array_equal(dn.filter((0, 1, Operator.NOT_EQUAL)), np.array([[2, 1], [2, 2], [2, 3]]))          assert np.array_equal(dn[dn[:, 0] != 1], np.array([[2, 1], [2, 2], [2, 3]]))            assert np.array_equal(dn.filter((1, 2, Operator.EQUAL)), np.array([[1, 2], [2, 2]]))          assert np.array_equal(dn[dn[:, 1] == 2], np.array([[1, 2], [2, 2]]))            assert np.array_equal(              dn.filter([(1, 1, Operator.EQUAL), (1, 2, Operator.EQUAL)], JoinOperator.OR),              np.array([[1, 1], [1, 2], [2, 1], [2, 2]]),          )          assert np.array_equal(dn[(dn[:, 1] == 1) | (dn[:, 1] == 2)], np.array([[1, 1], [1, 2], [2, 1], [2, 2]]))        def test_raise_error_invalid_exposed_type(self):          path = os.path.join(pathlib.Path(__file__).parent.resolve(), \"data_sample/example.csv\")          with pytest.raises(InvalidExposedType):              CSVDataNode(\"foo\", Scope.SCENARIO, properties={\"path\": path, \"exposed_type\": \"foo\"})        def test_get_system_modified_date_instead_of_last_edit_date(self, tmpdir_factory):          temp_file_path = str(tmpdir_factory.mktemp(\"data\").join(\"temp.csv\"))          pd.DataFrame([]).to_csv(temp_file_path)          dn = CSVDataNode(\"foo\", Scope.SCENARIO, properties={\"path\": temp_file_path, \"exposed_type\": \"pandas\"})            dn.write(pd.DataFrame([1, 2, 3]))          previous_edit_date = dn.last_edit_date            sleep(0.1)            pd.DataFrame([4, 5, 6]).to_csv(temp_file_path)          new_edit_date = datetime.fromtimestamp(os.path.getmtime(temp_file_path))            assert previous_edit_date < dn.last_edit_date          assert new_edit_date == dn.last_edit_date            sleep(0.1)            dn.write(pd.DataFrame([7, 8, 9]))          assert new_edit_date < dn.last_edit_date          os.unlink(temp_file_path) "}
{"text": "import os  import pathlib  from datetime import datetime  from time import sleep    import modin.pandas as modin_pd  import pandas as pd  import pytest    from src.taipy.core.data._data_manager import _DataManager  from src.taipy.core.data.pickle import PickleDataNode  from src.taipy.core.exceptions.exceptions import NoData  from taipy.config.common.scope import Scope  from taipy.config.config import Config  from taipy.config.exceptions.exceptions import InvalidConfigurationId      @pytest.fixture(scope=\"function\", autouse=True)  def cleanup():      yield      path = os.path.join(pathlib.Path(__file__).parent.resolve(), \"data_sample/temp.p\")      if os.path.isfile(path):          os.remove(path)      class TestPickleDataNodeEntity:      @pytest.fixture(scope=\"function\", autouse=True)      def remove_pickle_files(self):          yield          import glob            for f in glob.glob(\"*.p\"):              print(f\"deleting file {f}\")              os.remove(f)        def test_create(self):          dn = PickleDataNode(\"foobar_bazxyxea\", Scope.SCENARIO, properties={\"default_data\": \"Data\"})          assert os.path.isfile(Config.core.storage_folder + \"pickles/\" + dn.id + \".p\")          assert isinstance(dn, PickleDataNode)          assert dn.storage_type() == \"pickle\"          assert dn.config_id == \"foobar_bazxyxea\"          assert dn.scope == Scope.SCENARIO          assert dn.id is not None          assert dn.name is None          assert dn.owner_id is None          assert dn.last_edit_date is not None          assert dn.job_ids == []          assert dn.is_ready_for_reading          assert dn.read() == \"Data\"          assert dn.last_edit_date is not None          assert dn.job_ids == []            with pytest.raises(InvalidConfigurationId):              PickleDataNode(\"foobar bazxyxea\", Scope.SCENARIO, properties={\"default_data\": \"Data\"})        def test_get_user_properties(self, pickle_file_path):          dn_1 = PickleDataNode(\"dn_1\", Scope.SCENARIO, properties={\"path\": pickle_file_path})          assert dn_1._get_user_properties() == {}            dn_2 = PickleDataNode(              \"dn_2\",              Scope.SCENARIO,              properties={                  \"default_data\": \"foo\",                  \"default_path\": pickle_file_path,                  \"foo\": \"bar\",              },          )            # default_data, default_path, path, is_generated are filtered out          assert dn_2._get_user_properties() == {\"foo\": \"bar\"}        def test_new_pickle_data_node_with_existing_file_is_ready_for_reading(self):          not_ready_dn_cfg = Config.configure_data_node(\"not_ready_data_node_config_id\", \"pickle\", path=\"NOT_EXISTING.p\")          path = os.path.join(pathlib.Path(__file__).parent.resolve(), \"data_sample/example.p\")          ready_dn_cfg = Config.configure_data_node(\"ready_data_node_config_id\", \"pickle\", path=path)            dns = _DataManager._bulk_get_or_create([not_ready_dn_cfg, ready_dn_cfg])            assert not dns[not_ready_dn_cfg].is_ready_for_reading          assert dns[ready_dn_cfg].is_ready_for_reading        def test_create_with_file_name(self):          dn = PickleDataNode(\"foo\", Scope.SCENARIO, properties={\"default_data\": \"bar\", \"path\": \"foo.FILE.p\"})          assert os.path.isfile(\"foo.FILE.p\")          assert dn.read() == \"bar\"          dn.write(\"qux\")          assert dn.read() == \"qux\"          dn.write(1998)          assert dn.read() == 1998        def test_read_and_write(self):          no_data_dn = PickleDataNode(\"foo\", Scope.SCENARIO)          with pytest.raises(NoData):              assert no_data_dn.read() is None              no_data_dn.read_or_raise()          pickle_str = PickleDataNode(\"foo\", Scope.SCENARIO, properties={\"default_data\": \"bar\"})          assert isinstance(pickle_str.read(), str)          assert pickle_str.read() == \"bar\"          pickle_str.properties[\"default_data\"] = \"baz\"  # this modifies the default data value but not the data itself          assert pickle_str.read() == \"bar\"          pickle_str.write(\"qux\")          assert pickle_str.read() == \"qux\"          pickle_str.write(1998)          assert pickle_str.read() == 1998          assert isinstance(pickle_str.read(), int)          pickle_int = PickleDataNode(\"foo\", Scope.SCENARIO, properties={\"default_data\": 197})          assert isinstance(pickle_int.read(), int)          assert pickle_int.read() == 197          pickle_dict = PickleDataNode(              \"foo\", Scope.SCENARIO, properties={\"default_data\": {\"bar\": 12, \"baz\": \"qux\", \"quux\": [13]}}          )          assert isinstance(pickle_dict.read(), dict)          assert pickle_dict.read() == {\"bar\": 12, \"baz\": \"qux\", \"quux\": [13]}            default_pandas = pd.DataFrame({\"a\": [1, 2, 3], \"b\": [4, 5, 6]})          new_pandas_df = pd.DataFrame({\"c\": [7, 8, 9], \"d\": [10, 11, 12]})            default_modin = modin_pd.DataFrame({\"a\": [1, 2, 3], \"b\": [4, 5, 6]})          new_modin_df = modin_pd.DataFrame({\"c\": [7, 8, 9], \"d\": [10, 11, 12]})            pickle_pandas = PickleDataNode(\"foo\", Scope.SCENARIO, properties={\"default_data\": default_pandas})          assert isinstance(pickle_pandas.read(), pd.DataFrame)          assert default_pandas.equals(pickle_pandas.read())          pickle_pandas.write(new_pandas_df)          assert new_pandas_df.equals(pickle_pandas.read())          assert isinstance(pickle_pandas.read(), pd.DataFrame)          pickle_pandas.write(new_modin_df)          assert new_modin_df.equals(pickle_pandas.read())          assert isinstance(pickle_pandas.read(), modin_pd.DataFrame)          pickle_pandas.write(1998)          assert pickle_pandas.read() == 1998          assert isinstance(pickle_pandas.read(), int)            pickle_modin = PickleDataNode(\"foo\", Scope.SCENARIO, properties={\"default_data\": default_modin})          assert isinstance(pickle_modin.read(), modin_pd.DataFrame)          assert default_modin.equals(pickle_modin.read())          pickle_modin.write(new_modin_df)          assert new_modin_df.equals(pickle_modin.read())          assert isinstance(pickle_modin.read(), modin_pd.DataFrame)          pickle_modin.write(new_pandas_df)          assert new_pandas_df.equals(pickle_modin.read())          assert isinstance(pickle_modin.read(), pd.DataFrame)          pickle_modin.write(1998)          assert pickle_modin.read() == 1998          assert isinstance(pickle_modin.read(), int)        def test_path_overrides_default_path(self):          dn = PickleDataNode(              \"foo\",              Scope.SCENARIO,              properties={                  \"default_data\": \"bar\",                  \"default_path\": \"foo.FILE.p\",                  \"path\": \"bar.FILE.p\",              },          )          assert dn.path == \"bar.FILE.p\"        def test_set_path(self):          dn = PickleDataNode(\"foo\", Scope.SCENARIO, properties={\"default_path\": \"foo.p\"})          assert dn.path == \"foo.p\"          dn.path = \"bar.p\"          assert dn.path == \"bar.p\"        def test_is_generated(self):          dn = PickleDataNode(\"foo\", Scope.SCENARIO, properties={})          assert dn.is_generated          dn.path = \"bar.p\"          assert not dn.is_generated        def test_read_write_after_modify_path(self):          path = os.path.join(pathlib.Path(__file__).parent.resolve(), \"data_sample/example.p\")          new_path = os.path.join(pathlib.Path(__file__).parent.resolve(), \"data_sample/temp.p\")          dn = PickleDataNode(\"foo\", Scope.SCENARIO, properties={\"default_path\": path})          read_data = dn.read()          assert read_data is not None          dn.path = new_path          with pytest.raises(FileNotFoundError):              dn.read()          dn.write({\"other\": \"stuff\"})          assert dn.read() == {\"other\": \"stuff\"}        def test_get_system_modified_date_instead_of_last_edit_date(self, tmpdir_factory):          temp_file_path = str(tmpdir_factory.mktemp(\"data\").join(\"temp.pickle\"))          pd.DataFrame([]).to_pickle(temp_file_path)          dn = PickleDataNode(\"foo\", Scope.SCENARIO, properties={\"path\": temp_file_path, \"exposed_type\": \"pandas\"})            dn.write(pd.DataFrame([1, 2, 3]))          previous_edit_date = dn.last_edit_date            sleep(0.1)            pd.DataFrame([4, 5, 6]).to_pickle(temp_file_path)          new_edit_date = datetime.fromtimestamp(os.path.getmtime(temp_file_path))            assert previous_edit_date < dn.last_edit_date          assert new_edit_date == dn.last_edit_date            sleep(0.1)            dn.write(pd.DataFrame([7, 8, 9]))          assert new_edit_date < dn.last_edit_date          os.unlink(temp_file_path) "}
{"text": "import pytest    from src.taipy.core.data.data_node import DataNode  from src.taipy.core.data.data_node_id import DataNodeId  from src.taipy.core.data.generic import GenericDataNode  from src.taipy.core.exceptions.exceptions import MissingReadFunction, MissingRequiredProperty, MissingWriteFunction  from taipy.config.common.scope import Scope  from taipy.config.exceptions.exceptions import InvalidConfigurationId      def read_fct():      return TestGenericDataNode.data      def read_fct_with_args(inp):      return [i + inp for i in TestGenericDataNode.data]      def write_fct(data):      data.append(data[-1] + 1)      def write_fct_with_args(data, inp):      for _ in range(inp):          data.append(data[-1] + 1)      def read_fct_modify_data_node_name(data_node_id: DataNodeId, name: str):      import src.taipy.core as tp        data_node = tp.get(data_node_id)      assert isinstance(data_node, DataNode)      data_node.name = name  # type:ignore      return data_node      def reset_data():      TestGenericDataNode.data = [i for i in range(10)]      class TestGenericDataNode:      data = [i for i in range(10)]        def test_create(self):          dn = GenericDataNode(              \"foo_bar\", Scope.SCENARIO, properties={\"read_fct\": read_fct, \"write_fct\": write_fct, \"name\": \"super name\"}          )          assert isinstance(dn, GenericDataNode)          assert dn.storage_type() == \"generic\"          assert dn.config_id == \"foo_bar\"          assert dn.name == \"super name\"          assert dn.scope == Scope.SCENARIO          assert dn.id is not None          assert dn.owner_id is None          assert dn.last_edit_date is not None          assert dn.job_ids == []          assert dn.is_ready_for_reading          assert dn.properties[\"read_fct\"] == read_fct          assert dn.properties[\"write_fct\"] == write_fct            dn_1 = GenericDataNode(              \"foo\", Scope.SCENARIO, properties={\"read_fct\": read_fct, \"write_fct\": None, \"name\": \"foo\"}          )          assert isinstance(dn, GenericDataNode)          assert dn_1.storage_type() == \"generic\"          assert dn_1.config_id == \"foo\"          assert dn_1.name == \"foo\"          assert dn_1.scope == Scope.SCENARIO          assert dn_1.id is not None          assert dn_1.owner_id is None          assert dn_1.last_edit_date is not None          assert dn_1.job_ids == []          assert dn_1.is_ready_for_reading          assert dn_1.properties[\"read_fct\"] == read_fct          assert dn_1.properties[\"write_fct\"] is None            dn_2 = GenericDataNode(              \"xyz\", Scope.SCENARIO, properties={\"read_fct\": None, \"write_fct\": write_fct, \"name\": \"xyz\"}          )          assert isinstance(dn, GenericDataNode)          assert dn_2.storage_type() == \"generic\"          assert dn_2.config_id == \"xyz\"          assert dn_2.name == \"xyz\"          assert dn_2.scope == Scope.SCENARIO          assert dn_2.id is not None          assert dn_2.owner_id is None          assert dn_2.last_edit_date is not None          assert dn_2.job_ids == []          assert dn_2.is_ready_for_reading          assert dn_2.properties[\"read_fct\"] is None          assert dn_2.properties[\"write_fct\"] == write_fct            dn_3 = GenericDataNode(\"xyz\", Scope.SCENARIO, properties={\"read_fct\": read_fct, \"name\": \"xyz\"})          assert isinstance(dn, GenericDataNode)          assert dn_3.storage_type() == \"generic\"          assert dn_3.config_id == \"xyz\"          assert dn_3.name == \"xyz\"          assert dn_3.scope == Scope.SCENARIO          assert dn_3.id is not None          assert dn_3.owner_id is None          assert dn_3.last_edit_date is not None          assert dn_3.job_ids == []          assert dn_3.is_ready_for_reading          assert dn_3.properties[\"read_fct\"] == read_fct          assert dn_3.properties[\"write_fct\"] is None            dn_4 = GenericDataNode(\"xyz\", Scope.SCENARIO, properties={\"write_fct\": write_fct, \"name\": \"xyz\"})          assert isinstance(dn, GenericDataNode)          assert dn_4.storage_type() == \"generic\"          assert dn_4.config_id == \"xyz\"          assert dn_4.name == \"xyz\"          assert dn_4.scope == Scope.SCENARIO          assert dn_4.id is not None          assert dn_4.owner_id is None          assert dn_4.last_edit_date is not None          assert dn_4.job_ids == []          assert dn_4.is_ready_for_reading          assert dn_4.properties[\"read_fct\"] is None          assert dn_4.properties[\"write_fct\"] == write_fct            with pytest.raises(InvalidConfigurationId):              GenericDataNode(\"foo bar\", Scope.SCENARIO, properties={\"read_fct\": read_fct, \"write_fct\": write_fct})        def test_get_user_properties(self):          dn_1 = GenericDataNode(              \"dn_1\",              Scope.SCENARIO,              properties={                  \"read_fct\": read_fct,                  \"write_fct\": write_fct,                  \"read_fct_args\": 1,                  \"write_fct_args\": 2,                  \"foo\": \"bar\",              },          )            # read_fct, read_fct_args, write_fct, write_fct_args are filtered out          assert dn_1._get_user_properties() == {\"foo\": \"bar\"}        def test_create_with_missing_parameters(self):          with pytest.raises(MissingRequiredProperty):              GenericDataNode(\"foo\", Scope.SCENARIO, DataNodeId(\"dn_id\"))          with pytest.raises(MissingRequiredProperty):              GenericDataNode(\"foo\", Scope.SCENARIO, DataNodeId(\"dn_id\"), properties={})        def test_read_write_generic_datanode(self):          generic_dn = GenericDataNode(\"foo\", Scope.SCENARIO, properties={\"read_fct\": read_fct, \"write_fct\": write_fct})            assert generic_dn.read() == self.data          assert len(generic_dn.read()) == 10            generic_dn.write(self.data)          assert generic_dn.read() == self.data          assert len(generic_dn.read()) == 11            generic_dn_1 = GenericDataNode(\"bar\", Scope.SCENARIO, properties={\"read_fct\": read_fct, \"write_fct\": None})            assert generic_dn_1.read() == self.data          assert len(generic_dn_1.read()) == 11            with pytest.raises(MissingWriteFunction):              generic_dn_1.write(self.data)            generic_dn_2 = GenericDataNode(\"xyz\", Scope.SCENARIO, properties={\"read_fct\": None, \"write_fct\": write_fct})            generic_dn_2.write(self.data)          assert len(self.data) == 12            with pytest.raises(MissingReadFunction):              generic_dn_2.read()            generic_dn_3 = GenericDataNode(\"bar\", Scope.SCENARIO, properties={\"read_fct\": None, \"write_fct\": None})            with pytest.raises(MissingReadFunction):              generic_dn_3.read()          with pytest.raises(MissingWriteFunction):              generic_dn_3.write(self.data)            reset_data()        def test_read_write_generic_datanode_with_arguments(self):          generic_dn = GenericDataNode(              \"foo\",              Scope.SCENARIO,              properties={                  \"read_fct\": read_fct_with_args,                  \"write_fct\": write_fct_with_args,                  \"read_fct_args\": [1],                  \"write_fct_args\": [2],              },          )            assert all([a + 1 == b for a, b in zip(self.data, generic_dn.read())])          assert len(generic_dn.read()) == 10            generic_dn.write(self.data)          assert len(generic_dn.read()) == 12            reset_data()        def test_read_write_generic_datanode_with_non_list_arguments(self):          generic_dn = GenericDataNode(              \"foo\",              Scope.SCENARIO,              properties={                  \"read_fct\": read_fct_with_args,                  \"write_fct\": write_fct_with_args,                  \"read_fct_args\": 1,                  \"write_fct_args\": 2,              },          )            assert all([a + 1 == b for a, b in zip(self.data, generic_dn.read())])          assert len(generic_dn.read()) == 10            generic_dn.write(self.data)          assert len(generic_dn.read()) == 12            reset_data()        def test_save_data_node_when_read(self):          generic_dn = GenericDataNode(              \"foo\", Scope.SCENARIO, properties={\"read_fct\": read_fct_modify_data_node_name, \"write_fct\": write_fct}          )          generic_dn._properties[\"read_fct_args\"] = (generic_dn.id, \"bar\")          generic_dn.read()          assert generic_dn.name == \"bar\" "}
{"text": "  from dataclasses import dataclass  from datetime import datetime  from unittest.mock import patch    import mongomock  import pymongo  import pytest  from bson import ObjectId  from bson.errors import InvalidDocument    from src.taipy.core import MongoDefaultDocument  from src.taipy.core.common._mongo_connector import _connect_mongodb  from src.taipy.core.data.data_node_id import DataNodeId  from src.taipy.core.data.mongo import MongoCollectionDataNode  from src.taipy.core.data.operator import JoinOperator, Operator  from src.taipy.core.exceptions.exceptions import InvalidCustomDocument, MissingRequiredProperty  from taipy.config.common.scope import Scope      @pytest.fixture(scope=\"function\", autouse=True)  def clear_mongo_connection_cache():      _connect_mongodb.cache_clear()      @dataclass  class CustomObjectWithoutArgs:      def __init__(self, foo=None, bar=None):          self.foo = foo          self.bar = bar      class CustomObjectWithCustomEncoder:      def __init__(self, _id=None, integer=None, text=None, time=None):          self.id = _id          self.integer = integer          self.text = text          self.time = time        def encode(self):          return {\"_id\": self.id, \"integer\": self.integer, \"text\": self.text, \"time\": self.time.isoformat()}      class CustomObjectWithCustomEncoderDecoder(CustomObjectWithCustomEncoder):      @classmethod      def decode(cls, data):          return cls(data[\"_id\"], data[\"integer\"], data[\"text\"], datetime.fromisoformat(data[\"time\"]))      class TestMongoCollectionDataNode:      __properties = [          {              \"db_username\": \"\",              \"db_password\": \"\",              \"db_name\": \"taipy\",              \"collection_name\": \"foo\",              \"custom_document\": MongoDefaultDocument,              \"db_extra_args\": {                  \"ssl\": \"true\",                  \"retrywrites\": \"false\",                  \"maxIdleTimeMS\": \"120000\",              },          }      ]        @pytest.mark.parametrize(\"properties\", __properties)      def test_create(self, properties):          mongo_dn = MongoCollectionDataNode(              \"foo_bar\",              Scope.SCENARIO,              properties=properties,          )          assert isinstance(mongo_dn, MongoCollectionDataNode)          assert mongo_dn.storage_type() == \"mongo_collection\"          assert mongo_dn.config_id == \"foo_bar\"          assert mongo_dn.scope == Scope.SCENARIO          assert mongo_dn.id is not None          assert mongo_dn.owner_id is None          assert mongo_dn.job_ids == []          assert mongo_dn.is_ready_for_reading          assert mongo_dn.custom_document == MongoDefaultDocument        @pytest.mark.parametrize(\"properties\", __properties)      def test_get_user_properties(self, properties):          custom_properties = properties.copy()          custom_properties[\"foo\"] = \"bar\"          mongo_dn = MongoCollectionDataNode(              \"foo_bar\",              Scope.SCENARIO,              properties=custom_properties,          )          assert mongo_dn._get_user_properties() == {\"foo\": \"bar\"}        @pytest.mark.parametrize(          \"properties\",          [              {},              {\"db_username\": \"foo\"},              {\"db_username\": \"foo\", \"db_password\": \"foo\"},              {\"db_username\": \"foo\", \"db_password\": \"foo\", \"db_name\": \"foo\"},          ],      )      def test_create_with_missing_parameters(self, properties):          with pytest.raises(MissingRequiredProperty):              MongoCollectionDataNode(\"foo\", Scope.SCENARIO, DataNodeId(\"dn_id\"))          with pytest.raises(MissingRequiredProperty):              MongoCollectionDataNode(\"foo\", Scope.SCENARIO, DataNodeId(\"dn_id\"), properties=properties)        @pytest.mark.parametrize(\"properties\", __properties)      def test_raise_error_invalid_custom_document(self, properties):          custom_properties = properties.copy()          custom_properties[\"custom_document\"] = \"foo\"          with pytest.raises(InvalidCustomDocument):              MongoCollectionDataNode(                  \"foo\",                  Scope.SCENARIO,                  properties=custom_properties,              )        @mongomock.patch(servers=((\"localhost\", 27017),))      @pytest.mark.parametrize(\"properties\", __properties)      def test_read(self, properties):          mock_client = pymongo.MongoClient(\"localhost\")          mock_client[properties[\"db_name\"]][properties[\"collection_name\"]].insert_many(              [                  {\"foo\": \"baz\", \"bar\": \"qux\"},                  {\"foo\": \"quux\", \"bar\": \"quuz\"},                  {\"foo\": \"corge\"},                  {\"bar\": \"grault\"},                  {\"KWARGS_KEY\": \"KWARGS_VALUE\"},                  {},              ]          )            mongo_dn = MongoCollectionDataNode(              \"foo\",              Scope.SCENARIO,              properties=properties,          )            data = mongo_dn.read()            assert isinstance(data, list)          assert isinstance(data[0], MongoDefaultDocument)          assert isinstance(data[1], MongoDefaultDocument)          assert isinstance(data[2], MongoDefaultDocument)          assert isinstance(data[3], MongoDefaultDocument)          assert isinstance(data[4], MongoDefaultDocument)          assert isinstance(data[5], MongoDefaultDocument)            assert isinstance(data[0]._id, ObjectId)          assert data[0].foo == \"baz\"          assert data[0].bar == \"qux\"          assert isinstance(data[1]._id, ObjectId)          assert data[1].foo == \"quux\"          assert data[1].bar == \"quuz\"          assert isinstance(data[2]._id, ObjectId)          assert data[2].foo == \"corge\"          assert isinstance(data[3]._id, ObjectId)          assert data[3].bar == \"grault\"          assert isinstance(data[4]._id, ObjectId)          assert data[4].KWARGS_KEY == \"KWARGS_VALUE\"          assert isinstance(data[5]._id, ObjectId)        @mongomock.patch(servers=((\"localhost\", 27017),))      @pytest.mark.parametrize(\"properties\", __properties)      def test_read_empty_as(self, properties):          mongo_dn = MongoCollectionDataNode(              \"foo\",              Scope.SCENARIO,              properties=properties,          )          data = mongo_dn.read()          assert isinstance(data, list)          assert len(data) == 0        @mongomock.patch(servers=((\"localhost\", 27017),))      @pytest.mark.parametrize(\"properties\", __properties)      @pytest.mark.parametrize(          \"data\",          [              ([{\"foo\": 1, \"a\": 2}, {\"foo\": 3, \"bar\": 4}]),              ({\"a\": 1, \"bar\": 2}),          ],      )      def test_read_wrong_object_properties_name(self, properties, data):          custom_properties = properties.copy()          custom_properties[\"custom_document\"] = CustomObjectWithoutArgs          mongo_dn = MongoCollectionDataNode(              \"foo\",              Scope.SCENARIO,              properties=custom_properties,          )          mongo_dn.write(data)            with pytest.raises(TypeError):              data = mongo_dn.read()        @mongomock.patch(servers=((\"localhost\", 27017),))      @pytest.mark.parametrize(\"properties\", __properties)      @pytest.mark.parametrize(          \"data\",          [              ([{\"foo\": 11, \"bar\": 22}, {\"foo\": 33, \"bar\": 44}]),              ({\"foz\": 1, \"baz\": 2}),          ],      )      def test_append(self, properties, data):          mongo_dn = MongoCollectionDataNode(\"foo\", Scope.SCENARIO, properties=properties)          mongo_dn.append(data)            original_data = [{\"foo\": 1, \"bar\": 2}, {\"foo\": 3, \"bar\": 4}]          mongo_dn.write(original_data)            mongo_dn.append(data)          assert len(mongo_dn.read()) == len(data if isinstance(data, list) else [data]) + len(original_data)        @mongomock.patch(servers=((\"localhost\", 27017),))      @pytest.mark.parametrize(\"properties\", __properties)      @pytest.mark.parametrize(          \"data,written_data\",          [              ([{\"foo\": 1, \"bar\": 2}, {\"foo\": 3, \"bar\": 4}], [{\"foo\": 1, \"bar\": 2}, {\"foo\": 3, \"bar\": 4}]),              ({\"foo\": 1, \"bar\": 2}, [{\"foo\": 1, \"bar\": 2}]),          ],      )      def test_write(self, properties, data, written_data):          mongo_dn = MongoCollectionDataNode(\"foo\", Scope.SCENARIO, properties=properties)          mongo_dn.write(data)            read_objects = mongo_dn.read()            for read_object, written_dict in zip(read_objects, written_data):              assert isinstance(read_object._id, ObjectId)              assert read_object.foo == written_dict[\"foo\"]              assert read_object.bar == written_dict[\"bar\"]        @mongomock.patch(servers=((\"localhost\", 27017),))      @pytest.mark.parametrize(\"properties\", __properties)      @pytest.mark.parametrize(          \"data\",          [              [],          ],      )      def test_write_empty_list(self, properties, data):          mongo_dn = MongoCollectionDataNode(              \"foo\",              Scope.SCENARIO,              properties=properties,          )          mongo_dn.write(data)            assert len(mongo_dn.read()) == 0        @mongomock.patch(servers=((\"localhost\", 27017),))      @pytest.mark.parametrize(\"properties\", __properties)      def test_write_non_serializable(self, properties):          mongo_dn = MongoCollectionDataNode(\"foo\", Scope.SCENARIO, properties=properties)          data = {\"a\": 1, \"b\": mongo_dn}          with pytest.raises(InvalidDocument):              mongo_dn.write(data)        @mongomock.patch(servers=((\"localhost\", 27017),))      @pytest.mark.parametrize(\"properties\", __properties)      def test_write_custom_encoder(self, properties):          custom_properties = properties.copy()          custom_properties[\"custom_document\"] = CustomObjectWithCustomEncoder          mongo_dn = MongoCollectionDataNode(\"foo\", Scope.SCENARIO, properties=custom_properties)          data = [              CustomObjectWithCustomEncoder(\"1\", 1, \"abc\", datetime.now()),              CustomObjectWithCustomEncoder(\"2\", 2, \"def\", datetime.now()),          ]          mongo_dn.write(data)            read_data = mongo_dn.read()            assert isinstance(read_data[0], CustomObjectWithCustomEncoder)          assert isinstance(read_data[1], CustomObjectWithCustomEncoder)          assert read_data[0].id == \"1\"          assert read_data[0].integer == 1          assert read_data[0].text == \"abc\"          assert isinstance(read_data[0].time, str)          assert read_data[1].id == \"2\"          assert read_data[1].integer == 2          assert read_data[1].text == \"def\"          assert isinstance(read_data[1].time, str)        @mongomock.patch(servers=((\"localhost\", 27017),))      @pytest.mark.parametrize(\"properties\", __properties)      def test_write_custom_encoder_decoder(self, properties):          custom_properties = properties.copy()          custom_properties[\"custom_document\"] = CustomObjectWithCustomEncoderDecoder          mongo_dn = MongoCollectionDataNode(\"foo\", Scope.SCENARIO, properties=custom_properties)          data = [              CustomObjectWithCustomEncoderDecoder(\"1\", 1, \"abc\", datetime.now()),              CustomObjectWithCustomEncoderDecoder(\"2\", 2, \"def\", datetime.now()),          ]          mongo_dn.write(data)            read_data = mongo_dn.read()            assert isinstance(read_data[0], CustomObjectWithCustomEncoderDecoder)          assert isinstance(read_data[1], CustomObjectWithCustomEncoderDecoder)          assert read_data[0].id == \"1\"          assert read_data[0].integer == 1          assert read_data[0].text == \"abc\"          assert isinstance(read_data[0].time, datetime)          assert read_data[1].id == \"2\"          assert read_data[1].integer == 2          assert read_data[1].text == \"def\"          assert isinstance(read_data[1].time, datetime)        @mongomock.patch(servers=((\"localhost\", 27017),))      @pytest.mark.parametrize(\"properties\", __properties)      def test_filter(self, properties):          mock_client = pymongo.MongoClient(\"localhost\")          mock_client[properties[\"db_name\"]][properties[\"collection_name\"]].insert_many(              [                  {\"foo\": 1, \"bar\": 1},                  {\"foo\": 1, \"bar\": 2},                  {\"foo\": 1},                  {\"foo\": 2, \"bar\": 2},                  {\"bar\": 2},                  {\"KWARGS_KEY\": \"KWARGS_VALUE\"},              ]          )            mongo_dn = MongoCollectionDataNode(              \"foo\",              Scope.SCENARIO,              properties=properties,          )            assert len(mongo_dn.filter((\"foo\", 1, Operator.EQUAL))) == 3          assert len(mongo_dn.filter((\"foo\", 1, Operator.NOT_EQUAL))) == 3          assert len(mongo_dn.filter((\"bar\", 2, Operator.EQUAL))) == 3          assert len(mongo_dn.filter([(\"bar\", 1, Operator.EQUAL), (\"bar\", 2, Operator.EQUAL)], JoinOperator.OR)) == 4            assert mongo_dn[\"foo\"] == [1, 1, 1, 2, None, None]          assert mongo_dn[\"bar\"] == [1, 2, None, 2, 2, None]          assert [m.__dict__ for m in mongo_dn[:3]] == [m.__dict__ for m in mongo_dn.read()[:3]]          assert mongo_dn[[\"foo\", \"bar\"]] == [              {\"foo\": 1, \"bar\": 1},              {\"foo\": 1, \"bar\": 2},              {\"foo\": 1},              {\"foo\": 2, \"bar\": 2},              {\"bar\": 2},              {},          ]        @mongomock.patch(servers=((\"localhost\", 27017),))      @pytest.mark.parametrize(\"properties\", __properties)      def test_filter_does_not_read_all_entities(self, properties):          mongo_dn = MongoCollectionDataNode(\"foo\", Scope.SCENARIO, properties=properties)            # MongoCollectionDataNode.filter() should not call the MongoCollectionDataNode._read() method          with patch.object(MongoCollectionDataNode, \"_read\") as read_mock:              mongo_dn.filter((\"foo\", 1, Operator.EQUAL))              mongo_dn.filter((\"bar\", 2, Operator.NOT_EQUAL))              mongo_dn.filter([(\"bar\", 1, Operator.EQUAL), (\"bar\", 2, Operator.EQUAL)], JoinOperator.OR)                assert read_mock[\"_read\"].call_count == 0 "}
{"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": "import os  import pathlib  from datetime import datetime  from time import sleep  from typing import Dict    import modin.pandas as modin_pd  import numpy as np  import pandas as pd  import pytest  from modin.pandas.test.utils import df_equals  from pandas.testing import assert_frame_equal    from src.taipy.core.data._data_manager import _DataManager  from src.taipy.core.data.data_node_id import DataNodeId  from src.taipy.core.data.excel import ExcelDataNode  from src.taipy.core.data.operator import JoinOperator, Operator  from src.taipy.core.exceptions.exceptions import (      ExposedTypeLengthMismatch,      InvalidExposedType,      NoData,      NonExistingExcelSheet,      SheetNameLengthMismatch,  )  from taipy.config.common.scope import Scope  from taipy.config.config import Config      @pytest.fixture(scope=\"function\", autouse=True)  def cleanup():      yield      path = os.path.join(pathlib.Path(__file__).parent.resolve(), \"data_sample/temp.xlsx\")      if os.path.exists(path):          os.remove(path)      class MyCustomObject:      def __init__(self, id, integer, text):          self.id = id          self.integer = integer          self.text = text      class MyCustomObject1:      def __init__(self, id, integer, text):          self.id = id          self.integer = integer          self.text = text      class MyCustomObject2:      def __init__(self, id, integer, text):          self.id = id          self.integer = integer          self.text = text      class TestExcelDataNode:      def test_new_excel_data_node_with_existing_file_is_ready_for_reading(self):          not_ready_dn_cfg = Config.configure_data_node(\"not_ready_data_node_config_id\", \"excel\", path=\"NOT_EXISTING.csv\")          path = os.path.join(pathlib.Path(__file__).parent.resolve(), \"data_sample/example.xlsx\")          ready_dn_cfg = Config.configure_data_node(\"ready_data_node_config_id\", \"excel\", path=path)            dns = _DataManager._bulk_get_or_create([not_ready_dn_cfg, ready_dn_cfg])            assert not dns[not_ready_dn_cfg].is_ready_for_reading          assert dns[ready_dn_cfg].is_ready_for_reading        def test_create(self):          path = \"data/node/path\"          sheet_names = [\"sheet_name_1\", \"sheet_name_2\"]          dn = ExcelDataNode(              \"foo_bar\",              Scope.SCENARIO,              properties={\"path\": path, \"has_header\": False, \"sheet_name\": sheet_names, \"name\": \"super name\"},          )          assert isinstance(dn, ExcelDataNode)          assert dn.storage_type() == \"excel\"          assert dn.config_id == \"foo_bar\"          assert dn.name == \"super name\"          assert dn.scope == Scope.SCENARIO          assert dn.id is not None          assert dn.owner_id is None          assert dn.parent_ids == set()          assert dn.last_edit_date is None          assert dn.job_ids == []          assert not dn.is_ready_for_reading          assert dn.path == path          assert dn.has_header is False          assert dn.sheet_name == sheet_names        def test_get_user_properties(self, excel_file):          dn_1 = ExcelDataNode(\"dn_1\", Scope.SCENARIO, properties={\"path\": \"data/node/path\"})          assert dn_1._get_user_properties() == {}            dn_2 = ExcelDataNode(              \"dn_2\",              Scope.SCENARIO,              properties={                  \"exposed_type\": \"numpy\",                  \"default_data\": \"foo\",                  \"default_path\": excel_file,                  \"has_header\": False,                  \"sheet_name\": [\"sheet_name_1\", \"sheet_name_2\"],                  \"foo\": \"bar\",              },          )            # exposed_type, default_data, default_path, path, has_header are filtered out          assert dn_2._get_user_properties() == {\"foo\": \"bar\"}        def test_read_with_header(self):          with pytest.raises(NoData):              not_existing_excel = ExcelDataNode(\"foo\", Scope.SCENARIO, properties={\"path\": \"WRONG.xlsx\"})              assert not_existing_excel.read() is None              not_existing_excel.read_or_raise()            empty_excel_path = os.path.join(pathlib.Path(__file__).parent.resolve(), \"data_sample/empty.xlsx\")          empty_excel = ExcelDataNode(              \"foo\",              Scope.SCENARIO,              properties={\"path\": empty_excel_path, \"exposed_type\": MyCustomObject, \"has_header\": True},          )          assert len(empty_excel.read()) == 0            path = os.path.join(pathlib.Path(__file__).parent.resolve(), \"data_sample/example.xlsx\")            # Create ExcelDataNode without exposed_type (Default is pandas.DataFrame)          excel_data_node_as_pandas = ExcelDataNode(              \"bar\", Scope.SCENARIO, properties={\"path\": path, \"sheet_name\": \"Sheet1\"}          )            data_pandas = excel_data_node_as_pandas.read()          assert isinstance(data_pandas, pd.DataFrame)          assert len(data_pandas) == 5          assert np.array_equal(data_pandas.to_numpy(), pd.read_excel(path).to_numpy())            # Create ExcelDataNode with modin exposed_type          excel_data_node_as_modin = ExcelDataNode(              \"bar\", Scope.SCENARIO, properties={\"path\": path, \"sheet_name\": \"Sheet1\", \"exposed_type\": \"modin\"}          )            data_modin = excel_data_node_as_modin.read()          assert isinstance(data_modin, modin_pd.DataFrame)          assert len(data_modin) == 5          assert np.array_equal(data_modin.to_numpy(), pd.read_excel(path).to_numpy())            # Create ExcelDataNode with numpy exposed_type          excel_data_node_as_numpy = ExcelDataNode(              \"bar\", Scope.SCENARIO, properties={\"path\": path, \"exposed_type\": \"numpy\", \"sheet_name\": \"Sheet1\"}          )            data_numpy = excel_data_node_as_numpy.read()          assert isinstance(data_numpy, np.ndarray)          assert len(data_numpy) == 5          assert np.array_equal(data_numpy, pd.read_excel(path).to_numpy())            # Create the same ExcelDataNode but with custom exposed_type          non_existing_sheet_name_custom = ExcelDataNode(              \"bar\",              Scope.SCENARIO,              properties={\"path\": path, \"sheet_name\": \"abc\", \"exposed_type\": MyCustomObject},          )          with pytest.raises(NonExistingExcelSheet):              non_existing_sheet_name_custom.read()            excel_data_node_as_custom_object = ExcelDataNode(              \"bar\",              Scope.SCENARIO,              properties={\"path\": path, \"exposed_type\": MyCustomObject, \"sheet_name\": \"Sheet1\"},          )            data_custom = excel_data_node_as_custom_object.read()          assert isinstance(data_custom, list)          assert len(data_custom) == 5            for (_, row_pandas), row_custom in zip(data_pandas.iterrows(), data_custom):              assert isinstance(row_custom, MyCustomObject)              assert row_pandas[\"id\"] == row_custom.id              assert row_pandas[\"integer\"] == row_custom.integer              assert row_pandas[\"text\"] == row_custom.text        def test_read_without_header(self):          not_existing_excel = ExcelDataNode(              \"foo\", Scope.SCENARIO, properties={\"path\": \"WRONG.xlsx\", \"has_header\": False}          )          with pytest.raises(NoData):              assert not_existing_excel.read() is None              not_existing_excel.read_or_raise()            path = os.path.join(pathlib.Path(__file__).parent.resolve(), \"data_sample/example.xlsx\")            # Create ExcelDataNode without exposed_type (Default is pandas.DataFrame)          excel_data_node_as_pandas = ExcelDataNode(              \"bar\", Scope.SCENARIO, properties={\"path\": path, \"has_header\": False, \"sheet_name\": \"Sheet1\"}          )          data_pandas = excel_data_node_as_pandas.read()          assert isinstance(data_pandas, pd.DataFrame)          assert len(data_pandas) == 6          assert np.array_equal(data_pandas.to_numpy(), pd.read_excel(path, header=None).to_numpy())            # Create ExcelDataNode with modin exposed_type          excel_data_node_as_modin = ExcelDataNode(              \"bar\",              Scope.SCENARIO,              properties={\"path\": path, \"has_header\": False, \"sheet_name\": \"Sheet1\", \"exposed_type\": \"modin\"},          )          data_modin = excel_data_node_as_modin.read()          assert isinstance(data_modin, modin_pd.DataFrame)          assert len(data_modin) == 6          assert np.array_equal(data_modin.to_numpy(), pd.read_excel(path, header=None).to_numpy())            # Create ExcelDataNode with numpy exposed_type          excel_data_node_as_numpy = ExcelDataNode(              \"bar\",              Scope.SCENARIO,              properties={\"path\": path, \"has_header\": False, \"exposed_type\": \"numpy\", \"sheet_name\": \"Sheet1\"},          )            data_numpy = excel_data_node_as_numpy.read()          assert isinstance(data_numpy, np.ndarray)          assert len(data_numpy) == 6          assert np.array_equal(data_numpy, pd.read_excel(path, header=None).to_numpy())            # Create the same ExcelDataNode but with custom exposed_type          non_existing_sheet_name_custom = ExcelDataNode(              \"bar\",              Scope.SCENARIO,              properties={\"path\": path, \"has_header\": False, \"sheet_name\": \"abc\", \"exposed_type\": MyCustomObject},          )          with pytest.raises(NonExistingExcelSheet):              non_existing_sheet_name_custom.read()            excel_data_node_as_custom_object = ExcelDataNode(              \"bar\",              Scope.SCENARIO,              properties={                  \"path\": path,                  \"has_header\": False,                  \"exposed_type\": MyCustomObject,                  \"sheet_name\": \"Sheet1\",              },          )            data_custom = excel_data_node_as_custom_object.read()          assert isinstance(data_custom, list)          assert len(data_custom) == 6            for (_, row_pandas), row_custom in zip(data_pandas.iterrows(), data_custom):              assert isinstance(row_custom, MyCustomObject)              assert row_pandas[0] == row_custom.id              assert row_pandas[1] == row_custom.integer              assert row_pandas[2] == row_custom.text        @pytest.mark.parametrize(          \"content,columns\",          [              ([{\"a\": 11, \"b\": 22, \"c\": 33}, {\"a\": 44, \"b\": 55, \"c\": 66}], None),              ([[11, 22, 33], [44, 55, 66]], None),              ([[11, 22, 33], [44, 55, 66]], [\"e\", \"f\", \"g\"]),          ],      )      def test_write(self, excel_file, default_data_frame, content, columns):          excel_dn = ExcelDataNode(\"foo\", Scope.SCENARIO, properties={\"path\": excel_file, \"sheet_name\": \"Sheet1\"})          assert np.array_equal(excel_dn.read().values, default_data_frame.values)          if not columns:              excel_dn.write(content)              df = pd.DataFrame(content)          else:              excel_dn.write_with_column_names(content, columns)              df = pd.DataFrame(content, columns=columns)            assert np.array_equal(excel_dn.read().values, df.values)            excel_dn.write(None)          assert len(excel_dn.read()) == 0        @pytest.mark.parametrize(          \"content,sheet_name\",          [              ([{\"a\": 11, \"b\": 22, \"c\": 33}, {\"a\": 44, \"b\": 55, \"c\": 66}], \"sheet_name\"),              ([[11, 22, 33], [44, 55, 66]], [\"sheet_name\"]),          ],      )      def test_write_with_sheet_name(self, excel_file_with_sheet_name, default_data_frame, content, sheet_name):          excel_dn = ExcelDataNode(              \"foo\", Scope.SCENARIO, properties={\"path\": excel_file_with_sheet_name, \"sheet_name\": sheet_name}          )          df = pd.DataFrame(content)            if isinstance(sheet_name, str):              assert np.array_equal(excel_dn.read().values, default_data_frame.values)          else:              assert np.array_equal(excel_dn.read()[\"sheet_name\"].values, default_data_frame.values)            excel_dn.write(content)          if isinstance(sheet_name, str):              assert np.array_equal(excel_dn.read().values, df.values)          else:              assert np.array_equal(excel_dn.read()[\"sheet_name\"].values, df.values)            sheet_names = pd.ExcelFile(excel_file_with_sheet_name).sheet_names          expected_sheet_name = sheet_name[0] if isinstance(sheet_name, list) else sheet_name            assert sheet_names[0] == expected_sheet_name            excel_dn.write(None)          if isinstance(sheet_name, str):              assert len(excel_dn.read()) == 0          else:              assert len(excel_dn.read()) == 1        @pytest.mark.parametrize(          \"content,sheet_name\",          [              ([[11, 22, 33], [44, 55, 66]], [\"sheet_name_1\", \"sheet_name_2\"]),          ],      )      def test_raise_write_with_sheet_name_length_mismatch(          self, excel_file_with_sheet_name, default_data_frame, content, sheet_name      ):          excel_dn = ExcelDataNode(              \"foo\", Scope.SCENARIO, properties={\"path\": excel_file_with_sheet_name, \"sheet_name\": sheet_name}          )          with pytest.raises(SheetNameLengthMismatch):              excel_dn.write(content)        @pytest.mark.parametrize(          \"content\",          [              ([{\"a\": 11, \"b\": 22, \"c\": 33}, {\"a\": 44, \"b\": 55, \"c\": 66}]),          ],      )      def test_write_without_sheet_name(self, excel_file_with_sheet_name, default_data_frame, content):          excel_dn = ExcelDataNode(\"foo\", Scope.SCENARIO, properties={\"path\": excel_file_with_sheet_name})          default_data_frame = {\"sheet_name\": default_data_frame}          df = {\"Sheet1\": pd.DataFrame(content)}            assert np.array_equal(excel_dn.read()[\"sheet_name\"].values, default_data_frame[\"sheet_name\"].values)            excel_dn.write(content)          assert np.array_equal(excel_dn.read()[\"Sheet1\"].values, df[\"Sheet1\"].values)            sheet_names = pd.ExcelFile(excel_file_with_sheet_name).sheet_names          expected_sheet_name = \"Sheet1\"            assert sheet_names[0] == expected_sheet_name            excel_dn.write(None)          assert len(excel_dn.read()) == 1        @pytest.mark.parametrize(          \"content,columns,sheet_name\",          [              ([[11, 22, 33], [44, 55, 66]], [\"e\", \"f\", \"g\"], \"sheet_name\"),              ([[11, 22, 33], [44, 55, 66]], [\"e\", \"f\", \"g\"], [\"sheet_name\"]),          ],      )      def test_write_with_column_and_sheet_name(          self, excel_file_with_sheet_name, default_data_frame, content, columns, sheet_name      ):          excel_dn = ExcelDataNode(              \"foo\", Scope.SCENARIO, properties={\"path\": excel_file_with_sheet_name, \"sheet_name\": sheet_name}          )          df = pd.DataFrame(content)            if isinstance(sheet_name, str):              assert np.array_equal(excel_dn.read().values, default_data_frame.values)          else:              assert np.array_equal(excel_dn.read()[\"sheet_name\"].values, default_data_frame.values)            excel_dn.write_with_column_names(content, columns)            if isinstance(sheet_name, str):              assert np.array_equal(excel_dn.read().values, df.values)          else:              assert np.array_equal(excel_dn.read()[\"sheet_name\"].values, df.values)            sheet_names = pd.ExcelFile(excel_file_with_sheet_name).sheet_names          expected_sheet_name = sheet_name[0] if isinstance(sheet_name, list) else sheet_name            assert sheet_names[0] == expected_sheet_name            excel_dn.write(None)          if isinstance(sheet_name, str):              assert len(excel_dn.read()) == 0          else:              assert len(excel_dn.read()) == 1        @pytest.mark.parametrize(          \"content,columns\",          [              ([{\"a\": 11, \"b\": 22, \"c\": 33}, {\"a\": 44, \"b\": 55, \"c\": 66}], None),              ([[11, 22, 33], [44, 55, 66]], None),              ([[11, 22, 33], [44, 55, 66]], [\"e\", \"f\", \"g\"]),          ],      )      def test_write_modin(self, excel_file, default_data_frame, content, columns):          excel_dn = ExcelDataNode(              \"foo\", Scope.SCENARIO, properties={\"path\": excel_file, \"sheet_name\": \"Sheet1\", \"exposed_type\": \"modin\"}          )          assert np.array_equal(excel_dn.read().values, default_data_frame.values)          if not columns:              excel_dn.write(content)              df = modin_pd.DataFrame(content)          else:              excel_dn.write_with_column_names(content, columns)              df = modin_pd.DataFrame(content, columns=columns)            assert np.array_equal(excel_dn.read().values, df.values)            excel_dn.write(None)          assert len(excel_dn.read()) == 0        def test_read_multi_sheet_with_header(self):          not_existing_excel = ExcelDataNode(              \"foo\",              Scope.SCENARIO,              properties={\"path\": \"WRONG.xlsx\", \"sheet_name\": [\"sheet_name_1\", \"sheet_name_2\"]},          )          with pytest.raises(NoData):              assert not_existing_excel.read() is None              not_existing_excel.read_or_raise()            path = os.path.join(pathlib.Path(__file__).parent.resolve(), \"data_sample/example.xlsx\")          sheet_names = [\"Sheet1\", \"Sheet2\"]            # Create ExcelDataNode without exposed_type (Default is pandas.DataFrame)          excel_data_node_as_pandas = ExcelDataNode(              \"bar\", Scope.SCENARIO, properties={\"path\": path, \"sheet_name\": sheet_names}          )            data_pandas = excel_data_node_as_pandas.read()          assert isinstance(data_pandas, Dict)          assert len(data_pandas) == 2          assert all(              len(data_pandas[sheet_name] == 5) and isinstance(data_pandas[sheet_name], pd.DataFrame)              for sheet_name in sheet_names          )          assert list(data_pandas.keys()) == sheet_names          for sheet_name in sheet_names:              assert data_pandas[sheet_name].equals(pd.read_excel(path, sheet_name=sheet_name))            excel_data_node_as_pandas_no_sheet_name = ExcelDataNode(\"bar\", Scope.SCENARIO, properties={\"path\": path})            data_pandas_no_sheet_name = excel_data_node_as_pandas_no_sheet_name.read()          assert isinstance(data_pandas_no_sheet_name, Dict)          for key in data_pandas_no_sheet_name.keys():              assert isinstance(data_pandas_no_sheet_name[key], pd.DataFrame)              assert data_pandas[key].equals(data_pandas_no_sheet_name[key])            # Create ExcelDataNode with modin exposed_type          excel_data_node_as_modin = ExcelDataNode(              \"bar\", Scope.SCENARIO, properties={\"path\": path, \"sheet_name\": sheet_names, \"exposed_type\": \"modin\"}          )            data_modin = excel_data_node_as_modin.read()          assert isinstance(data_modin, Dict)          assert len(data_modin) == 2          assert all(              len(data_modin[sheet_name] == 5) and isinstance(data_modin[sheet_name], modin_pd.DataFrame)              for sheet_name in sheet_names          )          assert list(data_modin.keys()) == sheet_names          for sheet_name in sheet_names:              assert data_modin[sheet_name].equals(modin_pd.read_excel(path, sheet_name=sheet_name))            excel_data_node_as_pandas_no_sheet_name = ExcelDataNode(              \"bar\", Scope.SCENARIO, properties={\"path\": path, \"exposed_type\": \"modin\"}          )            data_modin_no_sheet_name = excel_data_node_as_pandas_no_sheet_name.read()          assert isinstance(data_modin_no_sheet_name, Dict)          for key in data_modin_no_sheet_name.keys():              assert isinstance(data_modin_no_sheet_name[key], modin_pd.DataFrame)              assert data_modin[key].equals(data_modin_no_sheet_name[key])            # Create ExcelDataNode with numpy exposed_type          excel_data_node_as_numpy = ExcelDataNode(              \"bar\",              Scope.SCENARIO,              properties={\"path\": path, \"sheet_name\": sheet_names, \"exposed_type\": \"numpy\"},          )            data_numpy = excel_data_node_as_numpy.read()          assert isinstance(data_numpy, Dict)          assert len(data_numpy) == 2          assert all(              len(data_numpy[sheet_name] == 5) and isinstance(data_numpy[sheet_name], np.ndarray)              for sheet_name in sheet_names          )          assert list(data_numpy.keys()) == sheet_names          for sheet_name in sheet_names:              assert np.array_equal(data_pandas[sheet_name], pd.read_excel(path, sheet_name=sheet_name).to_numpy())            excel_data_node_as_numpy_no_sheet_name = ExcelDataNode(              \"bar\",              Scope.SCENARIO,              properties={\"path\": path, \"exposed_type\": \"numpy\"},          )            data_numpy_no_sheet_name = excel_data_node_as_numpy_no_sheet_name.read()          assert isinstance(data_numpy_no_sheet_name, Dict)          for key in data_numpy_no_sheet_name.keys():              assert isinstance(data_numpy_no_sheet_name[key], np.ndarray)              assert np.array_equal(data_numpy[key], data_numpy_no_sheet_name[key])            # Create the same ExcelDataNode but with custom exposed_type          non_existing_sheet_name_custom = ExcelDataNode(              \"bar\",              Scope.SCENARIO,              properties={                  \"path\": path,                  \"sheet_name\": [\"Sheet1\", \"xyz\"],                  \"exposed_type\": MyCustomObject1,              },          )          with pytest.raises(NonExistingExcelSheet):              non_existing_sheet_name_custom.read()            excel_data_node_as_custom_object = ExcelDataNode(              \"bar\",              Scope.SCENARIO,              properties={\"path\": path, \"sheet_name\": sheet_names, \"exposed_type\": MyCustomObject1},          )            data_custom = excel_data_node_as_custom_object.read()          assert isinstance(data_custom, Dict)          assert len(data_custom) == 2          assert all(len(data_custom[sheet_name]) == 5 for sheet_name in sheet_names)          assert list(data_custom.keys()) == sheet_names            for sheet_name in sheet_names:              sheet_data_pandas, sheet_data_custom = data_pandas[sheet_name], data_custom[sheet_name]              for (_, row_pandas), row_custom in zip(sheet_data_pandas.iterrows(), sheet_data_custom):                  assert isinstance(row_custom, MyCustomObject1)                  assert row_pandas[\"id\"] == row_custom.id                  assert row_pandas[\"integer\"] == row_custom.integer                  assert row_pandas[\"text\"] == row_custom.text            excel_data_node_as_custom_object_no_sheet_name = ExcelDataNode(              \"bar\",              Scope.SCENARIO,              properties={\"path\": path, \"exposed_type\": MyCustomObject1},          )            data_custom_no_sheet_name = excel_data_node_as_custom_object_no_sheet_name.read()          assert isinstance(data_custom_no_sheet_name, Dict)          assert len(data_custom_no_sheet_name) == 2          assert data_custom.keys() == data_custom_no_sheet_name.keys()            for sheet_name in sheet_names:              sheet_data_custom_no_sheet_name, sheet_data_custom = (                  data_custom_no_sheet_name[sheet_name],                  data_custom[sheet_name],              )              for row_custom_no_sheet_name, row_custom in zip(sheet_data_custom_no_sheet_name, sheet_data_custom):                  assert isinstance(row_custom_no_sheet_name, MyCustomObject1)                  assert row_custom_no_sheet_name.id == row_custom.id                  assert row_custom_no_sheet_name.integer == row_custom.integer                  assert row_custom_no_sheet_name.text == row_custom.text            with pytest.raises(ExposedTypeLengthMismatch):              dn = ExcelDataNode(                  \"bar\",                  Scope.SCENARIO,                  properties={                      \"path\": path,                      \"sheet_name\": [\"Sheet1\"],                      \"exposed_type\": [MyCustomObject1, MyCustomObject2],                  },              )              dn.read()            custom_class_dict = {\"Sheet1\": MyCustomObject1, \"Sheet2\": MyCustomObject2}            excel_data_node_as_multi_custom_object = ExcelDataNode(              \"bar\",              Scope.SCENARIO,              properties={\"path\": path, \"sheet_name\": sheet_names, \"exposed_type\": custom_class_dict},          )          assert excel_data_node_as_multi_custom_object.properties[\"exposed_type\"] == custom_class_dict            excel_data_node_as_multi_custom_object = ExcelDataNode(              \"bar\",              Scope.SCENARIO,              properties={\"path\": path, \"sheet_name\": sheet_names, \"exposed_type\": [MyCustomObject1, MyCustomObject2]},          )          assert excel_data_node_as_multi_custom_object.properties[\"exposed_type\"] == [MyCustomObject1, MyCustomObject2]            multi_data_custom = excel_data_node_as_multi_custom_object.read()          assert isinstance(multi_data_custom, Dict)          assert len(multi_data_custom) == 2          assert all(len(multi_data_custom[sheet_name]) == 5 for sheet_name in sheet_names)          assert list(multi_data_custom.keys()) == sheet_names            for sheet_name, custom_class in custom_class_dict.items():              sheet_data_pandas, sheet_data_custom = data_pandas[sheet_name], multi_data_custom[sheet_name]              for (_, row_pandas), row_custom in zip(sheet_data_pandas.iterrows(), sheet_data_custom):                  assert isinstance(row_custom, custom_class)                  assert row_pandas[\"id\"] == row_custom.id                  assert row_pandas[\"integer\"] == row_custom.integer                  assert row_pandas[\"text\"] == row_custom.text            excel_data_node_as_multi_custom_object_no_sheet_name = ExcelDataNode(              \"bar\",              Scope.SCENARIO,              properties={\"path\": path, \"exposed_type\": custom_class_dict},          )          assert excel_data_node_as_multi_custom_object_no_sheet_name.properties[\"exposed_type\"] == custom_class_dict            multi_data_custom_no_sheet_name = excel_data_node_as_multi_custom_object_no_sheet_name.read()          assert isinstance(multi_data_custom_no_sheet_name, Dict)          assert len(multi_data_custom_no_sheet_name) == 2          assert multi_data_custom.keys() == multi_data_custom_no_sheet_name.keys()            for sheet_name, custom_class in custom_class_dict.items():              sheet_data_custom_no_sheet_name, sheet_data_custom = (                  multi_data_custom_no_sheet_name[sheet_name],                  multi_data_custom[sheet_name],              )              for row_custom_no_sheet_name, row_custom in zip(sheet_data_custom_no_sheet_name, sheet_data_custom):                  assert isinstance(row_custom_no_sheet_name, custom_class)                  assert row_custom_no_sheet_name.id == row_custom.id                  assert row_custom_no_sheet_name.integer == row_custom.integer                  assert row_custom_no_sheet_name.text == row_custom.text        def test_read_multi_sheet_without_header(self):          not_existing_excel = ExcelDataNode(              \"foo\",              Scope.SCENARIO,              properties={\"path\": \"WRONG.xlsx\", \"has_header\": False, \"sheet_name\": [\"sheet_name_1\", \"sheet_name_2\"]},          )          with pytest.raises(NoData):              assert not_existing_excel.read() is None              not_existing_excel.read_or_raise()            path = os.path.join(pathlib.Path(__file__).parent.resolve(), \"data_sample/example.xlsx\")          sheet_names = [\"Sheet1\", \"Sheet2\"]            # Create ExcelDataNode without exposed_type (Default is pandas.DataFrame)          excel_data_node_as_pandas = ExcelDataNode(              \"bar\", Scope.SCENARIO, properties={\"path\": path, \"has_header\": False, \"sheet_name\": sheet_names}          )          data_pandas = excel_data_node_as_pandas.read()          assert isinstance(data_pandas, Dict)          assert len(data_pandas) == 2          assert all(len(data_pandas[sheet_name]) == 6 for sheet_name in sheet_names)          assert list(data_pandas.keys()) == sheet_names          for sheet_name in sheet_names:              assert isinstance(data_pandas[sheet_name], pd.DataFrame)              assert data_pandas[sheet_name].equals(pd.read_excel(path, header=None, sheet_name=sheet_name))            excel_data_node_as_pandas_no_sheet_name = ExcelDataNode(              \"bar\", Scope.SCENARIO, properties={\"path\": path, \"has_header\": False}          )          data_pandas_no_sheet_name = excel_data_node_as_pandas_no_sheet_name.read()          assert isinstance(data_pandas_no_sheet_name, Dict)          for key in data_pandas_no_sheet_name.keys():              assert isinstance(data_pandas_no_sheet_name[key], pd.DataFrame)              assert data_pandas[key].equals(data_pandas_no_sheet_name[key])            # Create ExcelDataNode with modin exposed_type          excel_data_node_as_modin = ExcelDataNode(              \"bar\",              Scope.SCENARIO,              properties={\"path\": path, \"has_header\": False, \"sheet_name\": sheet_names, \"exposed_type\": \"modin\"},          )          data_modin = excel_data_node_as_modin.read()          assert isinstance(data_modin, Dict)          assert len(data_modin) == 2          assert all(len(data_modin[sheet_name]) == 6 for sheet_name in sheet_names)          assert list(data_modin.keys()) == sheet_names          for sheet_name in sheet_names:              assert isinstance(data_modin[sheet_name], modin_pd.DataFrame)              assert data_modin[sheet_name].equals(pd.read_excel(path, header=None, sheet_name=sheet_name))            excel_data_node_as_modin_no_sheet_name = ExcelDataNode(              \"bar\", Scope.SCENARIO, properties={\"path\": path, \"has_header\": False, \"exposed_type\": \"modin\"}          )          data_modin_no_sheet_name = excel_data_node_as_modin_no_sheet_name.read()          assert isinstance(data_modin_no_sheet_name, Dict)          for key in data_modin_no_sheet_name.keys():              assert isinstance(data_modin_no_sheet_name[key], modin_pd.DataFrame)              assert data_modin[key].equals(data_modin_no_sheet_name[key])            # Create ExcelDataNode with numpy exposed_type          excel_data_node_as_numpy = ExcelDataNode(              \"bar\",              Scope.SCENARIO,              properties={\"path\": path, \"has_header\": False, \"sheet_name\": sheet_names, \"exposed_type\": \"numpy\"},          )            data_numpy = excel_data_node_as_numpy.read()          assert isinstance(data_numpy, Dict)          assert len(data_numpy) == 2          assert all(              len(data_numpy[sheet_name] == 6) and isinstance(data_numpy[sheet_name], np.ndarray)              for sheet_name in sheet_names          )          assert list(data_numpy.keys()) == sheet_names          for sheet_name in sheet_names:              assert np.array_equal(                  data_pandas[sheet_name], pd.read_excel(path, header=None, sheet_name=sheet_name).to_numpy()              )            excel_data_node_as_numpy_no_sheet_name = ExcelDataNode(              \"bar\",              Scope.SCENARIO,              properties={\"path\": path, \"has_header\": False, \"exposed_type\": \"numpy\"},          )            data_numpy_no_sheet_name = excel_data_node_as_numpy_no_sheet_name.read()          assert isinstance(data_numpy_no_sheet_name, Dict)          for key in data_numpy_no_sheet_name.keys():              assert isinstance(data_numpy_no_sheet_name[key], np.ndarray)              assert np.array_equal(data_numpy[key], data_numpy_no_sheet_name[key])            # Create the same ExcelDataNode but with custom exposed_type          non_existing_sheet_name_custom = ExcelDataNode(              \"bar\",              Scope.SCENARIO,              properties={                  \"path\": path,                  \"has_header\": False,                  \"sheet_name\": [\"Sheet1\", \"xyz\"],                  \"exposed_type\": MyCustomObject1,              },          )          with pytest.raises(NonExistingExcelSheet):              non_existing_sheet_name_custom.read()            excel_data_node_as_custom_object = ExcelDataNode(              \"bar\",              Scope.SCENARIO,              properties={                  \"path\": path,                  \"has_header\": False,                  \"sheet_name\": sheet_names,                  \"exposed_type\": MyCustomObject1,              },          )            data_custom = excel_data_node_as_custom_object.read()          assert excel_data_node_as_custom_object.exposed_type == MyCustomObject1          assert isinstance(data_custom, Dict)          assert len(data_custom) == 2          assert all(len(data_custom[sheet_name]) == 6 for sheet_name in sheet_names)          assert list(data_custom.keys()) == sheet_names            for sheet_name in sheet_names:              sheet_data_pandas, sheet_data_custom = data_pandas[sheet_name], data_custom[sheet_name]              for (_, row_pandas), row_custom in zip(sheet_data_pandas.iterrows(), sheet_data_custom):                  assert isinstance(row_custom, MyCustomObject1)                  assert row_pandas[0] == row_custom.id                  assert row_pandas[1] == row_custom.integer                  assert row_pandas[2] == row_custom.text            excel_data_node_as_custom_object_no_sheet_name = ExcelDataNode(              \"bar\",              Scope.SCENARIO,              properties={\"path\": path, \"has_header\": False, \"exposed_type\": MyCustomObject1},          )            data_custom_no_sheet_name = excel_data_node_as_custom_object_no_sheet_name.read()          assert isinstance(data_custom_no_sheet_name, Dict)          assert len(data_custom_no_sheet_name) == 2          assert data_custom.keys() == data_custom_no_sheet_name.keys()            for sheet_name in sheet_names:              sheet_data_custom_no_sheet_name, sheet_data_custom = (                  data_custom_no_sheet_name[sheet_name],                  data_custom[sheet_name],              )              for row_custom_no_sheet_name, row_custom in zip(sheet_data_custom_no_sheet_name, sheet_data_custom):                  assert isinstance(row_custom_no_sheet_name, MyCustomObject1)                  assert row_custom_no_sheet_name.id == row_custom.id                  assert row_custom_no_sheet_name.integer == row_custom.integer                  assert row_custom_no_sheet_name.text == row_custom.text            with pytest.raises(ExposedTypeLengthMismatch):              dn = ExcelDataNode(                  \"bar\",                  Scope.SCENARIO,                  properties={                      \"path\": path,                      \"sheet_name\": [\"Sheet1\"],                      \"exposed_type\": [MyCustomObject1, MyCustomObject2],                      \"has_header\": False,                  },              )              dn.read()            custom_class_dict = {\"Sheet1\": MyCustomObject1, \"Sheet2\": MyCustomObject2}            excel_data_node_as_multi_custom_object = ExcelDataNode(              \"bar\",              Scope.SCENARIO,              properties={                  \"path\": path,                  \"sheet_name\": sheet_names,                  \"exposed_type\": custom_class_dict,                  \"has_header\": False,              },          )          assert excel_data_node_as_multi_custom_object.properties[\"exposed_type\"] == custom_class_dict            excel_data_node_as_multi_custom_object = ExcelDataNode(              \"bar\",              Scope.SCENARIO,              properties={                  \"path\": path,                  \"sheet_name\": sheet_names,                  \"exposed_type\": [MyCustomObject1, MyCustomObject2],                  \"has_header\": False,              },          )          assert excel_data_node_as_multi_custom_object.properties[\"exposed_type\"] == [MyCustomObject1, MyCustomObject2]            multi_data_custom = excel_data_node_as_multi_custom_object.read()          assert isinstance(multi_data_custom, Dict)          assert len(multi_data_custom) == 2          assert all(len(multi_data_custom[sheet_name]) == 6 for sheet_name in sheet_names)          assert list(multi_data_custom.keys()) == sheet_names            for sheet_name, custom_class in custom_class_dict.items():              sheet_data_pandas, sheet_data_custom = data_pandas[sheet_name], multi_data_custom[sheet_name]              for (_, row_pandas), row_custom in zip(sheet_data_pandas.iterrows(), sheet_data_custom):                  assert isinstance(row_custom, custom_class)                  assert row_pandas[0] == row_custom.id                  assert row_pandas[1] == row_custom.integer                  assert row_pandas[2] == row_custom.text            excel_data_node_as_multi_custom_object_no_sheet_name = ExcelDataNode(              \"bar\",              Scope.SCENARIO,              properties={\"path\": path, \"has_header\": False, \"exposed_type\": custom_class_dict},          )            multi_data_custom_no_sheet_name = excel_data_node_as_multi_custom_object_no_sheet_name.read()          assert isinstance(multi_data_custom_no_sheet_name, Dict)          assert len(multi_data_custom_no_sheet_name) == 2          assert multi_data_custom.keys() == multi_data_custom_no_sheet_name.keys()            for sheet_name, custom_class in custom_class_dict.items():              sheet_data_custom_no_sheet_name, sheet_data_custom = (                  multi_data_custom_no_sheet_name[sheet_name],                  multi_data_custom[sheet_name],              )              for row_custom_no_sheet_name, row_custom in zip(sheet_data_custom_no_sheet_name, sheet_data_custom):                  assert isinstance(row_custom_no_sheet_name, custom_class)                  assert row_custom_no_sheet_name.id == row_custom.id                  assert row_custom_no_sheet_name.integer == row_custom.integer                  assert row_custom_no_sheet_name.text == row_custom.text        @pytest.mark.parametrize(          \"content,columns\",          [              ([{\"a\": 11, \"b\": 22, \"c\": 33}, {\"a\": 44, \"b\": 55, \"c\": 66}], None),              ([[11, 22, 33], [44, 55, 66]], None),              ([[11, 22, 33], [44, 55, 66]], [\"e\", \"f\", \"g\"]),          ],      )      def test_write_multi_sheet(self, excel_file_with_multi_sheet, default_multi_sheet_data_frame, content, columns):          sheet_names = [\"Sheet1\", \"Sheet2\"]            excel_dn = ExcelDataNode(              \"foo\",              Scope.SCENARIO,              properties={\"path\": excel_file_with_multi_sheet, \"sheet_name\": sheet_names},          )            for sheet_name in sheet_names:              assert np.array_equal(excel_dn.read()[sheet_name].values, default_multi_sheet_data_frame[sheet_name].values)            multi_sheet_content = {sheet_name: pd.DataFrame(content) for sheet_name in sheet_names}            excel_dn.write(multi_sheet_content)            for sheet_name in sheet_names:              assert np.array_equal(excel_dn.read()[sheet_name].values, multi_sheet_content[sheet_name].values)        def test_write_multi_sheet_numpy(self, excel_file_with_multi_sheet):          sheet_names = [\"Sheet1\", \"Sheet2\"]            excel_dn = ExcelDataNode(              \"foo\",              Scope.SCENARIO,              properties={\"path\": excel_file_with_multi_sheet, \"sheet_name\": sheet_names, \"exposed_type\": \"numpy\"},          )            sheets_data = [[11, 22, 33], [44, 55, 66]]          data = {              sheet_name: pd.DataFrame(sheet_data).to_numpy() for sheet_name, sheet_data in zip(sheet_names, sheets_data)          }          excel_dn.write(data)          read_data = excel_dn.read()          assert all(np.array_equal(data[sheet_name], read_data[sheet_name]) for sheet_name in sheet_names)        @pytest.mark.parametrize(          \"content,columns\",          [              ([{\"a\": 11, \"b\": 22, \"c\": 33}, {\"a\": 44, \"b\": 55, \"c\": 66}], None),              ([[11, 22, 33], [44, 55, 66]], None),              ([[11, 22, 33], [44, 55, 66]], [\"e\", \"f\", \"g\"]),          ],      )      def test_write_multi_sheet_with_modin(          self, excel_file_with_multi_sheet, default_multi_sheet_data_frame, content, columns      ):          sheet_names = [\"Sheet1\", \"Sheet2\"]            excel_dn = ExcelDataNode(              \"foo\",              Scope.SCENARIO,              properties={\"path\": excel_file_with_multi_sheet, \"sheet_name\": sheet_names, \"exposed_type\": \"modin\"},          )            for sheet_name in sheet_names:              assert np.array_equal(excel_dn.read()[sheet_name].values, default_multi_sheet_data_frame[sheet_name].values)            multi_sheet_content = {sheet_name: modin_pd.DataFrame(content) for sheet_name in sheet_names}            excel_dn.write(multi_sheet_content)            for sheet_name in sheet_names:              assert np.array_equal(excel_dn.read()[sheet_name].values, multi_sheet_content[sheet_name].values)        @pytest.mark.parametrize(          \"content\",          [              ([{\"a\": 11, \"b\": 22, \"c\": 33}, {\"a\": 44, \"b\": 55, \"c\": 66}]),              (pd.DataFrame([{\"a\": 11, \"b\": 22, \"c\": 33}, {\"a\": 44, \"b\": 55, \"c\": 66}])),              ([[11, 22, 33], [44, 55, 66]]),          ],      )      def test_append_pandas_with_sheetname(self, excel_file, default_data_frame, content):          dn = ExcelDataNode(\"foo\", Scope.SCENARIO, properties={\"path\": excel_file, \"sheet_name\": \"Sheet1\"})          assert_frame_equal(dn.read(), default_data_frame)            dn.append(content)          assert_frame_equal(              dn.read(),              pd.concat([default_data_frame, pd.DataFrame(content, columns=[\"a\", \"b\", \"c\"])]).reset_index(drop=True),          )        @pytest.mark.parametrize(          \"content\",          [              ([{\"a\": 11, \"b\": 22, \"c\": 33}, {\"a\": 44, \"b\": 55, \"c\": 66}]),              (pd.DataFrame([{\"a\": 11, \"b\": 22, \"c\": 33}, {\"a\": 44, \"b\": 55, \"c\": 66}])),              ([[11, 22, 33], [44, 55, 66]]),          ],      )      def test_append_pandas_without_sheetname(self, excel_file, default_data_frame, content):          dn = ExcelDataNode(\"foo\", Scope.SCENARIO, properties={\"path\": excel_file})          assert_frame_equal(dn.read()[\"Sheet1\"], default_data_frame)            dn.append(content)          assert_frame_equal(              dn.read()[\"Sheet1\"],              pd.concat([default_data_frame, pd.DataFrame(content, columns=[\"a\", \"b\", \"c\"])]).reset_index(drop=True),          )        @pytest.mark.parametrize(          \"content\",          [              (                  {                      \"Sheet1\": pd.DataFrame([{\"a\": 11, \"b\": 22, \"c\": 33}]),                      \"Sheet2\": pd.DataFrame([{\"a\": 44, \"b\": 55, \"c\": 66}]),                  }              ),              (                  {                      \"Sheet1\": pd.DataFrame({\"a\": [11, 44], \"b\": [22, 55], \"c\": [33, 66]}),                      \"Sheet2\": pd.DataFrame([{\"a\": 77, \"b\": 88, \"c\": 99}]),                  }              ),              ({\"Sheet1\": np.array([[11, 22, 33], [44, 55, 66]]), \"Sheet2\": np.array([[77, 88, 99]])}),          ],      )      def test_append_pandas_multisheet(self, excel_file_with_multi_sheet, default_multi_sheet_data_frame, content):          dn = ExcelDataNode(              \"foo\", Scope.SCENARIO, properties={\"path\": excel_file_with_multi_sheet, \"sheet_name\": [\"Sheet1\", \"Sheet2\"]}          )          assert_frame_equal(dn.read()[\"Sheet1\"], default_multi_sheet_data_frame[\"Sheet1\"])          assert_frame_equal(dn.read()[\"Sheet2\"], default_multi_sheet_data_frame[\"Sheet2\"])            dn.append(content)            assert_frame_equal(              dn.read()[\"Sheet1\"],              pd.concat(                  [default_multi_sheet_data_frame[\"Sheet1\"], pd.DataFrame(content[\"Sheet1\"], columns=[\"a\", \"b\", \"c\"])]              ).reset_index(drop=True),          )          assert_frame_equal(              dn.read()[\"Sheet2\"],              pd.concat(                  [default_multi_sheet_data_frame[\"Sheet2\"], pd.DataFrame(content[\"Sheet2\"], columns=[\"a\", \"b\", \"c\"])]              ).reset_index(drop=True),          )        @pytest.mark.parametrize(          \"content\",          [              ({\"Sheet1\": pd.DataFrame([{\"a\": 11, \"b\": 22, \"c\": 33}])}),              (pd.DataFrame({\"a\": [11, 44], \"b\": [22, 55], \"c\": [33, 66]})),              ([[11, 22, 33], [44, 55, 66]]),          ],      )      def test_append_only_first_sheet_of_a_multisheet_file(          self, excel_file_with_multi_sheet, default_multi_sheet_data_frame, content      ):          dn = ExcelDataNode(              \"foo\", Scope.SCENARIO, properties={\"path\": excel_file_with_multi_sheet, \"sheet_name\": [\"Sheet1\", \"Sheet2\"]}          )          assert_frame_equal(dn.read()[\"Sheet1\"], default_multi_sheet_data_frame[\"Sheet1\"])          assert_frame_equal(dn.read()[\"Sheet2\"], default_multi_sheet_data_frame[\"Sheet2\"])            dn.append(content)            appended_content = content[\"Sheet1\"] if isinstance(content, dict) else content          assert_frame_equal(              dn.read()[\"Sheet1\"],              pd.concat(                  [default_multi_sheet_data_frame[\"Sheet1\"], pd.DataFrame(appended_content, columns=[\"a\", \"b\", \"c\"])]              ).reset_index(drop=True),          )          assert_frame_equal(dn.read()[\"Sheet2\"], default_multi_sheet_data_frame[\"Sheet2\"])        @pytest.mark.parametrize(          \"content\",          [              ([{\"a\": 11, \"b\": 22, \"c\": 33}, {\"a\": 44, \"b\": 55, \"c\": 66}]),              (modin_pd.DataFrame([{\"a\": 11, \"b\": 22, \"c\": 33}, {\"a\": 44, \"b\": 55, \"c\": 66}])),              ([[11, 22, 33], [44, 55, 66]]),          ],      )      def test_append_modin_with_sheetname(self, excel_file, default_data_frame, content):          dn = ExcelDataNode(              \"foo\", Scope.SCENARIO, properties={\"path\": excel_file, \"sheet_name\": \"Sheet1\", \"exposed_type\": \"modin\"}          )          df_equals(dn.read(), modin_pd.DataFrame(default_data_frame))            dn.append(content)          df_equals(              dn.read(),              modin_pd.concat(                  [modin_pd.DataFrame(default_data_frame), modin_pd.DataFrame(content, columns=[\"a\", \"b\", \"c\"])]              ).reset_index(drop=True),          )        @pytest.mark.parametrize(          \"content\",          [              ([{\"a\": 11, \"b\": 22, \"c\": 33}, {\"a\": 44, \"b\": 55, \"c\": 66}]),              (modin_pd.DataFrame([{\"a\": 11, \"b\": 22, \"c\": 33}, {\"a\": 44, \"b\": 55, \"c\": 66}])),              ([[11, 22, 33], [44, 55, 66]]),          ],      )      def test_append_modin_without_sheetname(self, excel_file, default_data_frame, content):          dn = ExcelDataNode(\"foo\", Scope.SCENARIO, properties={\"path\": excel_file, \"exposed_type\": \"modin\"})          df_equals(dn.read()[\"Sheet1\"], default_data_frame)            dn.append(content)          df_equals(              dn.read()[\"Sheet1\"],              modin_pd.concat([default_data_frame, modin_pd.DataFrame(content, columns=[\"a\", \"b\", \"c\"])]).reset_index(                  drop=True              ),          )        @pytest.mark.parametrize(          \"content\",          [              (                  {                      \"Sheet1\": modin_pd.DataFrame([{\"a\": 11, \"b\": 22, \"c\": 33}]),                      \"Sheet2\": modin_pd.DataFrame([{\"a\": 44, \"b\": 55, \"c\": 66}]),                  }              ),              (                  {                      \"Sheet1\": modin_pd.DataFrame({\"a\": [11, 44], \"b\": [22, 55], \"c\": [33, 66]}),                      \"Sheet2\": modin_pd.DataFrame([{\"a\": 77, \"b\": 88, \"c\": 99}]),                  }              ),              ({\"Sheet1\": np.array([[11, 22, 33], [44, 55, 66]]), \"Sheet2\": np.array([[77, 88, 99]])}),          ],      )      def test_append_modin_multisheet(self, excel_file_with_multi_sheet, default_multi_sheet_data_frame, content):          dn = ExcelDataNode(              \"foo\",              Scope.SCENARIO,              properties={                  \"path\": excel_file_with_multi_sheet,                  \"sheet_name\": [\"Sheet1\", \"Sheet2\"],                  \"exposed_type\": \"modin\",              },          )          df_equals(dn.read()[\"Sheet1\"], default_multi_sheet_data_frame[\"Sheet1\"])          df_equals(dn.read()[\"Sheet2\"], default_multi_sheet_data_frame[\"Sheet2\"])            dn.append(content)            df_equals(              dn.read()[\"Sheet1\"],              modin_pd.concat(                  [                      default_multi_sheet_data_frame[\"Sheet1\"],                      modin_pd.DataFrame(content[\"Sheet1\"], columns=[\"a\", \"b\", \"c\"]),                  ]              ).reset_index(drop=True),          )          df_equals(              dn.read()[\"Sheet2\"],              modin_pd.concat(                  [                      default_multi_sheet_data_frame[\"Sheet2\"],                      modin_pd.DataFrame(content[\"Sheet2\"], columns=[\"a\", \"b\", \"c\"]),                  ]              ).reset_index(drop=True),          )        def test_filter_pandas_exposed_type_with_sheetname(self, excel_file):          dn = ExcelDataNode(              \"foo\", Scope.SCENARIO, properties={\"path\": excel_file, \"sheet_name\": \"Sheet1\", \"exposed_type\": \"pandas\"}          )          dn.write(              [                  {\"foo\": 1, \"bar\": 1},                  {\"foo\": 1, \"bar\": 2},                  {\"foo\": 1},                  {\"foo\": 2, \"bar\": 2},                  {\"bar\": 2},              ]          )            # Test datanode indexing and slicing          assert dn[\"foo\"].equals(pd.Series([1, 1, 1, 2, None]))          assert dn[\"bar\"].equals(pd.Series([1, 2, None, 2, 2]))          assert dn[:2].equals(pd.DataFrame([{\"foo\": 1.0, \"bar\": 1.0}, {\"foo\": 1.0, \"bar\": 2.0}]))            # Test filter data          filtered_by_filter_method = dn.filter((\"foo\", 1, Operator.EQUAL))          filtered_by_indexing = dn[dn[\"foo\"] == 1]          expected_data = pd.DataFrame([{\"foo\": 1.0, \"bar\": 1.0}, {\"foo\": 1.0, \"bar\": 2.0}, {\"foo\": 1.0}])          assert_frame_equal(filtered_by_filter_method.reset_index(drop=True), expected_data)          assert_frame_equal(filtered_by_indexing.reset_index(drop=True), expected_data)            filtered_by_filter_method = dn.filter((\"foo\", 1, Operator.NOT_EQUAL))          filtered_by_indexing = dn[dn[\"foo\"] != 1]          expected_data = pd.DataFrame([{\"foo\": 2.0, \"bar\": 2.0}, {\"bar\": 2.0}])          assert_frame_equal(filtered_by_filter_method.reset_index(drop=True), expected_data)          assert_frame_equal(filtered_by_indexing.reset_index(drop=True), expected_data)            filtered_by_filter_method = dn.filter((\"bar\", 2, Operator.EQUAL))          filtered_by_indexing = dn[dn[\"bar\"] == 2]          expected_data = pd.DataFrame([{\"foo\": 1.0, \"bar\": 2.0}, {\"foo\": 2.0, \"bar\": 2.0}, {\"bar\": 2.0}])          assert_frame_equal(filtered_by_filter_method.reset_index(drop=True), expected_data)          assert_frame_equal(filtered_by_indexing.reset_index(drop=True), expected_data)            filtered_by_filter_method = dn.filter([(\"bar\", 1, Operator.EQUAL), (\"bar\", 2, Operator.EQUAL)], JoinOperator.OR)          filtered_by_indexing = dn[(dn[\"bar\"] == 1) | (dn[\"bar\"] == 2)]          expected_data = pd.DataFrame(              [                  {\"foo\": 1.0, \"bar\": 1.0},                  {\"foo\": 1.0, \"bar\": 2.0},                  {\"foo\": 2.0, \"bar\": 2.0},                  {\"bar\": 2.0},              ]          )          assert_frame_equal(filtered_by_filter_method.reset_index(drop=True), expected_data)          assert_frame_equal(filtered_by_indexing.reset_index(drop=True), expected_data)        def test_filter_pandas_exposed_type_without_sheetname(self, excel_file):          dn = ExcelDataNode(\"foo\", Scope.SCENARIO, properties={\"path\": excel_file, \"exposed_type\": \"pandas\"})          dn.write(              [                  {\"foo\": 1, \"bar\": 1},                  {\"foo\": 1, \"bar\": 2},                  {\"foo\": 1},                  {\"foo\": 2, \"bar\": 2},                  {\"bar\": 2},              ]          )            assert len(dn.filter((\"foo\", 1, Operator.EQUAL))[\"Sheet1\"]) == 3          assert len(dn.filter((\"foo\", 1, Operator.NOT_EQUAL))[\"Sheet1\"]) == 2          assert len(dn.filter((\"bar\", 2, Operator.EQUAL))[\"Sheet1\"]) == 3          assert len(dn.filter([(\"bar\", 1, Operator.EQUAL), (\"bar\", 2, Operator.EQUAL)], JoinOperator.OR)[\"Sheet1\"]) == 4            assert dn[\"Sheet1\"][\"foo\"].equals(pd.Series([1, 1, 1, 2, None]))          assert dn[\"Sheet1\"][\"bar\"].equals(pd.Series([1, 2, None, 2, 2]))          assert dn[\"Sheet1\"][:2].equals(pd.DataFrame([{\"foo\": 1.0, \"bar\": 1.0}, {\"foo\": 1.0, \"bar\": 2.0}]))        def test_filter_pandas_exposed_type_multisheet(self, excel_file):          dn = ExcelDataNode(              \"foo\",              Scope.SCENARIO,              properties={\"path\": excel_file, \"sheet_name\": [\"sheet_1\", \"sheet_2\"], \"exposed_type\": \"pandas\"},          )          dn.write(              {                  \"sheet_1\": pd.DataFrame(                      [                          {\"foo\": 1, \"bar\": 1},                          {\"foo\": 1, \"bar\": 2},                          {\"foo\": 1},                          {\"foo\": 2, \"bar\": 2},                          {\"bar\": 2},                      ]                  ),                  \"sheet_2\": pd.DataFrame(                      [                          {\"foo\": 1, \"bar\": 3},                          {\"foo\": 1, \"bar\": 4},                          {\"foo\": 1},                          {\"foo\": 2, \"bar\": 4},                          {\"bar\": 4},                      ]                  ),              }          )            assert len(dn.filter((\"foo\", 1, Operator.EQUAL))) == 2          assert len(dn.filter((\"foo\", 1, Operator.EQUAL))[\"sheet_1\"]) == 3          assert len(dn.filter((\"foo\", 1, Operator.EQUAL))[\"sheet_2\"]) == 3            assert len(dn.filter((\"foo\", 1, Operator.NOT_EQUAL))) == 2          assert len(dn.filter((\"foo\", 1, Operator.NOT_EQUAL))[\"sheet_1\"]) == 2          assert len(dn.filter((\"foo\", 1, Operator.NOT_EQUAL))[\"sheet_2\"]) == 2            assert len(dn.filter((\"bar\", 2, Operator.EQUAL))) == 2          assert len(dn.filter((\"bar\", 2, Operator.EQUAL))[\"sheet_1\"]) == 3          assert len(dn.filter((\"bar\", 2, Operator.EQUAL))[\"sheet_2\"]) == 0            assert len(dn.filter([(\"bar\", 1, Operator.EQUAL), (\"bar\", 2, Operator.EQUAL)], JoinOperator.OR)) == 2          assert len(dn.filter([(\"bar\", 1, Operator.EQUAL), (\"bar\", 2, Operator.EQUAL)], JoinOperator.OR)[\"sheet_1\"]) == 4          assert len(dn.filter([(\"bar\", 1, Operator.EQUAL), (\"bar\", 2, Operator.EQUAL)], JoinOperator.OR)[\"sheet_2\"]) == 0            assert dn[\"sheet_1\"][\"foo\"].equals(pd.Series([1, 1, 1, 2, None]))          assert dn[\"sheet_2\"][\"foo\"].equals(pd.Series([1, 1, 1, 2, None]))          assert dn[\"sheet_1\"][\"bar\"].equals(pd.Series([1, 2, None, 2, 2]))          assert dn[\"sheet_2\"][\"bar\"].equals(pd.Series([3, 4, None, 4, 4]))          assert dn[\"sheet_1\"][:2].equals(pd.DataFrame([{\"foo\": 1.0, \"bar\": 1.0}, {\"foo\": 1.0, \"bar\": 2.0}]))          assert dn[\"sheet_2\"][:2].equals(pd.DataFrame([{\"foo\": 1.0, \"bar\": 3.0}, {\"foo\": 1.0, \"bar\": 4.0}]))        def test_filter_modin_exposed_type_with_sheetname(self, excel_file):          dn = ExcelDataNode(              \"foo\", Scope.SCENARIO, properties={\"path\": excel_file, \"sheet_name\": \"Sheet1\", \"exposed_type\": \"modin\"}          )          dn.write(              [                  {\"foo\": 1, \"bar\": 1},                  {\"foo\": 1, \"bar\": 2},                  {\"foo\": 1},                  {\"foo\": 2, \"bar\": 2},                  {\"bar\": 2},              ]          )            # Test datanode indexing and slicing          assert dn[\"foo\"].equals(modin_pd.Series([1, 1, 1, 2, None]))          assert dn[\"bar\"].equals(modin_pd.Series([1, 2, None, 2, 2]))          assert dn[:2].equals(modin_pd.DataFrame([{\"foo\": 1.0, \"bar\": 1.0}, {\"foo\": 1.0, \"bar\": 2.0}]))            # Test filter data          filtered_by_filter_method = dn.filter((\"foo\", 1, Operator.EQUAL))          filtered_by_indexing = dn[dn[\"foo\"] == 1]          expected_data = modin_pd.DataFrame([{\"foo\": 1.0, \"bar\": 1.0}, {\"foo\": 1.0, \"bar\": 2.0}, {\"foo\": 1.0}])          df_equals(filtered_by_filter_method.reset_index(drop=True), expected_data)          df_equals(filtered_by_indexing.reset_index(drop=True), expected_data)            filtered_by_filter_method = dn.filter((\"foo\", 1, Operator.NOT_EQUAL))          filtered_by_indexing = dn[dn[\"foo\"] != 1]          expected_data = modin_pd.DataFrame([{\"foo\": 2.0, \"bar\": 2.0}, {\"bar\": 2.0}])          df_equals(filtered_by_filter_method.reset_index(drop=True), expected_data)          df_equals(filtered_by_indexing.reset_index(drop=True), expected_data)            filtered_by_filter_method = dn.filter((\"bar\", 2, Operator.EQUAL))          filtered_by_indexing = dn[dn[\"bar\"] == 2]          expected_data = modin_pd.DataFrame([{\"foo\": 1.0, \"bar\": 2.0}, {\"foo\": 2.0, \"bar\": 2.0}, {\"bar\": 2.0}])          df_equals(filtered_by_filter_method.reset_index(drop=True), expected_data)          df_equals(filtered_by_indexing.reset_index(drop=True), expected_data)            filtered_by_filter_method = dn.filter([(\"bar\", 1, Operator.EQUAL), (\"bar\", 2, Operator.EQUAL)], JoinOperator.OR)          filtered_by_indexing = dn[(dn[\"bar\"] == 1) | (dn[\"bar\"] == 2)]          expected_data = modin_pd.DataFrame(              [                  {\"foo\": 1.0, \"bar\": 1.0},                  {\"foo\": 1.0, \"bar\": 2.0},                  {\"foo\": 2.0, \"bar\": 2.0},                  {\"bar\": 2.0},              ]          )          df_equals(filtered_by_filter_method.reset_index(drop=True), expected_data)          df_equals(filtered_by_indexing.reset_index(drop=True), expected_data)        def test_filter_modin_exposed_type_without_sheetname(self, excel_file):          dn = ExcelDataNode(\"foo\", Scope.SCENARIO, properties={\"path\": excel_file, \"exposed_type\": \"modin\"})          dn.write(              [                  {\"foo\": 1, \"bar\": 1},                  {\"foo\": 1, \"bar\": 2},                  {\"foo\": 1},                  {\"foo\": 2, \"bar\": 2},                  {\"bar\": 2},              ]          )            assert len(dn.filter((\"foo\", 1, Operator.EQUAL))[\"Sheet1\"]) == 3          assert len(dn.filter((\"foo\", 1, Operator.NOT_EQUAL))[\"Sheet1\"]) == 2          assert len(dn.filter((\"bar\", 2, Operator.EQUAL))[\"Sheet1\"]) == 3          assert len(dn.filter([(\"bar\", 1, Operator.EQUAL), (\"bar\", 2, Operator.EQUAL)], JoinOperator.OR)[\"Sheet1\"]) == 4            assert dn[\"Sheet1\"][\"foo\"].equals(modin_pd.Series([1, 1, 1, 2, None]))          assert dn[\"Sheet1\"][\"bar\"].equals(modin_pd.Series([1, 2, None, 2, 2]))          assert dn[\"Sheet1\"][:2].equals(modin_pd.DataFrame([{\"foo\": 1.0, \"bar\": 1.0}, {\"foo\": 1.0, \"bar\": 2.0}]))        def test_filter_modin_exposed_type_multisheet(self, excel_file):          dn = ExcelDataNode(              \"foo\",              Scope.SCENARIO,              properties={\"path\": excel_file, \"sheet_name\": [\"sheet_1\", \"sheet_2\"], \"exposed_type\": \"modin\"},          )          dn.write(              {                  \"sheet_1\": pd.DataFrame(                      [                          {\"foo\": 1, \"bar\": 1},                          {\"foo\": 1, \"bar\": 2},                          {\"foo\": 1},                          {\"foo\": 2, \"bar\": 2},                          {\"bar\": 2},                      ]                  ),                  \"sheet_2\": pd.DataFrame(                      [                          {\"foo\": 1, \"bar\": 3},                          {\"foo\": 1, \"bar\": 4},                          {\"foo\": 1},                          {\"foo\": 2, \"bar\": 4},                          {\"bar\": 4},                      ]                  ),              }          )            assert len(dn.filter((\"foo\", 1, Operator.EQUAL))) == 2          assert len(dn.filter((\"foo\", 1, Operator.EQUAL))[\"sheet_1\"]) == 3          assert len(dn.filter((\"foo\", 1, Operator.EQUAL))[\"sheet_2\"]) == 3            assert len(dn.filter((\"foo\", 1, Operator.NOT_EQUAL))) == 2          assert len(dn.filter((\"foo\", 1, Operator.NOT_EQUAL))[\"sheet_1\"]) == 2          assert len(dn.filter((\"foo\", 1, Operator.NOT_EQUAL))[\"sheet_2\"]) == 2            assert len(dn.filter((\"bar\", 2, Operator.EQUAL))) == 2          assert len(dn.filter((\"bar\", 2, Operator.EQUAL))[\"sheet_1\"]) == 3          assert len(dn.filter((\"bar\", 2, Operator.EQUAL))[\"sheet_2\"]) == 0            assert len(dn.filter([(\"bar\", 1, Operator.EQUAL), (\"bar\", 2, Operator.EQUAL)], JoinOperator.OR)) == 2          assert len(dn.filter([(\"bar\", 1, Operator.EQUAL), (\"bar\", 2, Operator.EQUAL)], JoinOperator.OR)[\"sheet_1\"]) == 4          assert len(dn.filter([(\"bar\", 1, Operator.EQUAL), (\"bar\", 2, Operator.EQUAL)], JoinOperator.OR)[\"sheet_2\"]) == 0            assert dn[\"sheet_1\"][\"foo\"].equals(modin_pd.Series([1, 1, 1, 2, None]))          assert dn[\"sheet_2\"][\"foo\"].equals(modin_pd.Series([1, 1, 1, 2, None]))          assert dn[\"sheet_1\"][\"bar\"].equals(modin_pd.Series([1, 2, None, 2, 2]))          assert dn[\"sheet_2\"][\"bar\"].equals(modin_pd.Series([3, 4, None, 4, 4]))          assert dn[\"sheet_1\"][:2].equals(modin_pd.DataFrame([{\"foo\": 1.0, \"bar\": 1.0}, {\"foo\": 1.0, \"bar\": 2.0}]))          assert dn[\"sheet_2\"][:2].equals(modin_pd.DataFrame([{\"foo\": 1.0, \"bar\": 3.0}, {\"foo\": 1.0, \"bar\": 4.0}]))        def test_filter_numpy_exposed_type_with_sheetname(self, excel_file):          dn = ExcelDataNode(              \"foo\", Scope.SCENARIO, properties={\"path\": excel_file, \"sheet_name\": \"Sheet1\", \"exposed_type\": \"numpy\"}          )          dn.write(              [                  [1, 1],                  [1, 2],                  [1, 3],                  [2, 1],                  [2, 2],                  [2, 3],              ]          )            # Test datanode indexing and slicing          assert np.array_equal(dn[0], np.array([1, 1]))          assert np.array_equal(dn[1], np.array([1, 2]))          assert np.array_equal(dn[:3], np.array([[1, 1], [1, 2], [1, 3]]))          assert np.array_equal(dn[:, 0], np.array([1, 1, 1, 2, 2, 2]))          assert np.array_equal(dn[1:4, :1], np.array([[1], [1], [2]]))            # Test filter data          assert np.array_equal(dn.filter((0, 1, Operator.EQUAL)), np.array([[1, 1], [1, 2], [1, 3]]))          assert np.array_equal(dn[dn[:, 0] == 1], np.array([[1, 1], [1, 2], [1, 3]]))            assert np.array_equal(dn.filter((0, 1, Operator.NOT_EQUAL)), np.array([[2, 1], [2, 2], [2, 3]]))          assert np.array_equal(dn[dn[:, 0] != 1], np.array([[2, 1], [2, 2], [2, 3]]))            assert np.array_equal(dn.filter((1, 2, Operator.EQUAL)), np.array([[1, 2], [2, 2]]))          assert np.array_equal(dn[dn[:, 1] == 2], np.array([[1, 2], [2, 2]]))            assert np.array_equal(              dn.filter([(1, 1, Operator.EQUAL), (1, 2, Operator.EQUAL)], JoinOperator.OR),              np.array([[1, 1], [1, 2], [2, 1], [2, 2]]),          )          assert np.array_equal(dn[(dn[:, 1] == 1) | (dn[:, 1] == 2)], np.array([[1, 1], [1, 2], [2, 1], [2, 2]]))        def test_filter_numpy_exposed_type_without_sheetname(self, excel_file):          dn = ExcelDataNode(\"foo\", Scope.SCENARIO, properties={\"path\": excel_file, \"exposed_type\": \"numpy\"})          dn.write(              [                  [1, 1],                  [1, 2],                  [1, 3],                  [2, 1],                  [2, 2],                  [2, 3],              ]          )            assert len(dn.filter((0, 1, Operator.EQUAL))[\"Sheet1\"]) == 3          assert len(dn.filter((0, 1, Operator.NOT_EQUAL))[\"Sheet1\"]) == 3          assert len(dn.filter((1, 2, Operator.EQUAL))[\"Sheet1\"]) == 2          assert len(dn.filter([(0, 1, Operator.EQUAL), (1, 2, Operator.EQUAL)], JoinOperator.OR)[\"Sheet1\"]) == 4            assert np.array_equal(dn[\"Sheet1\"][0], np.array([1, 1]))          assert np.array_equal(dn[\"Sheet1\"][1], np.array([1, 2]))          assert np.array_equal(dn[\"Sheet1\"][:3], np.array([[1, 1], [1, 2], [1, 3]]))          assert np.array_equal(dn[\"Sheet1\"][:, 0], np.array([1, 1, 1, 2, 2, 2]))          assert np.array_equal(dn[\"Sheet1\"][1:4, :1], np.array([[1], [1], [2]]))        def test_filter_numpy_exposed_type_multisheet(self, excel_file):          dn = ExcelDataNode(              \"foo\",              Scope.SCENARIO,              properties={\"path\": excel_file, \"sheet_name\": [\"sheet_1\", \"sheet_2\"], \"exposed_type\": \"numpy\"},          )          dn.write(              {                  \"sheet_1\": pd.DataFrame(                      [                          [1, 1],                          [1, 2],                          [1, 3],                          [2, 1],                          [2, 2],                          [2, 3],                      ]                  ),                  \"sheet_2\": pd.DataFrame(                      [                          [1, 4],                          [1, 5],                          [1, 6],                          [2, 4],                          [2, 5],                          [2, 6],                      ]                  ),              }          )            assert len(dn.filter((0, 1, Operator.EQUAL))) == 2          assert len(dn.filter((0, 1, Operator.EQUAL))[\"sheet_1\"]) == 3          assert len(dn.filter((0, 1, Operator.EQUAL))[\"sheet_2\"]) == 3            assert len(dn.filter((0, 1, Operator.NOT_EQUAL))) == 2          assert len(dn.filter((0, 1, Operator.NOT_EQUAL))[\"sheet_1\"]) == 3          assert len(dn.filter((0, 1, Operator.NOT_EQUAL))[\"sheet_2\"]) == 3            assert len(dn.filter((1, 2, Operator.EQUAL))) == 2          assert len(dn.filter((1, 2, Operator.EQUAL))[\"sheet_1\"]) == 2          assert len(dn.filter((1, 2, Operator.EQUAL))[\"sheet_2\"]) == 0            assert len(dn.filter([(1, 1, Operator.EQUAL), (1, 2, Operator.EQUAL)], JoinOperator.OR)) == 2          assert len(dn.filter([(1, 1, Operator.EQUAL), (1, 2, Operator.EQUAL)], JoinOperator.OR)[\"sheet_1\"]) == 4          assert len(dn.filter([(1, 1, Operator.EQUAL), (1, 2, Operator.EQUAL)], JoinOperator.OR)[\"sheet_2\"]) == 0            assert np.array_equal(dn[\"sheet_1\"][0], np.array([1, 1]))          assert np.array_equal(dn[\"sheet_2\"][0], np.array([1, 4]))          assert np.array_equal(dn[\"sheet_1\"][1], np.array([1, 2]))          assert np.array_equal(dn[\"sheet_2\"][1], np.array([1, 5]))          assert np.array_equal(dn[\"sheet_1\"][:3], np.array([[1, 1], [1, 2], [1, 3]]))          assert np.array_equal(dn[\"sheet_2\"][:3], np.array([[1, 4], [1, 5], [1, 6]]))          assert np.array_equal(dn[\"sheet_1\"][:, 0], np.array([1, 1, 1, 2, 2, 2]))          assert np.array_equal(dn[\"sheet_2\"][:, 1], np.array([4, 5, 6, 4, 5, 6]))          assert np.array_equal(dn[\"sheet_1\"][1:4, :1], np.array([[1], [1], [2]]))          assert np.array_equal(dn[\"sheet_2\"][1:4, 1:2], np.array([[5], [6], [4]]))        def test_set_path(self):          dn = ExcelDataNode(\"foo\", Scope.SCENARIO, properties={\"default_path\": \"foo.xlsx\"})          assert dn.path == \"foo.xlsx\"          dn.path = \"bar.xlsx\"          assert dn.path == \"bar.xlsx\"        @pytest.mark.parametrize(          [\"properties\", \"exists\"],          [              ({}, False),              ({\"default_data\": {\"a\": [\"foo\", \"bar\"]}}, True),          ],      )      def test_create_with_default_data(self, properties, exists):          dn = ExcelDataNode(\"foo\", Scope.SCENARIO, DataNodeId(\"dn_id\"), properties=properties)          assert os.path.exists(dn.path) is exists        def test_read_write_after_modify_path(self):          path = os.path.join(pathlib.Path(__file__).parent.resolve(), \"data_sample/example.xlsx\")          new_path = os.path.join(pathlib.Path(__file__).parent.resolve(), \"data_sample/temp.xlsx\")          dn = ExcelDataNode(\"foo\", Scope.SCENARIO, properties={\"default_path\": path})          read_data = dn.read()          assert read_data is not None          dn.path = new_path          with pytest.raises(FileNotFoundError):              dn.read()          dn.write(read_data)          for sheet, df in dn.read().items():              assert np.array_equal(df.values, read_data[sheet].values)        def test_exposed_type_custom_class_after_modify_path(self):          path = os.path.join(pathlib.Path(__file__).parent.resolve(), \"data_sample/example.xlsx\")  # [\"Sheet1\", \"Sheet2\"]          new_path = os.path.join(              pathlib.Path(__file__).parent.resolve(), \"data_sample/example_2.xlsx\"          )  # [\"Sheet1\", \"Sheet2\", \"Sheet3\"]          dn = ExcelDataNode(\"foo\", Scope.SCENARIO, properties={\"default_path\": path, \"exposed_type\": MyCustomObject1})          assert dn.exposed_type == MyCustomObject1          dn.read()          dn.path = new_path          dn.read()            dn = ExcelDataNode(              \"foo\",              Scope.SCENARIO,              properties={\"default_path\": path, \"exposed_type\": MyCustomObject1, \"sheet_name\": [\"Sheet4\"]},          )          assert dn.exposed_type == MyCustomObject1          with pytest.raises(NonExistingExcelSheet):              dn.read()        def test_exposed_type_dict(self):          path = os.path.join(pathlib.Path(__file__).parent.resolve(), \"data_sample/example.xlsx\")  # [\"Sheet1\", \"Sheet2\"]          dn = ExcelDataNode(              \"foo\",              Scope.SCENARIO,              properties={                  \"default_path\": path,                  \"exposed_type\": {                      \"Sheet1\": MyCustomObject1,                      \"Sheet2\": MyCustomObject2,                      \"Sheet3\": MyCustomObject1,                  },              },          )          data = dn.read()          assert isinstance(data, Dict)          assert isinstance(data[\"Sheet1\"][0], MyCustomObject1)          assert isinstance(data[\"Sheet2\"][0], MyCustomObject2)        def test_exposed_type_list(self):          path_1 = os.path.join(              pathlib.Path(__file__).parent.resolve(), \"data_sample/example.xlsx\"          )  # [\"Sheet1\", \"Sheet2\"]          path_2 = os.path.join(              pathlib.Path(__file__).parent.resolve(), \"data_sample/example_2.xlsx\"          )  # [\"Sheet1\", \"Sheet2\", \"Sheet3\"]            dn = ExcelDataNode(              \"foo\",              Scope.SCENARIO,              properties={\"default_path\": path_1, \"exposed_type\": [MyCustomObject1, MyCustomObject2]},          )          data = dn.read()          assert isinstance(data, Dict)          assert isinstance(data[\"Sheet1\"][0], MyCustomObject1)          assert isinstance(data[\"Sheet2\"][0], MyCustomObject2)            dn.path = path_2          with pytest.raises(ExposedTypeLengthMismatch):              dn.read()        def test_not_trying_to_read_sheet_names_when_exposed_type_is_set(self):          dn = ExcelDataNode(              \"foo\", Scope.SCENARIO, properties={\"default_path\": \"notexistyet.xlsx\", \"exposed_type\": MyCustomObject1}          )          assert dn.path == \"notexistyet.xlsx\"          assert dn.exposed_type == MyCustomObject1          dn = ExcelDataNode(              \"foo\",              Scope.SCENARIO,              properties={\"default_path\": \"notexistyet.xlsx\", \"exposed_type\": [MyCustomObject1, MyCustomObject2]},          )          assert dn.path == \"notexistyet.xlsx\"          assert dn.exposed_type == [MyCustomObject1, MyCustomObject2]          dn = ExcelDataNode(              \"foo\",              Scope.SCENARIO,              properties={                  \"default_path\": \"notexistyet.xlsx\",                  \"exposed_type\": {\"Sheet1\": MyCustomObject1, \"Sheet2\": MyCustomObject2},              },          )          assert dn.path == \"notexistyet.xlsx\"          assert dn.exposed_type == {\"Sheet1\": MyCustomObject1, \"Sheet2\": MyCustomObject2}        def test_exposed_type_default(self):          path = os.path.join(pathlib.Path(__file__).parent.resolve(), \"data_sample/example.xlsx\")          dn = ExcelDataNode(\"foo\", Scope.SCENARIO, properties={\"default_path\": path, \"sheet_name\": \"Sheet1\"})          assert dn.exposed_type == \"pandas\"          data = dn.read()          assert isinstance(data, pd.DataFrame)        def test_pandas_exposed_type(self):          path = os.path.join(pathlib.Path(__file__).parent.resolve(), \"data_sample/example.xlsx\")          dn = ExcelDataNode(              \"foo\", Scope.SCENARIO, properties={\"default_path\": path, \"exposed_type\": \"pandas\", \"sheet_name\": \"Sheet1\"}          )          assert dn.exposed_type == \"pandas\"          data = dn.read()          assert isinstance(data, pd.DataFrame)        def test_complex_exposed_type_dict(self):          # [\"Sheet1\", \"Sheet2\", \"Sheet3\", \"Sheet4\", \"Sheet5\"]          path = os.path.join(pathlib.Path(__file__).parent.resolve(), \"data_sample/example_4.xlsx\")          dn = ExcelDataNode(              \"foo\",              Scope.SCENARIO,              properties={                  \"default_path\": path,                  \"exposed_type\": {                      \"Sheet1\": MyCustomObject1,                      \"Sheet2\": \"numpy\",                      \"Sheet3\": \"pandas\",                  },                  \"sheet_name\": [\"Sheet1\", \"Sheet2\", \"Sheet3\", \"Sheet4\"],              },          )          data = dn.read()          assert isinstance(data, dict)          assert isinstance(data[\"Sheet1\"], list)          assert isinstance(data[\"Sheet1\"][0], MyCustomObject1)          assert isinstance(data[\"Sheet2\"], np.ndarray)          assert isinstance(data[\"Sheet3\"], pd.DataFrame)          assert isinstance(data[\"Sheet4\"], pd.DataFrame)          assert data.get(\"Sheet5\") is None        def test_complex_exposed_type_list(self):          # [\"Sheet1\", \"Sheet2\", \"Sheet3\", \"Sheet4\",\"Sheet5\"]          path = os.path.join(pathlib.Path(__file__).parent.resolve(), \"data_sample/example_4.xlsx\")          dn = ExcelDataNode(              \"foo\",              Scope.SCENARIO,              properties={                  \"default_path\": path,                  \"exposed_type\": [MyCustomObject1, \"numpy\", \"pandas\"],                  \"sheet_name\": [\"Sheet1\", \"Sheet2\", \"Sheet3\"],              },          )          data = dn.read()          assert isinstance(data, dict)          assert isinstance(data[\"Sheet1\"], list)          assert isinstance(data[\"Sheet1\"][0], MyCustomObject1)          assert isinstance(data[\"Sheet2\"], np.ndarray)          assert isinstance(data[\"Sheet3\"], pd.DataFrame)        def test_invalid_exposed_type(self):          path = os.path.join(pathlib.Path(__file__).parent.resolve(), \"data_sample/example.xlsx\")          with pytest.raises(InvalidExposedType):              ExcelDataNode(                  \"foo\",                  Scope.SCENARIO,                  properties={\"default_path\": path, \"exposed_type\": \"invalid\", \"sheet_name\": \"Sheet1\"},              )            with pytest.raises(InvalidExposedType):              ExcelDataNode(                  \"foo\",                  Scope.SCENARIO,                  properties={                      \"default_path\": path,                      \"exposed_type\": [\"numpy\", \"invalid\", \"pandas\"],                      \"sheet_name\": \"Sheet1\",                  },              )            with pytest.raises(InvalidExposedType):              ExcelDataNode(                  \"foo\",                  Scope.SCENARIO,                  properties={                      \"default_path\": path,                      \"exposed_type\": {\"Sheet1\": \"pandas\", \"Sheet2\": \"invalid\"},                      \"sheet_name\": \"Sheet1\",                  },              )        def test_get_system_modified_date_instead_of_last_edit_date(self, tmpdir_factory):          temp_file_path = str(tmpdir_factory.mktemp(\"data\").join(\"temp.xlsx\"))          pd.DataFrame([]).to_excel(temp_file_path)          dn = ExcelDataNode(\"foo\", Scope.SCENARIO, properties={\"path\": temp_file_path, \"exposed_type\": \"pandas\"})            dn.write(pd.DataFrame([1, 2, 3]))          previous_edit_date = dn.last_edit_date            sleep(0.1)            pd.DataFrame([4, 5, 6]).to_excel(temp_file_path)          new_edit_date = datetime.fromtimestamp(os.path.getmtime(temp_file_path))            assert previous_edit_date < dn.last_edit_date          assert new_edit_date == dn.last_edit_date            sleep(0.1)            dn.write(pd.DataFrame([7, 8, 9]))          assert new_edit_date < dn.last_edit_date          os.unlink(temp_file_path) "}
{"text": "import os  import pathlib    import pytest    from src.taipy.core._version._version_manager import _VersionManager  from src.taipy.core.config.data_node_config import DataNodeConfig  from src.taipy.core.data._data_manager import _DataManager  from src.taipy.core.data._data_manager_factory import _DataManagerFactory  from src.taipy.core.data.csv import CSVDataNode  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 InvalidDataNodeType, ModelNotFound  from taipy.config.common.scope import Scope  from taipy.config.config import Config      def file_exists(file_path: str) -> bool:      return os.path.exists(file_path)      def init_managers():      _DataManagerFactory._build_manager()._delete_all()      class TestDataManager:      def test_create_data_node_and_modify_properties_does_not_modify_config(self, init_sql_repo):          init_managers()            dn_config = Config.configure_data_node(id=\"name\", foo=\"bar\")          dn = _DataManager._create_and_set(dn_config, None, None)          assert dn_config.properties.get(\"foo\") == \"bar\"          assert dn_config.properties.get(\"baz\") is None            dn.properties[\"baz\"] = \"qux\"          _DataManager._set(dn)          assert dn_config.properties.get(\"foo\") == \"bar\"          assert dn_config.properties.get(\"baz\") is None          assert dn.properties.get(\"foo\") == \"bar\"          assert dn.properties.get(\"baz\") == \"qux\"        def test_create_raises_exception_with_wrong_type(self, init_sql_repo):          init_managers()            wrong_type_dn_config = DataNodeConfig(id=\"foo\", storage_type=\"bar\", scope=DataNodeConfig._DEFAULT_SCOPE)          with pytest.raises(InvalidDataNodeType):              _DataManager._create_and_set(wrong_type_dn_config, None, None)        def test_create_from_same_config_generates_new_data_node_and_new_id(self, init_sql_repo):          init_managers()            dn_config = Config.configure_data_node(id=\"foo\", storage_type=\"in_memory\")          dn = _DataManager._create_and_set(dn_config, None, None)          dn_2 = _DataManager._create_and_set(dn_config, None, None)          assert dn_2.id != dn.id        def test_create_uses_overridden_attributes_in_config_file(self, init_sql_repo):          init_managers()            Config.override(os.path.join(pathlib.Path(__file__).parent.resolve(), \"data_sample/config.toml\"))            csv_dn_cfg = Config.configure_data_node(id=\"foo\", storage_type=\"csv\", path=\"bar\", has_header=True)          csv_dn = _DataManager._create_and_set(csv_dn_cfg, None, None)          assert csv_dn.config_id == \"foo\"          assert isinstance(csv_dn, CSVDataNode)          assert csv_dn._path == \"path_from_config_file\"          assert csv_dn.has_header            csv_dn_cfg = Config.configure_data_node(id=\"baz\", storage_type=\"csv\", path=\"bar\", has_header=True)          csv_dn = _DataManager._create_and_set(csv_dn_cfg, None, None)          assert csv_dn.config_id == \"baz\"          assert isinstance(csv_dn, CSVDataNode)          assert csv_dn._path == \"bar\"          assert csv_dn.has_header        def test_get_if_not_exists(self, init_sql_repo):          init_managers()            with pytest.raises(ModelNotFound):              _DataManager._repository._load(\"test_data_node_2\")        def test_get_all(self, init_sql_repo):          init_managers()            _DataManager._delete_all()          assert len(_DataManager._get_all()) == 0          dn_config_1 = Config.configure_data_node(id=\"foo\", storage_type=\"in_memory\")          _DataManager._create_and_set(dn_config_1, None, None)          assert len(_DataManager._get_all()) == 1          dn_config_2 = Config.configure_data_node(id=\"baz\", storage_type=\"in_memory\")          _DataManager._create_and_set(dn_config_2, None, None)          _DataManager._create_and_set(dn_config_2, None, None)          assert len(_DataManager._get_all()) == 3          assert len([dn for dn in _DataManager._get_all() if dn.config_id == \"foo\"]) == 1          assert len([dn for dn in _DataManager._get_all() if dn.config_id == \"baz\"]) == 2        def test_get_all_on_multiple_versions_environment(self, init_sql_repo):          init_managers()            # Create 5 data nodes with 2 versions each          # Only version 1.0 has the data node with config_id = \"config_id_1\"          # Only version 2.0 has the data node with config_id = \"config_id_6\"          for version in range(1, 3):              for i in range(5):                  _DataManager._set(                      InMemoryDataNode(                          f\"config_id_{i+version}\",                          Scope.SCENARIO,                          id=DataNodeId(f\"id{i}_v{version}\"),                          version=f\"{version}.0\",                      )                  )            _VersionManager._set_experiment_version(\"1.0\")          assert len(_DataManager._get_all()) == 5          assert len(_DataManager._get_all_by(filters=[{\"version\": \"1.0\", \"config_id\": \"config_id_1\"}])) == 1          assert len(_DataManager._get_all_by(filters=[{\"version\": \"1.0\", \"config_id\": \"config_id_6\"}])) == 0            _VersionManager._set_development_version(\"1.0\")          assert len(_DataManager._get_all()) == 5          assert len(_DataManager._get_all_by(filters=[{\"version\": \"1.0\", \"config_id\": \"config_id_1\"}])) == 1          assert len(_DataManager._get_all_by(filters=[{\"version\": \"1.0\", \"config_id\": \"config_id_6\"}])) == 0            _VersionManager._set_experiment_version(\"2.0\")          assert len(_DataManager._get_all()) == 5          assert len(_DataManager._get_all_by(filters=[{\"version\": \"2.0\", \"config_id\": \"config_id_1\"}])) == 0          assert len(_DataManager._get_all_by(filters=[{\"version\": \"2.0\", \"config_id\": \"config_id_6\"}])) == 1            _VersionManager._set_development_version(\"2.0\")          assert len(_DataManager._get_all()) == 5          assert len(_DataManager._get_all_by(filters=[{\"version\": \"2.0\", \"config_id\": \"config_id_1\"}])) == 0          assert len(_DataManager._get_all_by(filters=[{\"version\": \"2.0\", \"config_id\": \"config_id_6\"}])) == 1        def test_set(self, init_sql_repo):          init_managers()            dn = InMemoryDataNode(              \"config_id\",              Scope.SCENARIO,              id=DataNodeId(\"id\"),              owner_id=None,              parent_ids={\"task_id_1\"},              last_edit_date=None,              edits=[],              edit_in_progress=False,              properties={\"foo\": \"bar\"},          )          assert len(_DataManager._get_all()) == 0          assert not _DataManager._exists(dn.id)          _DataManager._set(dn)          assert len(_DataManager._get_all()) == 1          assert _DataManager._exists(dn.id)            # changing data node attribute          dn.config_id = \"foo\"          assert dn.config_id == \"foo\"          _DataManager._set(dn)          assert len(_DataManager._get_all()) == 1          assert dn.config_id == \"foo\"          assert _DataManager._get(dn.id).config_id == \"foo\"        def test_delete(self, init_sql_repo):          init_managers()          _DataManager._delete_all()            dn_1 = InMemoryDataNode(\"config_id\", Scope.SCENARIO, id=\"id_1\")          dn_2 = InMemoryDataNode(\"config_id\", Scope.SCENARIO, id=\"id_2\")          dn_3 = InMemoryDataNode(\"config_id\", Scope.SCENARIO, id=\"id_3\")          assert len(_DataManager._get_all()) == 0          _DataManager._set(dn_1)          _DataManager._set(dn_2)          _DataManager._set(dn_3)          assert len(_DataManager._get_all()) == 3          assert all(_DataManager._exists(dn.id) for dn in [dn_1, dn_2, dn_3])          _DataManager._delete(dn_1.id)          assert len(_DataManager._get_all()) == 2          assert _DataManager._get(dn_2.id).id == dn_2.id          assert _DataManager._get(dn_3.id).id == dn_3.id          assert _DataManager._get(dn_1.id) is None          assert all(_DataManager._exists(dn.id) for dn in [dn_2, dn_3])          assert not _DataManager._exists(dn_1.id)          _DataManager._delete_all()          assert len(_DataManager._get_all()) == 0          assert not any(_DataManager._exists(dn.id) for dn in [dn_2, dn_3])        def test_get_or_create(self, init_sql_repo):          def _get_or_create_dn(config, *args):              return _DataManager._bulk_get_or_create([config], *args)[config]            init_managers()            global_dn_config = Config.configure_data_node(              id=\"test_data_node\", storage_type=\"in_memory\", scope=Scope.GLOBAL, data=\"In memory Data Node\"          )          cycle_dn_config = Config.configure_data_node(              id=\"test_data_node1\", storage_type=\"in_memory\", scope=Scope.CYCLE, data=\"In memory scenario\"          )          scenario_dn_config = Config.configure_data_node(              id=\"test_data_node2\", storage_type=\"in_memory\", scope=Scope.SCENARIO, data=\"In memory scenario\"          )            _DataManager._delete_all()            assert len(_DataManager._get_all()) == 0          global_dn = _get_or_create_dn(global_dn_config, None, None)          assert len(_DataManager._get_all()) == 1          global_dn_bis = _get_or_create_dn(global_dn_config, None)          assert len(_DataManager._get_all()) == 1          assert global_dn.id == global_dn_bis.id            scenario_dn = _get_or_create_dn(scenario_dn_config, None, \"scenario_id\")          assert len(_DataManager._get_all()) == 2          scenario_dn_bis = _get_or_create_dn(scenario_dn_config, None, \"scenario_id\")          assert len(_DataManager._get_all()) == 2          assert scenario_dn.id == scenario_dn_bis.id          scenario_dn_ter = _get_or_create_dn(scenario_dn_config, None, \"scenario_id\")          assert len(_DataManager._get_all()) == 2          assert scenario_dn.id == scenario_dn_bis.id          assert scenario_dn_bis.id == scenario_dn_ter.id          scenario_dn_quater = _get_or_create_dn(scenario_dn_config, None, \"scenario_id_2\")          assert len(_DataManager._get_all()) == 3          assert scenario_dn.id == scenario_dn_bis.id          assert scenario_dn_bis.id == scenario_dn_ter.id          assert scenario_dn_ter.id != scenario_dn_quater.id            assert len(_DataManager._get_all()) == 3          cycle_dn = _get_or_create_dn(cycle_dn_config, \"cycle_id\", None)          assert len(_DataManager._get_all()) == 4          cycle_dn_1 = _get_or_create_dn(cycle_dn_config, \"cycle_id\", None)          assert len(_DataManager._get_all()) == 4          assert cycle_dn.id == cycle_dn_1.id          cycle_dn_2 = _get_or_create_dn(cycle_dn_config, \"cycle_id\", \"scenario_id\")          assert len(_DataManager._get_all()) == 4          assert cycle_dn.id == cycle_dn_2.id          cycle_dn_3 = _get_or_create_dn(cycle_dn_config, \"cycle_id\", None)          assert len(_DataManager._get_all()) == 4          assert cycle_dn.id == cycle_dn_3.id          cycle_dn_4 = _get_or_create_dn(cycle_dn_config, \"cycle_id\", \"scenario_id\")          assert len(_DataManager._get_all()) == 4          assert cycle_dn.id == cycle_dn_4.id          cycle_dn_5 = _get_or_create_dn(cycle_dn_config, \"cycle_id\", \"scenario_id_2\")          assert len(_DataManager._get_all()) == 4          assert cycle_dn.id == cycle_dn_5.id            assert cycle_dn_1.id == cycle_dn_2.id          assert cycle_dn_2.id == cycle_dn_3.id          assert cycle_dn_3.id == cycle_dn_4.id          assert cycle_dn_4.id == cycle_dn_5.id        def test_get_data_nodes_by_config_id(self, init_sql_repo):          init_managers()            dn_config_1 = Config.configure_data_node(\"dn_1\", scope=Scope.SCENARIO)          dn_config_2 = Config.configure_data_node(\"dn_2\", scope=Scope.SCENARIO)          dn_config_3 = Config.configure_data_node(\"dn_3\", scope=Scope.SCENARIO)            dn_1_1 = _DataManager._create_and_set(dn_config_1, None, None)          dn_1_2 = _DataManager._create_and_set(dn_config_1, None, None)          dn_1_3 = _DataManager._create_and_set(dn_config_1, None, None)          assert len(_DataManager._get_all()) == 3            dn_2_1 = _DataManager._create_and_set(dn_config_2, None, None)          dn_2_2 = _DataManager._create_and_set(dn_config_2, None, None)          assert len(_DataManager._get_all()) == 5            dn_3_1 = _DataManager._create_and_set(dn_config_3, None, None)          assert len(_DataManager._get_all()) == 6            dn_1_datanodes = _DataManager._get_by_config_id(dn_config_1.id)          assert len(dn_1_datanodes) == 3          assert sorted([dn_1_1.id, dn_1_2.id, dn_1_3.id]) == sorted([sequence.id for sequence in dn_1_datanodes])            dn_2_datanodes = _DataManager._get_by_config_id(dn_config_2.id)          assert len(dn_2_datanodes) == 2          assert sorted([dn_2_1.id, dn_2_2.id]) == sorted([sequence.id for sequence in dn_2_datanodes])            dn_3_datanodes = _DataManager._get_by_config_id(dn_config_3.id)          assert len(dn_3_datanodes) == 1          assert sorted([dn_3_1.id]) == sorted([sequence.id for sequence in dn_3_datanodes])        def test_get_data_nodes_by_config_id_in_multiple_versions_environment(self, init_sql_repo):          init_managers()            dn_config_1 = Config.configure_data_node(\"dn_1\", scope=Scope.SCENARIO)          dn_config_2 = Config.configure_data_node(\"dn_2\", scope=Scope.SCENARIO)            _VersionManager._set_experiment_version(\"1.0\")          _DataManager._create_and_set(dn_config_1, None, None)          _DataManager._create_and_set(dn_config_1, None, None)          _DataManager._create_and_set(dn_config_1, None, None)          _DataManager._create_and_set(dn_config_2, None, None)          _DataManager._create_and_set(dn_config_2, None, None)            assert len(_DataManager._get_by_config_id(dn_config_1.id)) == 3          assert len(_DataManager._get_by_config_id(dn_config_2.id)) == 2            _VersionManager._set_experiment_version(\"2.0\")          _DataManager._create_and_set(dn_config_1, None, None)          _DataManager._create_and_set(dn_config_1, None, None)          _DataManager._create_and_set(dn_config_1, None, None)          _DataManager._create_and_set(dn_config_2, None, None)          _DataManager._create_and_set(dn_config_2, None, None)            assert len(_DataManager._get_by_config_id(dn_config_1.id)) == 3          assert len(_DataManager._get_by_config_id(dn_config_2.id)) == 2 "}
{"text": "import os    import pytest    from src.taipy.core.data._data_manager_factory import _DataManagerFactory  from src.taipy.core.exceptions import ModelNotFound  from src.taipy.core.job._job_manager_factory import _JobManagerFactory  from src.taipy.core.submission._submission_manager_factory import _SubmissionManagerFactory  from src.taipy.core.submission.submission import Submission  from src.taipy.core.task._task_manager_factory import _TaskManagerFactory  from src.taipy.core.task.task import Task  from taipy.config.config import Config  from tests.conftest import init_sql_repo      def configure_fs_repo():      Config.configure_core(repository_type=\"default\")      def configure_sql_repo():      init_sql_repo      class TestSubmissionRepository:      @pytest.mark.parametrize(\"configure_repo\", [configure_fs_repo, configure_sql_repo])      def test_save_and_load(self, data_node, job, configure_repo):          configure_repo()            _DataManagerFactory._build_manager()._repository._save(data_node)          task = Task(\"task_config_id\", {}, print, [data_node], [data_node])          _TaskManagerFactory._build_manager()._repository._save(task)          job._task = task          _JobManagerFactory._build_manager()._repository._save(job)            submission = Submission(task.id)          submission_repository = _SubmissionManagerFactory._build_manager()._repository          submission_repository._save(submission)          submission.jobs = [job]            obj = submission_repository._load(submission.id)          assert isinstance(obj, Submission)        @pytest.mark.parametrize(\"configure_repo\", [configure_fs_repo, configure_sql_repo])      def test_exists(self, configure_repo):          configure_repo()            submission = Submission(\"entity_id\")          submission_repository = _SubmissionManagerFactory._build_manager()._repository          submission_repository._save(submission)            assert submission_repository._exists(submission.id)          assert not submission_repository._exists(\"not-existed-submission\")        @pytest.mark.parametrize(\"configure_repo\", [configure_fs_repo, configure_sql_repo])      def test_load_all(self, configure_repo):          configure_repo()            repository = _SubmissionManagerFactory._build_manager()._repository          submission = Submission(\"entity_id\")          for i in range(10):              submission.id = f\"submission-{i}\"              repository._save(submission)          submissions = repository._load_all()            assert len(submissions) == 10        @pytest.mark.parametrize(\"configure_repo\", [configure_fs_repo, configure_sql_repo])      def test_delete(self, configure_repo):          configure_repo()            repository = _SubmissionManagerFactory._build_manager()._repository            submission = Submission(\"entity_id\")          repository._save(submission)            repository._delete(submission.id)            with pytest.raises(ModelNotFound):              repository._load(submission.id)        @pytest.mark.parametrize(\"configure_repo\", [configure_fs_repo, configure_sql_repo])      def test_delete_all(self, configure_repo):          configure_repo()            submission_repository = _SubmissionManagerFactory._build_manager()._repository          submission = Submission(\"entity_id\")            for i in range(10):              submission.id = f\"submission-{i}\"              submission_repository._save(submission)            assert len(submission_repository._load_all()) == 10            submission_repository._delete_all()            assert len(submission_repository._load_all()) == 0        @pytest.mark.parametrize(\"configure_repo\", [configure_fs_repo, configure_sql_repo])      def test_delete_many(self, configure_repo):          configure_repo()            submission = Submission(\"entity_id\")          submission_repository = _SubmissionManagerFactory._build_manager()._repository            for i in range(10):              submission.id = f\"submission-{i}\"              submission_repository._save(submission)            objs = submission_repository._load_all()          assert len(objs) == 10          ids = [x.id for x in objs[:3]]          submission_repository._delete_many(ids)            assert len(submission_repository._load_all()) == 7        @pytest.mark.parametrize(\"configure_repo\", [configure_fs_repo, configure_sql_repo])      def test_delete_by(self, configure_repo):          configure_repo()            # Create 5 entities with version 1.0 and 5 entities with version 2.0          submission_repository = _SubmissionManagerFactory._build_manager()._repository          submission = Submission(\"entity_id\")            for i in range(10):              submission.id = f\"submission-{i}\"              submission._version = f\"{(i+1) // 5}.0\"              submission_repository._save(submission)            objs = submission_repository._load_all()          assert len(objs) == 10          submission_repository._delete_by(\"version\", \"1.0\")            assert len(submission_repository._load_all()) == 5        @pytest.mark.parametrize(\"configure_repo\", [configure_fs_repo, configure_sql_repo])      def test_search(self, configure_repo):          configure_repo()            submission_repository = _SubmissionManagerFactory._build_manager()._repository          submission = Submission(\"entity_id\", version=\"random_version_number\")          for i in range(10):              submission.id = f\"submission-{i}\"              submission_repository._save(submission)            assert len(submission_repository._load_all()) == 10            objs = submission_repository._search(\"id\", \"submission-2\")          assert len(objs) == 1          assert isinstance(objs[0], Submission)            objs = submission_repository._search(\"id\", \"submission-2\", filters=[{\"version\": \"random_version_number\"}])          assert len(objs) == 1          assert isinstance(objs[0], Submission)            assert submission_repository._search(\"id\", \"submission-2\", filters=[{\"version\": \"non_existed_version\"}]) == []        @pytest.mark.parametrize(\"configure_repo\", [configure_fs_repo, configure_sql_repo])      def test_export(self, tmpdir, configure_repo):          configure_repo()            repository = _SubmissionManagerFactory._build_manager()._repository          submission = Submission(\"entity_id\")          repository._save(submission)            repository._export(submission.id, tmpdir.strpath)          dir_path = (              repository.dir_path              if Config.core.repository_type == \"default\"              else os.path.join(tmpdir.strpath, \"submission\")          )            assert os.path.exists(os.path.join(dir_path, f\"{submission.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": "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 functools import partial  from typing import Union  from unittest import mock  from unittest.mock import patch    import pytest    from src.taipy.core import TaskId  from src.taipy.core.job._job_manager_factory import _JobManagerFactory  from src.taipy.core.job.job import Job  from src.taipy.core.job.status import Status  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_manager_factory import _TaskManagerFactory  from src.taipy.core.task.task import Task      def test_create_submission(scenario, job, current_datetime):      submission_1 = Submission(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      assert submission_1._version is not None        submission_2 = Submission(          scenario.id, \"submission_id\", [job], current_datetime, SubmissionStatus.COMPLETED, \"version_id\"      )        assert submission_2.id == \"submission_id\"      assert submission_2.entity_id == scenario.id      assert submission_2._jobs == [job]      assert submission_2.creation_date == current_datetime      assert submission_2._submission_status == SubmissionStatus.COMPLETED      assert submission_2._version == \"version_id\"      class MockJob:      def __init__(self, id: str, status):          self.status = status          self.id = id        def is_failed(self):          return self.status == Status.FAILED        def is_canceled(self):          return self.status == Status.CANCELED        def is_blocked(self):          return self.status == Status.BLOCKED        def is_pending(self):          return self.status == Status.PENDING        def is_running(self):          return self.status == Status.RUNNING        def is_completed(self):          return self.status == Status.COMPLETED        def is_skipped(self):          return self.status == Status.SKIPPED        def is_abandoned(self):          return self.status == Status.ABANDONED        def is_submitted(self):          return self.status == Status.SUBMITTED      def mock_get_jobs(job_ids):      jobs = {          \"job0_submitted\": MockJob(\"job0_submitted\", Status.SUBMITTED),          \"job1_failed\": MockJob(\"job1_failed\", Status.FAILED),          \"job2_canceled\": MockJob(\"job2_canceled\", Status.CANCELED),          \"job3_blocked\": MockJob(\"job3_blocked\", Status.BLOCKED),          \"job4_pending\": MockJob(\"job4_pending\", Status.PENDING),          \"job5_running\": MockJob(\"job5_running\", Status.RUNNING),          \"job6_completed\": MockJob(\"job6_completed\", Status.COMPLETED),          \"job7_skipped\": MockJob(\"job7_skipped\", Status.SKIPPED),          \"job8_abandoned\": MockJob(\"job8_abandoned\", Status.ABANDONED),      }      return [jobs[job_id] for job_id in job_ids]      def __test_update_submission_status(job_ids, expected_submission_status):      with (          patch(              \"src.taipy.core.submission.submission.Submission.jobs\",              new_callable=mock.PropertyMock,              return_value=(mock_get_jobs(job_ids)),          )      ):          submission = Submission(\"submission_id\")          submission._update_submission_status(None)          assert submission.submission_status == expected_submission_status      @pytest.mark.parametrize(      \"job_ids, expected_submission_status\",      [          ([\"job1_failed\"], SubmissionStatus.FAILED),          ([\"job2_canceled\"], SubmissionStatus.CANCELED),          ([\"job3_blocked\"], SubmissionStatus.BLOCKED),          ([\"job4_pending\"], SubmissionStatus.PENDING),          ([\"job5_running\"], SubmissionStatus.RUNNING),          ([\"job6_completed\"], SubmissionStatus.COMPLETED),          ([\"job7_skipped\"], SubmissionStatus.COMPLETED),          ([\"job8_abandoned\"], SubmissionStatus.UNDEFINED),      ],  )  def test_update_single_submission_status(job_ids, expected_submission_status):      __test_update_submission_status(job_ids, expected_submission_status)      @pytest.mark.parametrize(      \"job_ids, expected_submission_status\",      [          ([\"job1_failed\", \"job1_failed\"], SubmissionStatus.FAILED),          ([\"job1_failed\", \"job2_canceled\"], SubmissionStatus.FAILED),          ([\"job1_failed\", \"job3_blocked\"], SubmissionStatus.FAILED),          ([\"job1_failed\", \"job4_pending\"], SubmissionStatus.FAILED),          ([\"job1_failed\", \"job5_running\"], SubmissionStatus.FAILED),          ([\"job1_failed\", \"job6_completed\"], SubmissionStatus.FAILED),          ([\"job1_failed\", \"job7_skipped\"], SubmissionStatus.FAILED),          ([\"job1_failed\", \"job8_abandoned\"], SubmissionStatus.FAILED),          ([\"job2_canceled\", \"job1_failed\"], SubmissionStatus.FAILED),          ([\"job3_blocked\", \"job1_failed\"], SubmissionStatus.FAILED),          ([\"job4_pending\", \"job1_failed\"], SubmissionStatus.FAILED),          ([\"job5_running\", \"job1_failed\"], SubmissionStatus.FAILED),          ([\"job6_completed\", \"job1_failed\"], SubmissionStatus.FAILED),          ([\"job7_skipped\", \"job1_failed\"], SubmissionStatus.FAILED),          ([\"job8_abandoned\", \"job1_failed\"], SubmissionStatus.FAILED),      ],  )  def test_update_submission_status_with_one_failed_job_in_jobs(job_ids, expected_submission_status):      __test_update_submission_status(job_ids, expected_submission_status)      @pytest.mark.parametrize(      \"job_ids, expected_submission_status\",      [          ([\"job2_canceled\", \"job2_canceled\"], SubmissionStatus.CANCELED),          ([\"job2_canceled\", \"job3_blocked\"], SubmissionStatus.CANCELED),          ([\"job2_canceled\", \"job4_pending\"], SubmissionStatus.CANCELED),          ([\"job2_canceled\", \"job5_running\"], SubmissionStatus.CANCELED),          ([\"job2_canceled\", \"job6_completed\"], SubmissionStatus.CANCELED),          ([\"job2_canceled\", \"job7_skipped\"], SubmissionStatus.CANCELED),          ([\"job2_canceled\", \"job8_abandoned\"], SubmissionStatus.CANCELED),          ([\"job3_blocked\", \"job2_canceled\"], SubmissionStatus.CANCELED),          ([\"job4_pending\", \"job2_canceled\"], SubmissionStatus.CANCELED),          ([\"job5_running\", \"job2_canceled\"], SubmissionStatus.CANCELED),          ([\"job6_completed\", \"job2_canceled\"], SubmissionStatus.CANCELED),          ([\"job7_skipped\", \"job2_canceled\"], SubmissionStatus.CANCELED),          ([\"job8_abandoned\", \"job2_canceled\"], SubmissionStatus.CANCELED),      ],  )  def test_update_submission_status_with_one_canceled_job_in_jobs(job_ids, expected_submission_status):      __test_update_submission_status(job_ids, expected_submission_status)      @pytest.mark.parametrize(      \"job_ids, expected_submission_status\",      [          ([\"job4_pending\", \"job3_blocked\"], SubmissionStatus.PENDING),          ([\"job4_pending\", \"job4_pending\"], SubmissionStatus.PENDING),          ([\"job4_pending\", \"job6_completed\"], SubmissionStatus.PENDING),          ([\"job4_pending\", \"job7_skipped\"], SubmissionStatus.PENDING),          ([\"job3_blocked\", \"job4_pending\"], SubmissionStatus.PENDING),          ([\"job6_completed\", \"job4_pending\"], SubmissionStatus.PENDING),          ([\"job7_skipped\", \"job4_pending\"], SubmissionStatus.PENDING),      ],  )  def test_update_submission_status_with_no_failed_or_cancel_one_pending_in_jobs(job_ids, expected_submission_status):      __test_update_submission_status(job_ids, expected_submission_status)      @pytest.mark.parametrize(      \"job_ids, expected_submission_status\",      [          ([\"job5_running\", \"job3_blocked\"], SubmissionStatus.RUNNING),          ([\"job5_running\", \"job4_pending\"], SubmissionStatus.RUNNING),          ([\"job5_running\", \"job5_running\"], SubmissionStatus.RUNNING),          ([\"job5_running\", \"job6_completed\"], SubmissionStatus.RUNNING),          ([\"job5_running\", \"job7_skipped\"], SubmissionStatus.RUNNING),          ([\"job3_blocked\", \"job5_running\"], SubmissionStatus.RUNNING),          ([\"job4_pending\", \"job5_running\"], SubmissionStatus.RUNNING),          ([\"job6_completed\", \"job5_running\"], SubmissionStatus.RUNNING),          ([\"job7_skipped\", \"job5_running\"], SubmissionStatus.RUNNING),      ],  )  def test_update_submission_status_with_no_failed_cancel_nor_pending_one_running_in_jobs(      job_ids, expected_submission_status  ):      __test_update_submission_status(job_ids, expected_submission_status)      @pytest.mark.parametrize(      \"job_ids, expected_submission_status\",      [          ([\"job3_blocked\", \"job3_blocked\"], SubmissionStatus.BLOCKED),          ([\"job3_blocked\", \"job6_completed\"], SubmissionStatus.BLOCKED),          ([\"job3_blocked\", \"job7_skipped\"], SubmissionStatus.BLOCKED),          ([\"job6_completed\", \"job3_blocked\"], SubmissionStatus.BLOCKED),          ([\"job7_skipped\", \"job3_blocked\"], SubmissionStatus.BLOCKED),      ],  )  def test_update_submission_status_with_no_failed_cancel_pending_nor_running_one_blocked_in_jobs(      job_ids, expected_submission_status  ):      __test_update_submission_status(job_ids, expected_submission_status)      @pytest.mark.parametrize(      \"job_ids, expected_submission_status\",      [          ([\"job6_completed\", \"job6_completed\"], SubmissionStatus.COMPLETED),          ([\"job6_completed\", \"job7_skipped\"], SubmissionStatus.COMPLETED),          ([\"job7_skipped\", \"job6_completed\"], SubmissionStatus.COMPLETED),          ([\"job7_skipped\", \"job7_skipped\"], SubmissionStatus.COMPLETED),      ],  )  def test_update_submission_status_with_only_completed_or_skipped_in_jobs(job_ids, expected_submission_status):      __test_update_submission_status(job_ids, expected_submission_status)      @pytest.mark.parametrize(      \"job_ids, expected_submission_status\",      [          ([\"job3_blocked\", \"job8_abandoned\"], SubmissionStatus.UNDEFINED),          ([\"job4_pending\", \"job8_abandoned\"], SubmissionStatus.UNDEFINED),          ([\"job5_running\", \"job8_abandoned\"], SubmissionStatus.UNDEFINED),          ([\"job6_completed\", \"job8_abandoned\"], SubmissionStatus.UNDEFINED),          ([\"job7_skipped\", \"job8_abandoned\"], SubmissionStatus.UNDEFINED),          ([\"job8_abandoned\", \"job8_abandoned\"], SubmissionStatus.UNDEFINED),          ([\"job8_abandoned\", \"job3_blocked\"], SubmissionStatus.UNDEFINED),          ([\"job8_abandoned\", \"job4_pending\"], SubmissionStatus.UNDEFINED),          ([\"job8_abandoned\", \"job5_running\"], SubmissionStatus.UNDEFINED),          ([\"job8_abandoned\", \"job6_completed\"], SubmissionStatus.UNDEFINED),          ([\"job8_abandoned\", \"job7_skipped\"], SubmissionStatus.UNDEFINED),      ],  )  def test_update_submission_status_with_wrong_case_abandoned_without_cancel_or_failed_in_jobs(      job_ids, expected_submission_status  ):      __test_update_submission_status(job_ids, expected_submission_status)      def test_auto_set_and_reload():      task = Task(config_id=\"name_1\", properties={}, function=print, id=TaskId(\"task_1\"))      submission_1 = Submission(task.id)      job_1 = Job(\"job_1\", task, submission_1.id, submission_1.entity_id)      job_2 = Job(\"job_2\", task, submission_1.id, submission_1.entity_id)        _TaskManagerFactory._build_manager()._set(task)      _SubmissionManagerFactory._build_manager()._set(submission_1)      _JobManagerFactory._build_manager()._set(job_1)      _JobManagerFactory._build_manager()._set(job_2)        submission_2 = _SubmissionManagerFactory._build_manager()._get(submission_1)        assert submission_1.id == submission_2.id      assert submission_1.entity_id == submission_2.entity_id      assert submission_1.creation_date == submission_2.creation_date      assert submission_1.submission_status == submission_2.submission_status        # auto set & reload on jobs attribute      assert submission_1.jobs == []      assert submission_2.jobs == []      submission_1.jobs = [job_1]      assert submission_1.jobs == [job_1]      assert submission_2.jobs == [job_1]      submission_2.jobs = [job_2]      assert submission_1.jobs == [job_2]      assert submission_2.jobs == [job_2]      submission_1.jobs = [job_1, job_2]      assert submission_1.jobs == [job_1, job_2]      assert submission_2.jobs == [job_1, job_2]      submission_2.jobs = [job_2, job_1]      assert submission_1.jobs == [job_2, job_1]      assert submission_2.jobs == [job_2, job_1]        # auto set & reload on submission_status attribute      assert submission_1.submission_status == SubmissionStatus.SUBMITTED      assert submission_2.submission_status == SubmissionStatus.SUBMITTED      submission_1.submission_status = SubmissionStatus.BLOCKED      assert submission_1.submission_status == SubmissionStatus.BLOCKED      assert submission_2.submission_status == SubmissionStatus.BLOCKED      submission_2.submission_status = SubmissionStatus.COMPLETED      assert submission_1.submission_status == SubmissionStatus.COMPLETED      assert submission_2.submission_status == SubmissionStatus.COMPLETED        with submission_1 as submission:          assert submission.jobs == [job_2, job_1]          assert submission.submission_status == SubmissionStatus.COMPLETED            submission.jobs = [job_1]          submission.submission_status = SubmissionStatus.PENDING            assert submission.jobs == [job_2, job_1]          assert submission.submission_status == SubmissionStatus.COMPLETED        assert submission_1.jobs == [job_1]      assert submission_1.submission_status == SubmissionStatus.PENDING      assert submission_2.jobs == [job_1]      assert submission_2.submission_status == SubmissionStatus.PENDING "}
{"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": "import pathlib  import shutil  from datetime import datetime  from typing import Any, Callable, Dict, List, Optional, Set, Union, overload    from taipy.config.common.scope import Scope  from taipy.logger._taipy_logger import _TaipyLogger    from ._entity._entity import _Entity  from ._version._version_manager_factory import _VersionManagerFactory  from .common._warnings import _warn_no_core_service  from .config.data_node_config import DataNodeConfig  from .config.scenario_config import ScenarioConfig  from .cycle._cycle_manager_factory import _CycleManagerFactory  from .cycle.cycle import Cycle  from .cycle.cycle_id import CycleId  from .data._data_manager_factory import _DataManagerFactory  from .data.data_node import DataNode  from .data.data_node_id import DataNodeId  from .exceptions.exceptions import (      DataNodeConfigIsNotGlobal,      ModelNotFound,      NonExistingVersion,      VersionIsNotProductionVersion,  )  from .job._job_manager_factory import _JobManagerFactory  from .job.job import Job  from .job.job_id import JobId  from .scenario._scenario_manager_factory import _ScenarioManagerFactory  from .scenario.scenario import Scenario  from .scenario.scenario_id import ScenarioId  from .sequence._sequence_manager_factory import _SequenceManagerFactory  from .sequence.sequence import Sequence  from .sequence.sequence_id import SequenceId  from .submission._submission_manager_factory import _SubmissionManagerFactory  from .submission.submission import Submission  from .task._task_manager_factory import _TaskManagerFactory  from .task.task import Task  from .task.task_id import TaskId    __logger = _TaipyLogger._get_logger()      def set(entity: Union[DataNode, Task, Sequence, Scenario, Cycle]):      \"\"\"Save or update an entity.        This function allows you to save or update an entity in Taipy.        Parameters:          entity (Union[DataNode^, Task^, Sequence^, Scenario^, Cycle^]): The              entity to save or update.      \"\"\"      if isinstance(entity, Cycle):          return _CycleManagerFactory._build_manager()._set(entity)      if isinstance(entity, Scenario):          return _ScenarioManagerFactory._build_manager()._set(entity)      if isinstance(entity, Sequence):          return _SequenceManagerFactory._build_manager()._set(entity)      if isinstance(entity, Task):          return _TaskManagerFactory._build_manager()._set(entity)      if isinstance(entity, DataNode):          return _DataManagerFactory._build_manager()._set(entity)      def is_submittable(entity: Union[Scenario, ScenarioId, Sequence, SequenceId, Task, TaskId]) -> bool:      \"\"\"Indicate if an entity can be submitted.        This function checks if the given entity can be submitted for execution.        Returns:          True if the given entity can be submitted. False otherwise.      \"\"\"      if isinstance(entity, Scenario) or (isinstance(entity, str) and entity.startswith(Scenario._ID_PREFIX)):          return _ScenarioManagerFactory._build_manager()._is_submittable(entity)  # type: ignore      if isinstance(entity, Sequence) or (isinstance(entity, str) and entity.startswith(Sequence._ID_PREFIX)):          return _SequenceManagerFactory._build_manager()._is_submittable(entity)  # type: ignore      if isinstance(entity, Task) or (isinstance(entity, str) and entity.startswith(Task._ID_PREFIX)):          return _TaskManagerFactory._build_manager()._is_submittable(entity)  # type: ignore      return False      def is_editable(      entity: Union[          DataNode, Task, Job, Sequence, Scenario, Cycle, DataNodeId, TaskId, JobId, SequenceId, ScenarioId, CycleId      ]  ) -> bool:      \"\"\"Indicate if an entity can be edited.        This function checks if the given entity can be edited.        Returns:          True if the given entity can be edited. False otherwise.      \"\"\"      if isinstance(entity, Cycle) or (isinstance(entity, str) and entity.startswith(Cycle._ID_PREFIX)):          return _CycleManagerFactory._build_manager()._is_editable(entity)  # type: ignore      if isinstance(entity, Scenario) or (isinstance(entity, str) and entity.startswith(Scenario._ID_PREFIX)):          return _ScenarioManagerFactory._build_manager()._is_editable(entity)  # type: ignore      if isinstance(entity, Sequence) or (isinstance(entity, str) and entity.startswith(Sequence._ID_PREFIX)):          return _SequenceManagerFactory._build_manager()._is_editable(entity)  # type: ignore      if isinstance(entity, Task) or (isinstance(entity, str) and entity.startswith(Task._ID_PREFIX)):          return _TaskManagerFactory._build_manager()._is_editable(entity)  # type: ignore      if isinstance(entity, Job) or (isinstance(entity, str) and entity.startswith(Job._ID_PREFIX)):          return _JobManagerFactory._build_manager()._is_editable(entity)  # type: ignore      if isinstance(entity, DataNode) or (isinstance(entity, str) and entity.startswith(DataNode._ID_PREFIX)):          return _DataManagerFactory._build_manager()._is_editable(entity)  # type: ignore      return False      def is_readable(      entity: Union[          DataNode, Task, Job, Sequence, Scenario, Cycle, DataNodeId, TaskId, JobId, SequenceId, ScenarioId, CycleId      ]  ) -> bool:      \"\"\"Indicate if an entity can be read.        This function checks if the given entity can be read.        Returns:          True if the given entity can be read. False otherwise.      \"\"\"      if isinstance(entity, Cycle) or (isinstance(entity, str) and entity.startswith(Cycle._ID_PREFIX)):          return _CycleManagerFactory._build_manager()._is_readable(entity)  # type: ignore      if isinstance(entity, Scenario) or (isinstance(entity, str) and entity.startswith(Scenario._ID_PREFIX)):          return _ScenarioManagerFactory._build_manager()._is_readable(entity)  # type: ignore      if isinstance(entity, Sequence) or (isinstance(entity, str) and entity.startswith(Sequence._ID_PREFIX)):          return _SequenceManagerFactory._build_manager()._is_readable(entity)  # type: ignore      if isinstance(entity, Task) or (isinstance(entity, str) and entity.startswith(Task._ID_PREFIX)):          return _TaskManagerFactory._build_manager()._is_readable(entity)  # type: ignore      if isinstance(entity, Job) or (isinstance(entity, str) and entity.startswith(Job._ID_PREFIX)):          return _JobManagerFactory._build_manager()._is_readable(entity)  # type: ignore      if isinstance(entity, DataNode) or (isinstance(entity, str) and entity.startswith(DataNode._ID_PREFIX)):          return _DataManagerFactory._build_manager()._is_readable(entity)  # type: ignore      return False      @_warn_no_core_service()  def submit(      entity: Union[Scenario, Sequence, Task],      force: bool = False,      wait: bool = False,      timeout: Optional[Union[float, int]] = None,  ) -> Union[Job, List[Job]]:      \"\"\"Submit a scenario, sequence or task entity for execution.        This function submits the given entity for execution and returns the created job(s).        If the entity is a sequence or a scenario, all the tasks of the entity are      submitted for execution.        Parameters:          entity (Union[Scenario^, Sequence^, Task^]): The scenario, sequence or task to submit.          force (bool): If True, the execution is forced even if for skippable tasks.          wait (bool): Wait for the orchestrated jobs created from the submission to be finished              in asynchronous mode.          timeout (Union[float, int]): The optional maximum number of seconds to wait              for the jobs to be finished before returning.        Returns:          The created `Job^` or a collection of the created `Job^` depends on the submitted entity.                - If a `Scenario^` or a `Sequence^` is provided, it will return a list of `Job^`.              - If a `Task^` is provided, it will return the created `Job^`.      \"\"\"      if isinstance(entity, Scenario):          return _ScenarioManagerFactory._build_manager()._submit(entity, force=force, wait=wait, timeout=timeout)      if isinstance(entity, Sequence):          return _SequenceManagerFactory._build_manager()._submit(entity, force=force, wait=wait, timeout=timeout)      if isinstance(entity, Task):          return _TaskManagerFactory._build_manager()._submit(entity, force=force, wait=wait, timeout=timeout)      @overload  def exists(entity_id: TaskId) -> bool:      ...      @overload  def exists(entity_id: DataNodeId) -> bool:      ...      @overload  def exists(entity_id: SequenceId) -> bool:      ...      @overload  def exists(entity_id: ScenarioId) -> bool:      ...      @overload  def exists(entity_id: CycleId) -> bool:      ...      @overload  def exists(entity_id: JobId) -> bool:      ...      @overload  def exists(entity_id: str) -> bool:      ...      def exists(entity_id: Union[TaskId, DataNodeId, SequenceId, ScenarioId, JobId, CycleId, str]) -> bool:      \"\"\"Check if an entity with the specified identifier exists.        This function checks if an entity with the given identifier exists.      It supports various types of entity identifiers, including `TaskId^`,      `DataNodeId^`, `SequenceId^`, `ScenarioId^`, `JobId^`, `CycleId^`, and string      representations.        Parameters:          entity_id (Union[DataNodeId^, TaskId^, SequenceId^, ScenarioId^, JobId^, CycleId^]): The              identifier of the entity to check for existence.        Returns:          True if the given entity exists. False otherwise.        Raises:          ModelNotFound: If the entity's type cannot be determined.        Note:          The function performs checks for various entity types          (`Job^`, `Cycle^`, `Scenario^`, `Sequence^`, `Task^`, `DataNode^`)          based on their respective identifier prefixes.      \"\"\"      if entity_id.startswith(Job._ID_PREFIX):          return _JobManagerFactory._build_manager()._exists(JobId(entity_id))      if entity_id.startswith(Cycle._ID_PREFIX):          return _CycleManagerFactory._build_manager()._exists(CycleId(entity_id))      if entity_id.startswith(Scenario._ID_PREFIX):          return _ScenarioManagerFactory._build_manager()._exists(ScenarioId(entity_id))      if entity_id.startswith(Sequence._ID_PREFIX):          return _SequenceManagerFactory._build_manager()._exists(SequenceId(entity_id))      if entity_id.startswith(Task._ID_PREFIX):          return _TaskManagerFactory._build_manager()._exists(TaskId(entity_id))      if entity_id.startswith(DataNode._ID_PREFIX):          return _DataManagerFactory._build_manager()._exists(DataNodeId(entity_id))      raise ModelNotFound(\"NOT_DETERMINED\", entity_id)      @overload  def get(entity_id: TaskId) -> Task:      ...      @overload  def get(entity_id: DataNodeId) -> DataNode:      ...      @overload  def get(entity_id: SequenceId) -> Sequence:      ...      @overload  def get(entity_id: ScenarioId) -> Scenario:      ...      @overload  def get(entity_id: CycleId) -> Cycle:      ...      @overload  def get(entity_id: JobId) -> Job:      ...      @overload  def get(entity_id: str) -> Union[Task, DataNode, Sequence, Scenario, Job, Cycle]:      ...      def get(      entity_id: Union[TaskId, DataNodeId, SequenceId, ScenarioId, JobId, CycleId, str]  ) -> Union[Task, DataNode, Sequence, Scenario, Job, Cycle]:      \"\"\"Retrieve an entity by its unique identifier.        This function allows you to retrieve an entity by specifying its identifier.      The identifier must match the pattern of one of the supported entity types:      Task^, DataNode^, Sequence^, Job^, Cycle^, or Scenario^.          Parameters:          entity_id (Union[TaskId, DataNodeId, SequenceId, ScenarioId, JobId, CycleId, str]):              The identifier of the entity to retrieve.<br/>              It should conform to the identifier pattern of one of the entities (`Task^`, `DataNode^`,              `Sequence^`, `Job^`, `Cycle^` or `Scenario^`).        Returns:          The entity that corresponds to the provided identifier. Returns None if no matching entity is found.        Raises:          ModelNotFound^: If the provided *entity_id* does not match any known entity pattern.      \"\"\"      if entity_id.startswith(Job._ID_PREFIX):          return _JobManagerFactory._build_manager()._get(JobId(entity_id))      if entity_id.startswith(Cycle._ID_PREFIX):          return _CycleManagerFactory._build_manager()._get(CycleId(entity_id))      if entity_id.startswith(Scenario._ID_PREFIX):          return _ScenarioManagerFactory._build_manager()._get(ScenarioId(entity_id))      if entity_id.startswith(Sequence._ID_PREFIX):          return _SequenceManagerFactory._build_manager()._get(SequenceId(entity_id))      if entity_id.startswith(Task._ID_PREFIX):          return _TaskManagerFactory._build_manager()._get(TaskId(entity_id))      if entity_id.startswith(DataNode._ID_PREFIX):          return _DataManagerFactory._build_manager()._get(DataNodeId(entity_id))      raise ModelNotFound(\"NOT_DETERMINED\", entity_id)      def get_tasks() -> List[Task]:      \"\"\"Retrieve a list of all existing tasks.        This function returns a list of all tasks that currently exist.        Returns:          A list containing all the tasks.      \"\"\"      return _TaskManagerFactory._build_manager()._get_all()      def is_deletable(entity: Union[Scenario, Job, ScenarioId, JobId]) -> bool:      \"\"\"Check if a `Scenario^` or a `Job^` can be deleted.        This function determines whether a scenario or a job can be safely      deleted without causing conflicts or issues.        Parameters:          entity (Union[Scenario, Job, ScenarioId, JobId]): The scenario or job to check.        Returns:          True if the given scenario or job can be deleted. False otherwise.      \"\"\"      if isinstance(entity, str) and entity.startswith(Job._ID_PREFIX) or isinstance(entity, Job):          return _JobManagerFactory._build_manager()._is_deletable(entity)  # type: ignore      if isinstance(entity, str) and entity.startswith(Scenario._ID_PREFIX) or isinstance(entity, Scenario):          return _ScenarioManagerFactory._build_manager()._is_deletable(entity)  # type: ignore      return True      def delete(entity_id: Union[TaskId, DataNodeId, SequenceId, ScenarioId, JobId, CycleId]):      \"\"\"Delete an entity and its nested entities.        This function deletes the specified entity and recursively deletes all its nested entities.      The behavior varies depending on the type of entity provided:        - If a `CycleId` is provided, the nested scenarios, tasks, data nodes, and jobs are deleted.      - If a `ScenarioId` is provided, the nested tasks, data nodes, and jobs are deleted.        If the scenario is primary, it can only be deleted if it is the only scenario in the cycle.        In that case, its cycle is also deleted. Use the `is_deletable()^` function to check if        the scenario can be deleted.      - If a `SequenceId` is provided, the related jobs are deleted.      - If a `TaskId` is provided, the related data nodes, and jobs are deleted.        Parameters:          entity_id (Union[TaskId, DataNodeId, SequenceId, ScenarioId, JobId, CycleId]):              The identifier of the entity to delete.        Raises:          ModelNotFound: No entity corresponds to the specified *entity_id*.      \"\"\"      if entity_id.startswith(Job._ID_PREFIX):          job_manager = _JobManagerFactory._build_manager()          return job_manager._delete(job_manager._get(JobId(entity_id)))  # type: ignore      if entity_id.startswith(Cycle._ID_PREFIX):          return _CycleManagerFactory._build_manager()._hard_delete(CycleId(entity_id))      if entity_id.startswith(Scenario._ID_PREFIX):          return _ScenarioManagerFactory._build_manager()._hard_delete(ScenarioId(entity_id))      if entity_id.startswith(Sequence._ID_PREFIX):          return _SequenceManagerFactory._build_manager()._hard_delete(SequenceId(entity_id))      if entity_id.startswith(Task._ID_PREFIX):          return _TaskManagerFactory._build_manager()._hard_delete(TaskId(entity_id))      if entity_id.startswith(DataNode._ID_PREFIX):          return _DataManagerFactory._build_manager()._delete(DataNodeId(entity_id))      raise ModelNotFound(\"NOT_DETERMINED\", entity_id)      def get_scenarios(cycle: Optional[Cycle] = None, tag: Optional[str] = None) -> List[Scenario]:      \"\"\"Retrieve a list of existing scenarios filtered by cycle or tag.        This function allows you to retrieve a list of scenarios based on optional      filtering criteria. If both a _cycle_ and a _tag_ are provided, the returned      list contains scenarios that belong to the specified _cycle_ **and** also      have the specified _tag_.        Parameters:           cycle (Optional[Cycle^]): The optional `Cycle^` to filter scenarios by.           tag (Optional[str]): The optional tag to filter scenarios by.        Returns:          The list of scenarios filtered by cycle or tag. If no filtering criteria              are provided, this method returns all existing scenarios.      \"\"\"      if not cycle and not tag:          return _ScenarioManagerFactory._build_manager()._get_all()      if cycle and not tag:          return _ScenarioManagerFactory._build_manager()._get_all_by_cycle(cycle)      if not cycle and tag:          return _ScenarioManagerFactory._build_manager()._get_all_by_tag(tag)      if cycle and tag:          cycles_scenarios = _ScenarioManagerFactory._build_manager()()._get_all_by_cycle(cycle)          return [scenario for scenario in cycles_scenarios if scenario.has_tag(tag)]      return []      def get_primary(cycle: Cycle) -> Optional[Scenario]:      \"\"\"Retrieve the primary scenario associated with a cycle.        Parameters:          cycle (Cycle^): The cycle for which to retrieve the primary scenario.        Returns:          The primary scenario of the given _cycle_. If the cycle has no              primary scenario, this method returns None.      \"\"\"      return _ScenarioManagerFactory._build_manager()._get_primary(cycle)      def get_primary_scenarios() -> List[Scenario]:      \"\"\"Retrieve a list of all primary scenarios.        Returns:          A list containing all primary scenarios.      \"\"\"      return _ScenarioManagerFactory._build_manager()._get_primary_scenarios()      def is_promotable(scenario: Union[Scenario, ScenarioId]) -> bool:      \"\"\"Determine if a scenario can be promoted to become a primary scenario.        This function checks whether the given scenario is eligible to be promoted      as a primary scenario.        Parameters:          scenario (Union[Scenario, ScenarioId]): The scenario to be evaluated for promotability.        Returns:          True if the given scenario can be promoted to be a primary scenario. False otherwise.      \"\"\"      return _ScenarioManagerFactory._build_manager()._is_promotable_to_primary(scenario)      def set_primary(scenario: Scenario):      \"\"\"Promote a scenario as the primary scenario of its cycle.        This function promotes the given scenario as the primary scenario of its associated cycle.      If the cycle already has a primary scenario, that scenario is demoted and is      no longer considered the primary scenario for its cycle.        Parameters:          scenario (Scenario^): The scenario to promote as the new _primary_ scenario.      \"\"\"      return _ScenarioManagerFactory._build_manager()._set_primary(scenario)      def tag(scenario: Scenario, tag: str):      \"\"\"Add a tag to a scenario.        This function adds a user-defined tag to the specified scenario. If another scenario      within the same cycle already has the same tag applied, the previous scenario is untagged.        Parameters:          scenario (Scenario^): The scenario to which the tag will be added.          tag (str): The tag to apply to the scenario.      \"\"\"      return _ScenarioManagerFactory._build_manager()._tag(scenario, tag)      def untag(scenario: Scenario, tag: str):      \"\"\"Remove a tag from a scenario.        This function removes a specified tag from the given scenario. If the scenario does      not have the specified tag, it has no effect.        Parameters:          scenario (Scenario^): The scenario from which the tag will be removed.          tag (str): The tag to remove from the scenario.      \"\"\"      return _ScenarioManagerFactory._build_manager()._untag(scenario, tag)      def compare_scenarios(*scenarios: Scenario, data_node_config_id: Optional[str] = None) -> Dict[str, Any]:      \"\"\"Compare the data nodes of several scenarios.        You can specify which data node config identifier should the comparison be performed      on.        Parameters:          *scenarios (*Scenario^): The list of the scenarios to compare.          data_node_config_id (Optional[str]): The config identifier of the DataNode to perform              the comparison on. <br/>                If _data_node_config_id_ is not provided, the scenarios are              compared on all defined comparators.<br/>        Returns:          The comparison results. The key is the data node config identifier used for          comparison.        Raises:          InsufficientScenarioToCompare^: Raised when only one or no scenario for comparison              is provided.          NonExistingComparator^: Raised when the scenario comparator does not exist.          DifferentScenarioConfigs^: Raised when the provided scenarios do not share the              same scenario config.          NonExistingScenarioConfig^: Raised when the scenario config of the provided              scenarios could not be found.      \"\"\"      return _ScenarioManagerFactory._build_manager()._compare(*scenarios, data_node_config_id=data_node_config_id)      def subscribe_scenario(      callback: Callable[[Scenario, Job], None],      params: Optional[List[Any]] = None,      scenario: Optional[Scenario] = None,  ):      \"\"\"Subscribe a function to be called on job status change.        The subscription is applied to all jobs created for the execution of _scenario_.      If no scenario is provided, the subscription applies to all scenarios.        Parameters:          callback (Callable[[Scenario^, Job^], None]): The function to be called on              status change.          params (Optional[List[Any]]): The parameters to be passed to the _callback_.          scenario (Optional[Scenario^]): The scenario to which the callback is applied.              If None, the subscription is registered for all scenarios.        Note:          Notifications are applied only for jobs created **after** this subscription.      \"\"\"      params = [] if params is None else params      return _ScenarioManagerFactory._build_manager()._subscribe(callback, params, scenario)      def unsubscribe_scenario(      callback: Callable[[Scenario, Job], None], params: Optional[List[Any]] = None, scenario: Optional[Scenario] = None  ):      \"\"\"Unsubscribe a function that is called when the status of a `Job^` changes.        If no scenario is provided, the subscription is removed for all scenarios.        Parameters:          callback (Callable[[Scenario^, Job^], None]): The function to unsubscribe from.          params (Optional[List[Any]]): The parameters to be passed to the callback.          scenario (Optional[Scenario]): The scenario to unsubscribe from. If None, it              applies to all scenarios.        Note:          The callback function will continue to be called for ongoing jobs.      \"\"\"      return _ScenarioManagerFactory._build_manager()._unsubscribe(callback, params, scenario)      def subscribe_sequence(      callback: Callable[[Sequence, Job], None], params: Optional[List[Any]] = None, sequence: Optional[Sequence] = None  ):      \"\"\"Subscribe a function to be called on job status change.        The subscription is applied to all jobs created for the execution of _sequence_.        Parameters:          callback (Callable[[Sequence^, Job^], None]): The callable function to be called on              status change.          params (Optional[List[Any]]): The parameters to be passed to the _callback_.          sequence (Optional[Sequence^]): The sequence to subscribe on. If None, the subscription              is applied to all sequences.        Note:          Notifications are applied only for jobs created **after** this subscription.      \"\"\"      return _SequenceManagerFactory._build_manager()._subscribe(callback, params, sequence)      def unsubscribe_sequence(      callback: Callable[[Sequence, Job], None], params: Optional[List[Any]] = None, sequence: Optional[Sequence] = None  ):      \"\"\"Unsubscribe a function that is called when the status of a Job changes.        Parameters:          callback (Callable[[Sequence^, Job^], None]): The callable function to be called on              status change.          params (Optional[List[Any]]): The parameters to be passed to the _callback_.          sequence (Optional[Sequence^]): The sequence to unsubscribe to. If None, it applies              to all sequences.        Note:          The function will continue to be called for ongoing jobs.      \"\"\"      return _SequenceManagerFactory._build_manager()._unsubscribe(callback, params, sequence)      def get_sequences() -> List[Sequence]:      \"\"\"Return all existing sequences.        Returns:          The list of all sequences.      \"\"\"      return _SequenceManagerFactory._build_manager()._get_all()      def get_jobs() -> List[Job]:      \"\"\"Return all the existing jobs.        Returns:          The list of all jobs.      \"\"\"      return _JobManagerFactory._build_manager()._get_all()      def delete_job(job: Job, force=False):      \"\"\"Delete a job.        This function deletes the specified job. If the job is not completed and      *force* is not set to True, a `JobNotDeletedException^` may be raised.        Parameters:          job (Job^): The job to delete.          force (Optional[bool]): If True, forces the deletion of _job_, even              if it is not completed yet.      Raises:          JobNotDeletedException^: If the job is not finished.      \"\"\"      return _JobManagerFactory._build_manager()._delete(job, force)      def delete_jobs():      \"\"\"Delete all jobs.\"\"\"      return _JobManagerFactory._build_manager()._delete_all()      def cancel_job(job: Union[str, Job]):      \"\"\"Cancel a job and set the status of the subsequent jobs to ABANDONED.        This function cancels the specified job and sets the status of any subsequent jobs to ABANDONED.        Parameters:          job (Job^): The job to cancel.      \"\"\"      _JobManagerFactory._build_manager()._cancel(job)      def get_latest_job(task: Task) -> Optional[Job]:      \"\"\"Return the latest job of a task.        This function retrieves the latest job associated with a task.        Parameters:          task (Task^): The task to retrieve the latest job from.      Returns:          The latest job created from _task_, or None if no job has been created from _task_.      \"\"\"      return _JobManagerFactory._build_manager()._get_latest(task)      def get_latest_submission(entity: Union[Scenario, Sequence, Task]) -> Optional[Submission]:      \"\"\"Return the latest submission of a scenario, sequence or task.        This function retrieves the latest submission associated with a scenario, sequence or task.        Parameters:          entity (Union[Scenario^, Sequence^, Task^]): The scenario, sequence or task to          retrieve the latest submission from.      Returns:          The latest submission created from _scenario_, _sequence_ and _task_, or None          if no submission has been created from _scenario_, _sequence_ and _task_.      \"\"\"      return _SubmissionManagerFactory._build_manager()._get_latest(entity)      def get_data_nodes() -> List[DataNode]:      \"\"\"Return all the existing data nodes.        Returns:          The list of all data nodes.      \"\"\"      return _DataManagerFactory._build_manager()._get_all()      def get_cycles() -> List[Cycle]:      \"\"\"Return the list of all existing cycles.        Returns:          The list of all cycles.      \"\"\"      return _CycleManagerFactory._build_manager()._get_all()      def create_scenario(      config: ScenarioConfig,      creation_date: Optional[datetime] = None,      name: Optional[str] = None,  ) -> Scenario:      \"\"\"Create and return a new scenario based on a scenario configuration.        If the scenario belongs to a cycle, a cycle (corresponding to the _creation_date_      and the configuration frequency attribute) is created if it does not exist yet.        Parameters:          config (ScenarioConfig^): The scenario configuration used to create a new scenario.          creation_date (Optional[datetime.datetime]): The creation date of the scenario.              If None, the current date time is used.          name (Optional[str]): The displayable name of the scenario.      Returns:          The new scenario.      \"\"\"      return _ScenarioManagerFactory._build_manager()._create(config, creation_date, name)      def create_global_data_node(config: DataNodeConfig) -> DataNode:      \"\"\"Create and return a new GLOBAL data node from a data node configuration.        Parameters:          config (DataNodeConfig^): The data node configuration. It must have a `GLOBAL` scope.        Returns:          The new global data node.        Raises:          DataNodeConfigIsNotGlobal^: If the data node configuration does not have GLOBAL scope.      \"\"\"      # Check if the data node config has GLOBAL scope      if config.scope is not Scope.GLOBAL:          raise DataNodeConfigIsNotGlobal(config.id)  # type: ignore        if dns := _DataManagerFactory._build_manager()._get_by_config_id(config.id):  # type: ignore          return dns[0]      return _DataManagerFactory._build_manager()._create_and_set(config, None, None)      def clean_all_entities_by_version(version_number=None) -> bool:      \"\"\"Delete all entities of a specific version.        This function deletes all entities associated with the specified version.        Parameters:          version_number (optional[str]): The version number of the entities to be deleted.              If None, the default behavior may apply.        Returns:          True if the operation succeeded, False otherwise.        Notes:          - If the specified version does not exist, the operation will be aborted, and False will be returned.          - This function cleans all entities, including jobs, scenarios, sequences, tasks, and data nodes.          - The production version of the specified version is also deleted if it exists.      \"\"\"      version_manager = _VersionManagerFactory._build_manager()      try:          version_number = version_manager._replace_version_number(version_number)      except NonExistingVersion as e:          __logger.warning(f\"{e.message} Abort cleaning the entities of version '{version_number}'.\")          return False        _JobManagerFactory._build_manager()._delete_by_version(version_number)      _ScenarioManagerFactory._build_manager()._delete_by_version(version_number)      _SequenceManagerFactory._build_manager()._delete_by_version(version_number)      _TaskManagerFactory._build_manager()._delete_by_version(version_number)      _DataManagerFactory._build_manager()._delete_by_version(version_number)        version_manager._delete(version_number)      try:          version_manager._delete_production_version(version_number)      except VersionIsNotProductionVersion:          pass        return True      def export_scenario(      scenario_id: ScenarioId,      folder_path: Union[str, pathlib.Path],  ):      \"\"\"Export all related entities of a scenario to a folder.        This function exports all related entities of the specified scenario to the      specified folder.        Parameters:          scenario_id (ScenarioId): The ID of the scenario to export.          folder_path (Union[str, pathlib.Path]): The folder path to export the scenario to.      \"\"\"        manager = _ScenarioManagerFactory._build_manager()      scenario = manager._get(scenario_id)      entity_ids = manager._get_children_entity_ids(scenario)  # type: ignore      entity_ids.scenario_ids = {scenario_id}      entity_ids.cycle_ids = {scenario.cycle.id}        shutil.rmtree(folder_path, ignore_errors=True)        for data_node_id in entity_ids.data_node_ids:          _DataManagerFactory._build_manager()._export(data_node_id, folder_path)      for task_id in entity_ids.task_ids:          _TaskManagerFactory._build_manager()._export(task_id, folder_path)      for sequence_id in entity_ids.sequence_ids:          _SequenceManagerFactory._build_manager()._export(sequence_id, folder_path)      for cycle_id in entity_ids.cycle_ids:          _CycleManagerFactory._build_manager()._export(cycle_id, folder_path)      for scenario_id in entity_ids.scenario_ids:          _ScenarioManagerFactory._build_manager()._export(scenario_id, folder_path)      for job_id in entity_ids.job_ids:          _JobManagerFactory._build_manager()._export(job_id, folder_path)      def get_parents(      entity: Union[TaskId, DataNodeId, SequenceId, Task, DataNode, Sequence], parent_dict=None  ) -> Dict[str, Set[_Entity]]:      \"\"\"Get the parents of an entity from itself or its identifier.        Parameters:          entity (Union[TaskId, DataNodeId, SequenceId, Task, DataNode, Sequence]): The entity or its              identifier to get the parents.        Returns:          The dictionary of all parent entities.              They are grouped by their type (Scenario^, Sequences^, or tasks^) so each key corresponds              to a level of the parents and the value is a set of the parent entities.              An empty dictionary is returned if the entity does not have parents.<br/>              Example: The following instruction returns all the scenarios that include the              datanode identified by \"my_datanode_id\".              `taipy.get_parents(\"id_of_my_datanode\")[\"scenario\"]`        Raises:          ModelNotFound^: If _entity_ does not match a correct entity pattern.      \"\"\"        def update_parent_dict(parents_set, parent_dict):          for k, value in parents_set.items():              if k in parent_dict.keys():                  parent_dict[k].update(value)              else:                  parent_dict[k] = value        if isinstance(entity, str):          entity = get(entity)  # type: ignore        parent_dict = parent_dict or dict()        if isinstance(entity, (Scenario, Cycle)):          return parent_dict        current_parent_dict: Dict[str, Set] = {}      for parent in entity.parent_ids:          parent_entity = get(parent)          if parent_entity._MANAGER_NAME in current_parent_dict.keys():              current_parent_dict[parent_entity._MANAGER_NAME].add(parent_entity)          else:              current_parent_dict[parent_entity._MANAGER_NAME] = {parent_entity}        if isinstance(entity, Sequence):          update_parent_dict(current_parent_dict, parent_dict)        if isinstance(entity, Task):          parent_entity_key_to_search_next = \"scenario\"          update_parent_dict(current_parent_dict, parent_dict)          for parent in parent_dict.get(parent_entity_key_to_search_next, []):              get_parents(parent, parent_dict)        if isinstance(entity, DataNode):          parent_entity_key_to_search_next = \"task\"          update_parent_dict(current_parent_dict, parent_dict)          for parent in parent_dict.get(parent_entity_key_to_search_next, []):              get_parents(parent, parent_dict)        return parent_dict      def get_cycles_scenarios() -> Dict[Optional[Cycle], List[Scenario]]:      \"\"\"Get the scenarios grouped by cycles.        Returns:          The dictionary of all cycles and their corresponding scenarios.      \"\"\"        cycles_scenarios: Dict[Optional[Cycle], List[Scenario]] = {}      for scenario in get_scenarios():          if scenario.cycle in cycles_scenarios.keys():              cycles_scenarios[scenario.cycle].append(scenario)          else:              cycles_scenarios[scenario.cycle] = [scenario]      return cycles_scenarios      def get_entities_by_config_id(      config_id: str,  ) -> Union[List, List[Task], List[DataNode], List[Sequence], List[Scenario]]:      \"\"\"Get the entities by its config id.        Parameters:          config_id (str): The config id of the entities        Returns:          The list of all entities by the config id.      \"\"\"        entities: List = []        if entities := _ScenarioManagerFactory._build_manager()._get_by_config_id(config_id):          return entities      if entities := _TaskManagerFactory._build_manager()._get_by_config_id(config_id):          return entities      if entities := _DataManagerFactory._build_manager()._get_by_config_id(config_id):          return entities      return entities "}
{"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 copy  import json  import pathlib  import shutil  from typing import Any, Dict, Iterable, Iterator, List, Optional, Type, Union    from taipy.config.config import Config    from ..common._utils import _retry_read_entity  from ..common.typing import Converter, Entity, Json, ModelType  from ..exceptions import FileCannotBeRead, InvalidExportPath, ModelNotFound  from ._abstract_repository import _AbstractRepository  from ._decoder import _Decoder  from ._encoder import _Encoder      class _FileSystemRepository(_AbstractRepository[ModelType, Entity]):      \"\"\"      Holds common methods to be used and extended when the need for saving      dataclasses as JSON files in local storage emerges.        Some lines have type: ignore because MyPy won't recognize some generic attributes. This      should be revised in the future.        Attributes:          model_type (ModelType): Generic dataclass.          converter: A class that handles conversion to and from a database backend          dir_name (str): Folder that will hold the files for this dataclass model.      \"\"\"        __EXCEPTIONS_TO_RETRY = (FileCannotBeRead,)        def __init__(self, model_type: Type[ModelType], converter: Type[Converter], dir_name: str):          self.model_type = model_type          self.converter = converter          self._dir_name = dir_name        @property      def dir_path(self):          return self._storage_folder / self._dir_name        @property      def _storage_folder(self) -> pathlib.Path:          return pathlib.Path(Config.core.storage_folder)        ###############################      # ##   Inherited methods   ## #      ###############################        def _save(self, entity: Entity):          self.__create_directory_if_not_exists()          model = self.converter._entity_to_model(entity)  # type: ignore          self.__get_path(model.id).write_text(              json.dumps(model.to_dict(), ensure_ascii=False, indent=0, cls=_Encoder, check_circular=False),              encoding=\"UTF-8\",          )        def _exists(self, entity_id: str) -> bool:          return self.__get_path(entity_id).exists()        def _load(self, entity_id: str) -> Entity:          path = pathlib.Path(self.__get_path(entity_id))            try:              file_content = self.__read_file(path)          except (FileNotFoundError, FileCannotBeRead):              raise ModelNotFound(str(self.dir_path), entity_id)            return self.__file_content_to_entity(file_content)        def _load_all(self, filters: Optional[List[Dict]] = None) -> List[Entity]:          entities = []          try:              for f in self.dir_path.iterdir():                  if data := self.__filter_by(f, filters):                      entities.append(self.__file_content_to_entity(data))          except FileNotFoundError:              pass          return entities        def _delete(self, entity_id: str):          try:              self.__get_path(entity_id).unlink()          except FileNotFoundError:              raise ModelNotFound(str(self.dir_path), entity_id)        def _delete_all(self):          shutil.rmtree(self.dir_path, ignore_errors=True)        def _delete_many(self, ids: Iterable[str]):          for model_id in ids:              self._delete(model_id)        def _delete_by(self, attribute: str, value: str):          filters: List[Dict] = [{}]          for fil in filters:              fil.update({attribute: value})            try:              for f in self.dir_path.iterdir():                  if self.__filter_by(f, filters):                      f.unlink()          except FileNotFoundError:              pass        def _search(self, attribute: str, value: Any, filters: Optional[List[Dict]] = None) -> List[Entity]:          return list(self.__search(attribute, value, filters))        def _export(self, entity_id: str, folder_path: Union[str, pathlib.Path]):          if isinstance(folder_path, str):              folder: pathlib.Path = pathlib.Path(folder_path)          else:              folder = folder_path            if folder.resolve() == self._storage_folder.resolve():              raise InvalidExportPath(\"The export folder must not be the storage folder.\")            export_dir = folder / self._dir_name          if not export_dir.exists():              export_dir.mkdir(parents=True)            export_path = export_dir / f\"{entity_id}.json\"          # Delete if exists.          if export_path.exists():              export_path.unlink()            shutil.copy2(self.__get_path(entity_id), export_path)        ###########################################      # ##   Specific or optimized methods   ## #      ###########################################      def _get_by_configs_and_owner_ids(self, configs_and_owner_ids, filters: Optional[List[Dict]] = None):          # Design in order to optimize performance on Entity creation.          # Maintainability and readability were impacted.          if not filters:              filters = [{}]          res = {}          configs_and_owner_ids = set(configs_and_owner_ids)            try:              for f in self.dir_path.iterdir():                  config_id, owner_id, entity = self.__match_file_and_get_entity(                      f, configs_and_owner_ids, copy.deepcopy(filters)                  )                    if entity:                      key = config_id, owner_id                      res[key] = entity                      configs_and_owner_ids.remove(key)                        if len(configs_and_owner_ids) == 0:                          return res          except FileNotFoundError:              # Folder with data was not created yet.              return {}            return res        def _get_by_config_and_owner_id(          self, config_id: str, owner_id: Optional[str], filters: Optional[List[Dict]] = None      ) -> Optional[Entity]:          if not filters:              filters = [{}]          else:              filters = copy.deepcopy(filters)            if owner_id is not None:              for fil in filters:                  fil.update({\"owner_id\": owner_id})          return self.__filter_files_by_config_and_owner_id(config_id, owner_id, filters)        #############################      # ##   Private methods   ## #      #############################        def __filter_files_by_config_and_owner_id(          self, config_id: str, owner_id: Optional[str], filters: Optional[List[Dict]] = None      ):          try:              files = filter(lambda f: config_id in f.name, self.dir_path.iterdir())              entities = map(                  lambda f: self.__file_content_to_entity(self.__filter_by(f, filters)),                  files,              )              corresponding_entities = filter(                  lambda e: e is not None and e.config_id == config_id and e.owner_id == owner_id,  # type: ignore                  entities,              )              return next(corresponding_entities, None)  # type: ignore          except FileNotFoundError:              pass          return None        def __match_file_and_get_entity(self, filepath, config_and_owner_ids, filters):          if match := [(c, p) for c, p in config_and_owner_ids if c.id in filepath.name]:              for config, owner_id in match:                  for fil in filters:                      fil.update({\"config_id\": config.id, \"owner_id\": owner_id})                    if data := self.__filter_by(filepath, filters):                      return config, owner_id, self.__file_content_to_entity(data)            return None, None, None        def __create_directory_if_not_exists(self):          self.dir_path.mkdir(parents=True, exist_ok=True)        def __search(self, attribute: str, value: str, filters: Optional[List[Dict]] = None) -> Iterator[Entity]:          return filter(lambda e: getattr(e, attribute, None) == value, self._load_all(filters))        def __get_path(self, model_id) -> pathlib.Path:          return self.dir_path / f\"{model_id}.json\"        def __file_content_to_entity(self, file_content):          if not file_content:              return None          if isinstance(file_content, str):              file_content = json.loads(file_content, cls=_Decoder)          model = self.model_type.from_dict(file_content)          entity = self.converter._model_to_entity(model)          return entity        def __filter_by(self, filepath: pathlib.Path, filters: Optional[List[Dict]]) -> Optional[Json]:          if not filters:              filters = [{}]            try:              file_content = self.__read_file(filepath)          except (FileNotFoundError, FileCannotBeRead):              return None            for _filter in filters:              conditions = [                  f'\"{key}\": \"{value}\"' if value is not None else f'\"{key}\": null' for key, value in _filter.items()              ]              if all(condition in file_content for condition in conditions):                  return json.loads(file_content, cls=_Decoder)          return None        @_retry_read_entity(__EXCEPTIONS_TO_RETRY)      def __read_file(self, filepath: pathlib.Path) -> str:          if not filepath.is_file():              raise FileNotFoundError            try:              with filepath.open(\"r\", encoding=\"UTF-8\") as f:                  file_content = f.read()              return file_content          except Exception:              raise FileCannotBeRead(str(filepath)) "}
{"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": "import json  import pathlib  from typing import Any, Dict, Iterable, List, Optional, Type, Union    from sqlalchemy.dialects import sqlite  from sqlalchemy.exc import NoResultFound    from .._repository._abstract_repository import _AbstractRepository  from ..common.typing import Converter, Entity, ModelType  from ..exceptions import ModelNotFound  from .db._sql_connection import _SQLConnection      class _SQLRepository(_AbstractRepository[ModelType, Entity]):      def __init__(self, model_type: Type[ModelType], converter: Type[Converter]):          \"\"\"          Holds common methods to be used and extended when the need for saving          dataclasses in a SqlLite database.            Some lines have type: ignore because MyPy won't recognize some generic attributes. This          should be revised in the future.            Attributes:              model_type: Generic dataclass.              converter: A class that handles conversion to and from a database backend              db: An sqlite3 session object          \"\"\"          self.db = _SQLConnection.init_db()          self.model_type = model_type          self.converter = converter          self.table = self.model_type.__table__        ###############################      # ##   Inherited methods   ## #      ###############################      def _save(self, entity: Entity):          obj = self.converter._entity_to_model(entity)          if self._exists(entity.id):  # type: ignore              self._update_entry(obj)              return          self.__insert_model(obj)        def _exists(self, entity_id: str):          query = self.table.select().filter_by(id=entity_id)          return bool(self.db.execute(str(query), [entity_id]).fetchone())        def _load(self, entity_id: str) -> Entity:          query = self.table.select().filter_by(id=entity_id)            if entry := self.db.execute(str(query.compile(dialect=sqlite.dialect())), [entity_id]).fetchone():              entry = self.model_type.from_dict(entry)              return self.converter._model_to_entity(entry)          raise ModelNotFound(str(self.model_type.__name__), entity_id)        def _load_all(self, filters: Optional[List[Dict]] = None) -> List[Entity]:          query = self.table.select()          entities: List[Entity] = []            for f in filters or [{}]:              filtered_query = query.filter_by(**f)              try:                  entries = self.db.execute(                      str(filtered_query.compile(dialect=sqlite.dialect())),                      [self.__serialize_filter_values(val) for val in list(f.values())],                  ).fetchall()                    entities.extend([self.converter._model_to_entity(self.model_type.from_dict(m)) for m in entries])              except NoResultFound:                  continue          return entities        def _delete(self, entity_id: str):          delete_query = self.table.delete().filter_by(id=entity_id)          cursor = self.db.execute(str(delete_query.compile(dialect=sqlite.dialect())), [entity_id])            if cursor.rowcount == 0:              raise ModelNotFound(str(self.model_type.__name__), entity_id)            self.db.commit()        def _delete_all(self):          self.db.execute(str(self.table.delete().compile(dialect=sqlite.dialect())))          self.db.commit()        def _delete_many(self, ids: Iterable[str]):          for entity_id in ids:              self._delete(entity_id)        def _delete_by(self, attribute: str, value: str):          delete_by_query = self.table.delete().filter_by(**{attribute: value})            self.db.execute(str(delete_by_query.compile(dialect=sqlite.dialect())), [value])          self.db.commit()        def _search(self, attribute: str, value: Any, filters: Optional[List[Dict]] = None) -> List[Entity]:          query = self.table.select().filter_by(**{attribute: value})            entities: List[Entity] = []          for f in filters or [{}]:              entries = self.db.execute(                  str(query.filter_by(**f).compile(dialect=sqlite.dialect())),                  [value] + [self.__serialize_filter_values(val) for val in list(f.values())],              ).fetchall()              entities.extend([self.converter._model_to_entity(self.model_type.from_dict(m)) for m in entries])            return entities        def _export(self, entity_id: str, folder_path: Union[str, pathlib.Path]):          if isinstance(folder_path, str):              folder: pathlib.Path = pathlib.Path(folder_path)          else:              folder = folder_path            export_dir = folder / self.table.name          if not export_dir.exists():              export_dir.mkdir(parents=True)            export_path = export_dir / f\"{entity_id}.json\"            query = self.table.select().filter_by(id=entity_id)            if entry := self.db.execute(str(query.compile(dialect=sqlite.dialect())), [entity_id]).fetchone():              with open(export_path, \"w\", encoding=\"utf-8\") as export_file:                  export_file.write(json.dumps(entry))          else:              raise ModelNotFound(self.model_type, entity_id)  # type: ignore        ###########################################      # ##   Specific or optimized methods   ## #      ###########################################      def _get_multi(self, *, skip: int = 0, limit: int = 100) -> List[ModelType]:          query = self.table.select().offset(skip).limit(limit)          return self.db.execute(str(query.compile(dialect=sqlite.dialect()))).fetchall()        def _get_by_config(self, config_id: Any) -> Optional[ModelType]:          query = self.table.select().filter_by(config_id=config_id)          return self.db.execute(str(query.compile(dialect=sqlite.dialect())), [config_id]).fetchall()        def _get_by_config_and_owner_id(          self, config_id: str, owner_id: Optional[str], filters: Optional[List[Dict]] = None      ) -> Optional[Entity]:          if not filters:              filters = [{}]          if entry := self.__get_entities_by_config_and_owner(config_id, owner_id, filters):              return self.converter._model_to_entity(entry)          return None        def _get_by_configs_and_owner_ids(self, configs_and_owner_ids, filters: Optional[List[Dict]] = None):          # Design in order to optimize performance on Entity creation.          # Maintainability and readability were impacted.          if not filters:              filters = [{}]          res = {}          configs_and_owner_ids = set(configs_and_owner_ids)            for config, owner in configs_and_owner_ids:              entry = self.__get_entities_by_config_and_owner(config.id, owner, filters)              if entry:                  entity = self.converter._model_to_entity(entry)                  key = config, owner                  res[key] = entity            return res        def __get_entities_by_config_and_owner(          self, config_id: str, owner_id: Optional[str] = None, filters: Optional[List[Dict]] = None      ) -> Optional[ModelType]:          if not filters:              filters = []          versions = [item.get(\"version\") for item in filters if item.get(\"version\")]            query = self.table.select().filter_by(config_id=config_id)          parameters: List = [config_id]            if owner_id:              parameters.append(owner_id)          query = query.filter_by(owner_id=owner_id)          query = str(query.compile(dialect=sqlite.dialect()))            if versions:              table_name = self.table.name              query = query + f\" AND {table_name}.version IN ({','.join(['?']*len(versions))})\"              parameters.extend(versions)            if entry := self.db.execute(query, parameters).fetchone():              return self.model_type.from_dict(entry)          return None        #############################      # ##   Private methods   ## #      #############################      def __insert_model(self, model: ModelType):          query = self.table.insert()          self.db.execute(str(query.compile(dialect=sqlite.dialect())), model.to_list())          self.db.commit()        def _update_entry(self, model):          query = self.table.update().filter_by(id=model.id)          self.db.execute(str(query.compile(dialect=sqlite.dialect())), model.to_list() + [model.id])          self.db.commit()        @staticmethod      def __serialize_filter_values(value):          if isinstance(value, (dict, list)):              return json.dumps(value).replace('\"', \"'\")          return value "}
{"text": "#  # Licensed under the Apache License, Version 2.0 (the \"License\"); you may not use this file except in compliance with  # the License. You may obtain a copy of the License at  #  #        http://www.apache.org/licenses/LICENSE-2.0  #  # Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on  # an \"AS IS\" BASIS, WITHOUT 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": "import re  from copy import copy  from typing import Any, Dict, Optional, Union    from taipy.config import Config, UniqueSection  from taipy.config._config import _Config  from taipy.config.common._config_blocker import _ConfigBlocker  from taipy.config.common._template_handler import _TemplateHandler as _tpl    from .._init_version import _read_version  from ..exceptions.exceptions import ConfigCoreVersionMismatched      class CoreSection(UniqueSection):      \"\"\"      Configuration parameters for running the `Core^` service.        Attributes:          root_folder (str): Path of the base folder for the taipy application. The default value is \"./taipy/\"          storage_folder (str): Folder name used to store Taipy data. The default value is \".data/\". It is used in              conjunction with the *root_folder* attribute. That means the storage path is <root_folder><storage_folder>              (The default path is \"./taipy/.data/\").          repository_type (str): Type of the repository to be used to store Taipy data. The default value is              \"filesystem\".          repository_properties (Dict[str, Union[str, int]]): A dictionary of additional properties to be used by the              repository.          read_entity_retry (int): Number of retries to read an entity from the repository before return failure.              The default value is 3.          mode (str): The Taipy operating mode. By default, the `Core^` service runs in \"development\" mode.              An \"experiment\" and a \"production\" mode are also available. Please refer to the              [Versioning management](../core/versioning/index.md) documentation page for more details.          version_number (str)): The identifier of the user application version. Please refer to the              [Versioning management](../core/versioning/index.md) documentation page for more details.          force (bool): If True, force the application run even if there are some conflicts in the              configuration.          core_version (str): The Taipy Core package version.          **properties (dict[str, any]): A dictionary of additional properties.      \"\"\"        name = \"CORE\"        _ROOT_FOLDER_KEY = \"root_folder\"      _DEFAULT_ROOT_FOLDER = \"./taipy/\"        _STORAGE_FOLDER_KEY = \"storage_folder\"      _DEFAULT_STORAGE_FOLDER = \".data/\"        _REPOSITORY_TYPE_KEY = \"repository_type\"      _DEFAULT_REPOSITORY_TYPE = \"filesystem\"      _REPOSITORY_PROPERTIES_KEY = \"repository_properties\"      _DEFAULT_REPOSITORY_PROPERTIES: Dict = dict()        _READ_ENTITY_RETRY_KEY = \"read_entity_retry\"      _DEFAULT_READ_ENTITY_RETRY = 1        _MODE_KEY = \"mode\"      _DEVELOPMENT_MODE = \"development\"      _EXPERIMENT_MODE = \"experiment\"      _PRODUCTION_MODE = \"production\"      _DEFAULT_MODE = _DEVELOPMENT_MODE        _VERSION_NUMBER_KEY = \"version_number\"      _DEFAULT_VERSION_NUMBER = \"\"        _FORCE_KEY = \"force\"      _DEFAULT_FORCE = False        _CORE_VERSION_KEY = \"core_version\"      _CURRENT_CORE_VERSION = _read_version()        def __init__(          self,          root_folder: Optional[str] = None,          storage_folder: Optional[str] = None,          repository_type: Optional[str] = None,          repository_properties: Optional[Dict[str, Union[str, int]]] = None,          read_entity_retry: Optional[int] = None,          mode: Optional[str] = None,          version_number: Optional[str] = None,          force: Optional[bool] = None,          core_version: Optional[str] = None,          **properties,      ):          self._root_folder = root_folder          self._storage_folder = storage_folder          self._repository_type = repository_type          self._repository_properties = repository_properties or {}          self._read_entity_retry = (              read_entity_retry if read_entity_retry is not None else self._DEFAULT_READ_ENTITY_RETRY          )          self.mode = mode or self._DEFAULT_MODE          self.version_number = version_number or self._DEFAULT_VERSION_NUMBER          self.force = force or self._DEFAULT_FORCE            self._check_compatibility(core_version)          self._core_version = core_version            super().__init__(**properties)        def __copy__(self):          return CoreSection(              self.root_folder,              self.storage_folder,              self.repository_type,              self.repository_properties,              self.read_entity_retry,              self.mode,              self.version_number,              self.force,              self._core_version,              **copy(self._properties),          )        @property      def storage_folder(self):          return _tpl._replace_templates(self._storage_folder)        @storage_folder.setter  # type: ignore      @_ConfigBlocker._check()      def storage_folder(self, val):          self._storage_folder = val        @property      def root_folder(self):          return _tpl._replace_templates(self._root_folder)        @root_folder.setter  # type: ignore      @_ConfigBlocker._check()      def root_folder(self, val):          self._root_folder = val        @property      def repository_type(self):          return _tpl._replace_templates(self._repository_type)        @repository_type.setter  # type: ignore      @_ConfigBlocker._check()      def repository_type(self, val):          self._repository_type = val        @property      def repository_properties(self):          return (              {k: _tpl._replace_templates(v) for k, v in self._repository_properties.items()}              if self._repository_properties              else self._DEFAULT_REPOSITORY_PROPERTIES.copy()          )        @repository_properties.setter  # type: ignore      @_ConfigBlocker._check()      def repository_properties(self, val):          self._repository_properties = val        @property      def read_entity_retry(self):          return _tpl._replace_templates(self._read_entity_retry)        @read_entity_retry.setter  # type: ignore      @_ConfigBlocker._check()      def read_entity_retry(self, val):          self._read_entity_retry = val        @classmethod      def default_config(cls):          return CoreSection(              cls._DEFAULT_ROOT_FOLDER,              cls._DEFAULT_STORAGE_FOLDER,              cls._DEFAULT_REPOSITORY_TYPE,              cls._DEFAULT_REPOSITORY_PROPERTIES,              cls._DEFAULT_READ_ENTITY_RETRY,              cls._DEFAULT_MODE,              cls._DEFAULT_VERSION_NUMBER,              cls._DEFAULT_FORCE,              cls._CURRENT_CORE_VERSION,          )        def _clean(self):          self._root_folder = self._DEFAULT_ROOT_FOLDER          self._storage_folder = self._DEFAULT_STORAGE_FOLDER          self._repository_type = self._DEFAULT_REPOSITORY_TYPE          self._repository_properties = self._DEFAULT_REPOSITORY_PROPERTIES.copy()          self._read_entity_retry = self._DEFAULT_READ_ENTITY_RETRY          self.mode = self._DEFAULT_MODE          self.version_number = self._DEFAULT_VERSION_NUMBER          self.force = self._DEFAULT_FORCE          self._core_version = self._CURRENT_CORE_VERSION          self._properties.clear()        def _to_dict(self):          as_dict = {}          if self._root_folder:              as_dict[self._ROOT_FOLDER_KEY] = self._root_folder          if self._storage_folder:              as_dict[self._STORAGE_FOLDER_KEY] = self._storage_folder          if self._repository_type:              as_dict[self._REPOSITORY_TYPE_KEY] = self._repository_type          if self._repository_properties:              as_dict[self._REPOSITORY_PROPERTIES_KEY] = self._repository_properties          if self._read_entity_retry is not None:              as_dict[self._READ_ENTITY_RETRY_KEY] = self._read_entity_retry          if self.mode is not None:              as_dict[self._MODE_KEY] = self.mode          if self.version_number is not None:              as_dict[self._VERSION_NUMBER_KEY] = self.version_number          if self.force is not None:              as_dict[self._FORCE_KEY] = self.force          if self._core_version is not None:              as_dict[self._CORE_VERSION_KEY] = self._core_version          as_dict.update(self._properties)          return as_dict        @classmethod      def _from_dict(cls, as_dict: Dict[str, Any], id=None, config: Optional[_Config] = None):          root_folder = as_dict.pop(cls._ROOT_FOLDER_KEY, None)          storage_folder = as_dict.pop(cls._STORAGE_FOLDER_KEY, None)          repository_type = as_dict.pop(cls._REPOSITORY_TYPE_KEY, None)          repository_properties = as_dict.pop(cls._REPOSITORY_PROPERTIES_KEY, None)          read_entity_retry = as_dict.pop(cls._READ_ENTITY_RETRY_KEY, None)          mode = as_dict.pop(cls._MODE_KEY, None)          version_nb = as_dict.pop(cls._VERSION_NUMBER_KEY, None)          force = as_dict.pop(cls._FORCE_KEY, None)          core_version = as_dict.pop(cls._CORE_VERSION_KEY, None)          return CoreSection(              root_folder,              storage_folder,              repository_type,              repository_properties,              read_entity_retry,              mode,              version_nb,              force,              core_version,              **as_dict,          )        def _update(self, as_dict: Dict[str, Any]):          root_folder = _tpl._replace_templates(as_dict.pop(self._ROOT_FOLDER_KEY, self._root_folder))          if self._root_folder != root_folder:              self._root_folder = root_folder            storage_folder = _tpl._replace_templates(as_dict.pop(self._STORAGE_FOLDER_KEY, self._storage_folder))          if self._storage_folder != storage_folder:              self._storage_folder = storage_folder            repository_type = _tpl._replace_templates(as_dict.pop(self._REPOSITORY_TYPE_KEY, self._repository_type))          if self._repository_type != repository_type:              self._repository_type = repository_type            repository_properties = _tpl._replace_templates(              as_dict.pop(self._REPOSITORY_PROPERTIES_KEY, self._repository_properties)          )          self._repository_properties.update(repository_properties)            read_entity_retry = _tpl._replace_templates(as_dict.pop(self._READ_ENTITY_RETRY_KEY, self._read_entity_retry))          if self._read_entity_retry != read_entity_retry:              self._read_entity_retry = read_entity_retry            mode = _tpl._replace_templates(as_dict.pop(self._MODE_KEY, self.mode))          if self.mode != mode:              self.mode = mode            version_number = _tpl._replace_templates(as_dict.pop(self._VERSION_NUMBER_KEY, self.version_number))          if self.version_number != version_number:              self.version_number = version_number            force = _tpl._replace_templates(as_dict.pop(self._FORCE_KEY, self.force))          if self.force != force:              self.force = force            core_version = as_dict.pop(self._CORE_VERSION_KEY, None)          self._check_compatibility(core_version)            self._properties.update(as_dict)        @classmethod      def _check_compatibility(cls, core_version):          if not core_version:              return            version_pattern = r\"^(\\d+)\\.(\\d+)\\.(\\d+)$\"          dev_version_pattern = r\"^(\\d+)\\.(\\d+)\\.(\\d+).(\\w*)$\"            installed_match = re.match(version_pattern, cls._CURRENT_CORE_VERSION) or re.match(              dev_version_pattern, cls._CURRENT_CORE_VERSION          )          required_match = re.match(version_pattern, core_version) or re.match(dev_version_pattern, core_version)          if required_match and installed_match:              installed_group = installed_match.groups()              required_group = required_match.groups()              installed_major, installed_minor = installed_group[0], installed_group[1]              required_major, required_minor = required_group[0], required_group[1]                if required_major != installed_major or required_minor != installed_minor:                  raise ConfigCoreVersionMismatched(core_version, cls._CURRENT_CORE_VERSION)        @staticmethod      def _configure(          root_folder: Optional[str] = None,          storage_folder: Optional[str] = None,          repository_type: Optional[str] = None,          repository_properties: Optional[Dict[str, Union[str, int]]] = None,          read_entity_retry: Optional[int] = None,          mode: Optional[str] = None,          version_number: Optional[str] = None,          force: Optional[bool] = None,          **properties,      ) -> \"CoreSection\":          \"\"\"Configure the Core service.            Parameters:              root_folder (Optional[str]): Path of the base folder for the taipy application.                  The default value is \"./taipy/\"              storage_folder (Optional[str]): Folder name used to store Taipy data. The default value is \".data/\".                  It is used in conjunction with the `root_folder` field. That means the storage path is                  <root_folder><storage_folder> (The default path is \"./taipy/.data/\").              repository_type (Optional[str]): The type of the repository to be used to store Taipy data.                  The default value is \"filesystem\".              repository_properties (Optional[Dict[str, Union[str, int]]]): A dictionary of additional properties                  to be used by the repository.              read_entity_retry (Optional[int]): Number of retries to read an entity from the repository                  before return failure. The default value is 3.              mode (Optional[str]): Indicates the mode of the version management system.                  Possible values are *\"development\"*, *\"experiment\"*, or *\"production\"*.              version_number (Optional[str]): The string identifier of the version.                   In development mode, the version number is ignored.              force (Optional[bool]): If True, Taipy will override a version even if the configuration                  has changed and run the application.              **properties (Dict[str, Any]): A keyworded variable length list of additional arguments configure the                  behavior of the `Core^` service.          Returns:              The Core configuration.          \"\"\"          section = CoreSection(              root_folder=root_folder,              storage_folder=storage_folder,              repository_type=repository_type,              repository_properties=repository_properties,              read_entity_retry=read_entity_retry,              mode=mode,              version_number=version_number,              force=force,              core_version=_read_version(),              **properties,          )          Config._register(section)          return Config.unique_sections[CoreSection.name] "}
{"text": "from collections import defaultdict  from copy import copy  from typing import Any, Callable, Dict, List, Optional, Union    from taipy.config._config import _Config  from taipy.config.common._template_handler import _TemplateHandler as _tpl  from taipy.config.common._validate_id import _validate_id  from taipy.config.common.frequency import Frequency  from taipy.config.config import Config  from taipy.config.section import Section    from .data_node_config import DataNodeConfig  from .task_config import TaskConfig      class ScenarioConfig(Section):      \"\"\"      Configuration fields needed to instantiate an actual `Scenario^`.        Attributes:          id (str): Identifier of the scenario config. It must be a valid Python variable name.          tasks (Optional[Union[TaskConfig, List[TaskConfig]]]): List of task configs.<br/>              The default value is None.          additional_data_nodes (Optional[Union[DataNodeConfig, List[DataNodeConfig]]]): <br/>              List of additional data node configs. The default value is None.          frequency (Optional[Frequency]): The frequency of the scenario's cycle. The default value is None.          comparators: Optional[Dict[str, Union[List[Callable], Callable]]]: Dictionary of the data node <br/>              config id as key and a list of Callable used to compare the data nodes as value.          sequences (Optional[Dict[str, List[TaskConfig]]]): Dictionary of sequence descriptions.              The default value is None.          **properties (dict[str, any]): A dictionary of additional properties.      \"\"\"        name = \"SCENARIO\"        _SEQUENCES_KEY = \"sequences\"      _TASKS_KEY = \"tasks\"      _ADDITIONAL_DATA_NODES_KEY = \"additional_data_nodes\"      _FREQUENCY_KEY = \"frequency\"      _SEQUENCES_KEY = \"sequences\"      _COMPARATOR_KEY = \"comparators\"        def __init__(          self,          id: str,          tasks: Optional[Union[TaskConfig, List[TaskConfig]]] = None,          additional_data_nodes: Optional[Union[DataNodeConfig, List[DataNodeConfig]]] = None,          frequency: Optional[Frequency] = None,          comparators: Optional[Dict[str, Union[List[Callable], Callable]]] = None,          sequences: Optional[Dict[str, List[TaskConfig]]] = None,          **properties,      ):            if tasks:              self._tasks = list(tasks) if isinstance(tasks, TaskConfig) else copy(tasks)          else:              self._tasks = []            if additional_data_nodes:              self._additional_data_nodes = (                  list(additional_data_nodes)                  if isinstance(additional_data_nodes, DataNodeConfig)                  else copy(additional_data_nodes)              )          else:              self._additional_data_nodes = []            self.sequences = sequences if sequences else {}          self.frequency = frequency          self.comparators = defaultdict(list)            if comparators:              for k, v in comparators.items():                  if isinstance(v, list):                      self.comparators[_validate_id(k)].extend(v)                  else:                      self.comparators[_validate_id(k)].append(v)          super().__init__(id, **properties)        def __copy__(self):          comp = None if self.comparators is None else self.comparators          scenario_config = ScenarioConfig(              self.id,              copy(self._tasks),              copy(self._additional_data_nodes),              self.frequency,              copy(comp),              copy(self.sequences),              **copy(self._properties),          )          return scenario_config        def __getattr__(self, item: str) -> Optional[Any]:          return _tpl._replace_templates(self._properties.get(item))        @property      def task_configs(self) -> List[TaskConfig]:          return self._tasks        @property      def tasks(self) -> List[TaskConfig]:          return self._tasks        @property      def additional_data_node_configs(self) -> List[DataNodeConfig]:          return self._additional_data_nodes        @property      def additional_data_nodes(self) -> List[DataNodeConfig]:          return self._additional_data_nodes        @property      def data_node_configs(self) -> List[DataNodeConfig]:          return self.__get_all_unique_data_nodes()        @property      def data_nodes(self) -> List[DataNodeConfig]:          return self.__get_all_unique_data_nodes()        def __get_all_unique_data_nodes(self) -> List[DataNodeConfig]:          data_node_configs = set(self._additional_data_nodes)          for task in self._tasks:              data_node_configs.update(task.inputs)              data_node_configs.update(task.outputs)            return list(data_node_configs)        @classmethod      def default_config(cls):          return ScenarioConfig(cls._DEFAULT_KEY, list(), list(), None, dict())        def _clean(self):          self._tasks = list()          self._additional_data_nodes = list()          self.frequency = None          self.comparators = dict()          self.sequences = dict()          self._properties = dict()        def _to_dict(self) -> Dict[str, Any]:          return {              self._COMPARATOR_KEY: self.comparators,              self._TASKS_KEY: self._tasks,              self._ADDITIONAL_DATA_NODES_KEY: self._additional_data_nodes,              self._FREQUENCY_KEY: self.frequency,              self._SEQUENCES_KEY: self.sequences,              **self._properties,          }        @classmethod      def _from_dict(          cls, as_dict: Dict[str, Any], id: str, config: Optional[_Config] = None      ) -> \"ScenarioConfig\":  # type: ignore          as_dict.pop(cls._ID_KEY, id)            tasks = cls.__get_task_configs(as_dict.pop(cls._TASKS_KEY, list()), config)            additional_data_node_ids = as_dict.pop(cls._ADDITIONAL_DATA_NODES_KEY, list())          additional_data_nodes = cls.__get_additional_data_node_configs(additional_data_node_ids, config)            frequency = as_dict.pop(cls._FREQUENCY_KEY, None)          comparators = as_dict.pop(cls._COMPARATOR_KEY, dict())          sequences = as_dict.pop(cls._SEQUENCES_KEY, {})            for sequence_name, sequence_tasks in sequences.items():              sequences[sequence_name] = cls.__get_task_configs(sequence_tasks, config)            scenario_config = ScenarioConfig(              id=id,              tasks=tasks,              additional_data_nodes=additional_data_nodes,              frequency=frequency,              comparators=comparators,              sequences=sequences,              **as_dict,          )            return scenario_config        @staticmethod      def __get_task_configs(task_config_ids: List[str], config: Optional[_Config]):          task_configs = set()          if config:              if task_config_section := config._sections.get(TaskConfig.name):                  for task_config_id in task_config_ids:                      if task_config := task_config_section.get(task_config_id, None):                          task_configs.add(task_config)          return list(task_configs)        @staticmethod      def __get_additional_data_node_configs(additional_data_node_ids: List[str], config: Optional[_Config]):          additional_data_node_configs = set()          if config:              if data_node_config_section := config._sections.get(DataNodeConfig.name):                  for additional_data_node_id in additional_data_node_ids:                      if additional_data_node_config := data_node_config_section.get(additional_data_node_id):                          additional_data_node_configs.add(additional_data_node_config)          return list(additional_data_node_configs)        def _update(self, as_dict: Dict[str, Any], default_section=None):          self._tasks = as_dict.pop(self._TASKS_KEY, self._tasks)          if self._tasks is None and default_section:              self._tasks = default_section._tasks            self._additional_data_nodes = as_dict.pop(self._ADDITIONAL_DATA_NODES_KEY, self._additional_data_nodes)          if self._additional_data_nodes is None and default_section:              self._additional_data_nodes = default_section._additional_data_nodes            self.frequency = as_dict.pop(self._FREQUENCY_KEY, self.frequency)          if self.frequency is None and default_section:              self.frequency = default_section.frequency            self.comparators = as_dict.pop(self._COMPARATOR_KEY, self.comparators)          if self.comparators is None and default_section:              self.comparators = default_section.comparators            self.sequences = as_dict.pop(self._SEQUENCES_KEY, self.sequences)          if self.sequences is None and default_section:              self.sequences = default_section.sequences            self._properties.update(as_dict)          if default_section:              self._properties = {**default_section.properties, **self._properties}        def add_comparator(self, dn_config_id: str, comparator: Callable):          self.comparators[dn_config_id].append(comparator)        def delete_comparator(self, dn_config_id: str):          if dn_config_id in self.comparators:              del self.comparators[dn_config_id]        @staticmethod      def _configure(          id: str,          task_configs: Optional[List[TaskConfig]] = None,          additional_data_node_configs: Optional[List[DataNodeConfig]] = None,          frequency: Optional[Frequency] = None,          comparators: Optional[Dict[str, Union[List[Callable], Callable]]] = None,          sequences: Optional[Dict[str, List[TaskConfig]]] = None,          **properties,      ) -> \"ScenarioConfig\":          \"\"\"Configure a new scenario configuration.            Parameters:              id (str): The unique identifier of the new scenario configuration.              task_configs (Optional[List[TaskConfig^]]): The list of task configurations used by this                  scenario configuration. The default value is None.              additional_data_node_configs (Optional[List[DataNodeConfig^]]): The list of additional data nodes                  related to this scenario configuration. The default value is None.              frequency (Optional[Frequency^]): The scenario frequency.<br/>                  It corresponds to the recurrence of the scenarios instantiated from this                  configuration. Based on this frequency each scenario will be attached to the                  relevant cycle.              comparators (Optional[Dict[str, Union[List[Callable], Callable]]]): The list of                  functions used to compare scenarios. A comparator function is attached to a                  scenario's data node configuration. The key of the dictionary parameter                  corresponds to the data node configuration id. During the scenarios'                  comparison, each comparator is applied to all the data nodes instantiated from                  the data node configuration attached to the comparator. See                  `(taipy.)compare_scenarios()^` more more details.              sequences (Optional[Dict[str, List[TaskConfig]]]): Dictionary of sequence descriptions.                  The default value is None.              **properties (dict[str, any]): A keyworded variable length list of additional arguments.            Returns:              The new scenario configuration.          \"\"\"          section = ScenarioConfig(              id,              task_configs,              additional_data_node_configs,              frequency=frequency,              comparators=comparators,              sequences=sequences,              **properties,          )          Config._register(section)          return Config.sections[ScenarioConfig.name][id]        @staticmethod      def _set_default_configuration(          task_configs: Optional[List[TaskConfig]] = None,          additional_data_node_configs: List[DataNodeConfig] = None,          frequency: Optional[Frequency] = None,          comparators: Optional[Dict[str, Union[List[Callable], Callable]]] = None,          sequences: Optional[Dict[str, List[TaskConfig]]] = None,          **properties,      ) -> \"ScenarioConfig\":          \"\"\"Set the default values for scenario configurations.            This function creates the *default scenario configuration* object,          where all scenario configuration objects will find their default          values when needed.            Parameters:              task_configs (Optional[List[TaskConfig^]]): The list of task configurations used by this                  scenario configuration.              additional_data_node_configs (Optional[List[DataNodeConfig^]]): The list of additional data nodes                  related to this scenario configuration.              frequency (Optional[Frequency^]): The scenario frequency.                  It corresponds to the recurrence of the scenarios instantiated from this                  configuration. Based on this frequency each scenario will be attached to                  the relevant cycle.              comparators (Optional[Dict[str, Union[List[Callable], Callable]]]): The list of                  functions used to compare scenarios. A comparator function is attached to a                  scenario's data node configuration. The key of the dictionary parameter                  corresponds to the data node configuration id. During the scenarios'                  comparison, each comparator is applied to all the data nodes instantiated from                  the data node configuration attached to the comparator. See                  `taipy.compare_scenarios()^` more more details.              sequences (Optional[Dict[str, List[TaskConfig]]]): Dictionary of sequences. The default value is None.              **properties (dict[str, any]): A keyworded variable length list of additional arguments.            Returns:              The new default scenario configuration.          \"\"\"          section = ScenarioConfig(              _Config.DEFAULT_KEY,              task_configs,              additional_data_node_configs,              frequency=frequency,              comparators=comparators,              sequences=sequences,              **properties,          )          Config._register(section)          return Config.sections[ScenarioConfig.name][_Config.DEFAULT_KEY]        def add_sequences(self, sequences: Dict[str, List[TaskConfig]]):          self.sequences.update(sequences)        def remove_sequences(self, sequence_names: Union[str, List[str]]):          if isinstance(sequence_names, List):              for sequence_name in sequence_names:                  self.sequences.pop(sequence_name)          else:              self.sequences.pop(sequence_names) "}
{"text": "import json  from copy import copy  from datetime import timedelta  from typing import Any, Callable, Dict, List, Optional, Union    from taipy.config._config import _Config  from taipy.config.common._config_blocker import _ConfigBlocker  from taipy.config.common._template_handler import _TemplateHandler as _tpl  from taipy.config.common.scope import Scope  from taipy.config.config import Config  from taipy.config.section import Section    from ..common._warnings import _warn_deprecated  from ..common.mongo_default_document import MongoDefaultDocument      class DataNodeConfig(Section):      \"\"\"      Configuration fields needed to instantiate a `DataNode^`.        A Data Node config is made to be used as a generator for actual data nodes. It holds configuration information      needed to create an actual data node.        Attributes:          id (str): Unique identifier of the data node config. It must be a valid Python variable name.          storage_type (str): Storage type of the data nodes created from the data node config. The possible values              are : \"csv\", \"excel\", \"pickle\", \"sql_table\", \"sql\", \"mongo_collection\", \"generic\", \"json\", \"parquet\" and              \"in_memory\".              The default value is \"pickle\".              Note that the \"in_memory\" value can only be used when `JobConfig^`.mode is \"standalone\".          scope (Optional[Scope^]): The optional `Scope^` of the data nodes instantiated from the data node config.              The default value is SCENARIO.          **properties (dict[str, any]): A dictionary of additional properties.      \"\"\"        name = \"DATA_NODE\"        _STORAGE_TYPE_KEY = \"storage_type\"      _STORAGE_TYPE_VALUE_PICKLE = \"pickle\"      _STORAGE_TYPE_VALUE_SQL_TABLE = \"sql_table\"      _STORAGE_TYPE_VALUE_SQL = \"sql\"      _STORAGE_TYPE_VALUE_MONGO_COLLECTION = \"mongo_collection\"      _STORAGE_TYPE_VALUE_CSV = \"csv\"      _STORAGE_TYPE_VALUE_EXCEL = \"excel\"      _STORAGE_TYPE_VALUE_IN_MEMORY = \"in_memory\"      _STORAGE_TYPE_VALUE_GENERIC = \"generic\"      _STORAGE_TYPE_VALUE_JSON = \"json\"      _STORAGE_TYPE_VALUE_PARQUET = \"parquet\"      _DEFAULT_STORAGE_TYPE = _STORAGE_TYPE_VALUE_PICKLE      _ALL_STORAGE_TYPES = [          _STORAGE_TYPE_VALUE_PICKLE,          _STORAGE_TYPE_VALUE_SQL_TABLE,          _STORAGE_TYPE_VALUE_SQL,          _STORAGE_TYPE_VALUE_MONGO_COLLECTION,          _STORAGE_TYPE_VALUE_CSV,          _STORAGE_TYPE_VALUE_EXCEL,          _STORAGE_TYPE_VALUE_IN_MEMORY,          _STORAGE_TYPE_VALUE_GENERIC,          _STORAGE_TYPE_VALUE_JSON,          _STORAGE_TYPE_VALUE_PARQUET,      ]        _EXPOSED_TYPE_KEY = \"exposed_type\"      _EXPOSED_TYPE_PANDAS = \"pandas\"      _EXPOSED_TYPE_MODIN = \"modin\"      _EXPOSED_TYPE_NUMPY = \"numpy\"      _DEFAULT_EXPOSED_TYPE = _EXPOSED_TYPE_PANDAS        _ALL_EXPOSED_TYPES = [          _EXPOSED_TYPE_PANDAS,          _EXPOSED_TYPE_MODIN,          _EXPOSED_TYPE_NUMPY,      ]        _OPTIONAL_ENCODING_PROPERTY = \"encoding\"      _DEFAULT_ENCODING_VALUE = \"utf-8\"        # Generic      _OPTIONAL_READ_FUNCTION_GENERIC_PROPERTY = \"read_fct\"      _OPTIONAL_READ_FUNCTION_ARGS_GENERIC_PROPERTY = \"read_fct_args\"      _OPTIONAL_WRITE_FUNCTION_GENERIC_PROPERTY = \"write_fct\"      _OPTIONAL_WRITE_FUNCTION_ARGS_GENERIC_PROPERTY = \"write_fct_args\"      # CSV      _OPTIONAL_EXPOSED_TYPE_CSV_PROPERTY = \"exposed_type\"      _OPTIONAL_DEFAULT_PATH_CSV_PROPERTY = \"default_path\"      _OPTIONAL_HAS_HEADER_CSV_PROPERTY = \"has_header\"      # Excel      _OPTIONAL_EXPOSED_TYPE_EXCEL_PROPERTY = \"exposed_type\"      _OPTIONAL_DEFAULT_PATH_EXCEL_PROPERTY = \"default_path\"      _OPTIONAL_HAS_HEADER_EXCEL_PROPERTY = \"has_header\"      _OPTIONAL_SHEET_NAME_EXCEL_PROPERTY = \"sheet_name\"      # In memory      _OPTIONAL_DEFAULT_DATA_IN_MEMORY_PROPERTY = \"default_data\"      # SQL      _REQUIRED_DB_NAME_SQL_PROPERTY = \"db_name\"      _REQUIRED_DB_ENGINE_SQL_PROPERTY = \"db_engine\"      _DB_ENGINE_SQLITE = \"sqlite\"      _OPTIONAL_FOLDER_PATH_SQLITE_PROPERTY = \"sqlite_folder_path\"      _OPTIONAL_FILE_EXTENSION_SQLITE_PROPERTY = \"sqlite_file_extension\"      _OPTIONAL_DB_PASSWORD_SQL_PROPERTY = \"db_password\"      _OPTIONAL_DB_USERNAME_SQL_PROPERTY = \"db_username\"      _OPTIONAL_PORT_SQL_PROPERTY = \"db_port\"      _OPTIONAL_HOST_SQL_PROPERTY = \"db_host\"      _OPTIONAL_DRIVER_SQL_PROPERTY = \"db_driver\"      _OPTIONAL_DB_EXTRA_ARGS_SQL_PROPERTY = \"db_extra_args\"      _OPTIONAL_EXPOSED_TYPE_SQL_PROPERTY = \"exposed_type\"      # SQL_TABLE      _REQUIRED_TABLE_NAME_SQL_TABLE_PROPERTY = \"table_name\"      # SQL      _REQUIRED_READ_QUERY_SQL_PROPERTY = \"read_query\"      _REQUIRED_WRITE_QUERY_BUILDER_SQL_PROPERTY = \"write_query_builder\"      _OPTIONAL_APPEND_QUERY_BUILDER_SQL_PROPERTY = \"append_query_builder\"      # MONGO      _REQUIRED_DB_NAME_MONGO_PROPERTY = \"db_name\"      _REQUIRED_COLLECTION_NAME_MONGO_PROPERTY = \"collection_name\"      _OPTIONAL_CUSTOM_DOCUMENT_MONGO_PROPERTY = \"custom_document\"      _OPTIONAL_USERNAME_MONGO_PROPERTY = \"db_username\"      _OPTIONAL_PASSWORD_MONGO_PROPERTY = \"db_password\"      _OPTIONAL_HOST_MONGO_PROPERTY = \"db_host\"      _OPTIONAL_PORT_MONGO_PROPERTY = \"db_port\"      _OPTIONAL_DRIVER_MONGO_PROPERTY = \"db_driver\"      _OPTIONAL_DB_EXTRA_ARGS_MONGO_PROPERTY = \"db_extra_args\"      # Pickle      _OPTIONAL_DEFAULT_PATH_PICKLE_PROPERTY = \"default_path\"      _OPTIONAL_DEFAULT_DATA_PICKLE_PROPERTY = \"default_data\"      # JSON      _OPTIONAL_ENCODER_JSON_PROPERTY = \"encoder\"      _OPTIONAL_DECODER_JSON_PROPERTY = \"decoder\"      _OPTIONAL_DEFAULT_PATH_JSON_PROPERTY = \"default_path\"      # Parquet      _OPTIONAL_EXPOSED_TYPE_PARQUET_PROPERTY = \"exposed_type\"      _OPTIONAL_DEFAULT_PATH_PARQUET_PROPERTY = \"default_path\"      _OPTIONAL_ENGINE_PARQUET_PROPERTY = \"engine\"      _OPTIONAL_COMPRESSION_PARQUET_PROPERTY = \"compression\"      _OPTIONAL_READ_KWARGS_PARQUET_PROPERTY = \"read_kwargs\"      _OPTIONAL_WRITE_KWARGS_PARQUET_PROPERTY = \"write_kwargs\"        _REQUIRED_PROPERTIES: Dict[str, List] = {          _STORAGE_TYPE_VALUE_PICKLE: [],          _STORAGE_TYPE_VALUE_SQL_TABLE: [              _REQUIRED_DB_NAME_SQL_PROPERTY,              _REQUIRED_DB_ENGINE_SQL_PROPERTY,              _REQUIRED_TABLE_NAME_SQL_TABLE_PROPERTY,          ],          _STORAGE_TYPE_VALUE_SQL: [              _REQUIRED_DB_NAME_SQL_PROPERTY,              _REQUIRED_DB_ENGINE_SQL_PROPERTY,              _REQUIRED_READ_QUERY_SQL_PROPERTY,              _REQUIRED_WRITE_QUERY_BUILDER_SQL_PROPERTY,          ],          _STORAGE_TYPE_VALUE_MONGO_COLLECTION: [              _REQUIRED_DB_NAME_MONGO_PROPERTY,              _REQUIRED_COLLECTION_NAME_MONGO_PROPERTY,          ],          _STORAGE_TYPE_VALUE_CSV: [],          _STORAGE_TYPE_VALUE_EXCEL: [],          _STORAGE_TYPE_VALUE_IN_MEMORY: [],          _STORAGE_TYPE_VALUE_GENERIC: [],          _STORAGE_TYPE_VALUE_JSON: [],          _STORAGE_TYPE_VALUE_PARQUET: [],      }        _OPTIONAL_PROPERTIES = {          _STORAGE_TYPE_VALUE_GENERIC: {              _OPTIONAL_READ_FUNCTION_GENERIC_PROPERTY: None,              _OPTIONAL_WRITE_FUNCTION_GENERIC_PROPERTY: None,              _OPTIONAL_READ_FUNCTION_ARGS_GENERIC_PROPERTY: None,              _OPTIONAL_WRITE_FUNCTION_ARGS_GENERIC_PROPERTY: None,          },          _STORAGE_TYPE_VALUE_CSV: {              _OPTIONAL_DEFAULT_PATH_CSV_PROPERTY: None,              _OPTIONAL_ENCODING_PROPERTY: _DEFAULT_ENCODING_VALUE,              _OPTIONAL_HAS_HEADER_CSV_PROPERTY: True,              _OPTIONAL_EXPOSED_TYPE_CSV_PROPERTY: _DEFAULT_EXPOSED_TYPE,          },          _STORAGE_TYPE_VALUE_EXCEL: {              _OPTIONAL_DEFAULT_PATH_EXCEL_PROPERTY: None,              _OPTIONAL_HAS_HEADER_EXCEL_PROPERTY: True,              _OPTIONAL_SHEET_NAME_EXCEL_PROPERTY: None,              _OPTIONAL_EXPOSED_TYPE_EXCEL_PROPERTY: _DEFAULT_EXPOSED_TYPE,          },          _STORAGE_TYPE_VALUE_IN_MEMORY: {_OPTIONAL_DEFAULT_DATA_IN_MEMORY_PROPERTY: None},          _STORAGE_TYPE_VALUE_SQL_TABLE: {              _OPTIONAL_DB_USERNAME_SQL_PROPERTY: None,              _OPTIONAL_DB_PASSWORD_SQL_PROPERTY: None,              _OPTIONAL_HOST_SQL_PROPERTY: \"localhost\",              _OPTIONAL_PORT_SQL_PROPERTY: 1433,              _OPTIONAL_DRIVER_SQL_PROPERTY: \"\",              _OPTIONAL_FOLDER_PATH_SQLITE_PROPERTY: None,              _OPTIONAL_FILE_EXTENSION_SQLITE_PROPERTY: \".db\",              _OPTIONAL_DB_EXTRA_ARGS_SQL_PROPERTY: None,              _OPTIONAL_EXPOSED_TYPE_SQL_PROPERTY: _DEFAULT_EXPOSED_TYPE,          },          _STORAGE_TYPE_VALUE_SQL: {              _OPTIONAL_DB_USERNAME_SQL_PROPERTY: None,              _OPTIONAL_DB_PASSWORD_SQL_PROPERTY: None,              _OPTIONAL_HOST_SQL_PROPERTY: \"localhost\",              _OPTIONAL_PORT_SQL_PROPERTY: 1433,              _OPTIONAL_DRIVER_SQL_PROPERTY: \"\",              _OPTIONAL_APPEND_QUERY_BUILDER_SQL_PROPERTY: None,              _OPTIONAL_FOLDER_PATH_SQLITE_PROPERTY: None,              _OPTIONAL_FILE_EXTENSION_SQLITE_PROPERTY: \".db\",              _OPTIONAL_DB_EXTRA_ARGS_SQL_PROPERTY: None,              _OPTIONAL_EXPOSED_TYPE_SQL_PROPERTY: _DEFAULT_EXPOSED_TYPE,          },          _STORAGE_TYPE_VALUE_MONGO_COLLECTION: {              _OPTIONAL_CUSTOM_DOCUMENT_MONGO_PROPERTY: MongoDefaultDocument,              _OPTIONAL_USERNAME_MONGO_PROPERTY: \"\",              _OPTIONAL_PASSWORD_MONGO_PROPERTY: \"\",              _OPTIONAL_HOST_MONGO_PROPERTY: \"localhost\",              _OPTIONAL_PORT_MONGO_PROPERTY: 27017,              _OPTIONAL_DRIVER_MONGO_PROPERTY: \"\",              _OPTIONAL_DB_EXTRA_ARGS_MONGO_PROPERTY: None,          },          _STORAGE_TYPE_VALUE_PICKLE: {              _OPTIONAL_DEFAULT_PATH_PICKLE_PROPERTY: None,              _OPTIONAL_DEFAULT_DATA_PICKLE_PROPERTY: None,          },          _STORAGE_TYPE_VALUE_JSON: {              _OPTIONAL_DEFAULT_PATH_PICKLE_PROPERTY: None,              _OPTIONAL_ENCODING_PROPERTY: _DEFAULT_ENCODING_VALUE,              _OPTIONAL_ENCODER_JSON_PROPERTY: None,              _OPTIONAL_DECODER_JSON_PROPERTY: None,          },          _STORAGE_TYPE_VALUE_PARQUET: {              _OPTIONAL_DEFAULT_PATH_PARQUET_PROPERTY: None,              _OPTIONAL_ENGINE_PARQUET_PROPERTY: \"pyarrow\",              _OPTIONAL_COMPRESSION_PARQUET_PROPERTY: \"snappy\",              _OPTIONAL_READ_KWARGS_PARQUET_PROPERTY: None,              _OPTIONAL_WRITE_KWARGS_PARQUET_PROPERTY: None,              _OPTIONAL_EXPOSED_TYPE_PARQUET_PROPERTY: _DEFAULT_EXPOSED_TYPE,          },      }        _SCOPE_KEY = \"scope\"      _DEFAULT_SCOPE = Scope.SCENARIO        _VALIDITY_PERIOD_KEY = \"validity_period\"      _DEFAULT_VALIDITY_PERIOD = None        def __init__(          self,          id: str,          storage_type: Optional[str] = None,          scope: Optional[Scope] = None,          validity_period: Optional[timedelta] = None,          **properties,      ):          self._storage_type = storage_type          self._scope = scope          self._validity_period = validity_period          super().__init__(id, **properties)        def __copy__(self):          return DataNodeConfig(self.id, self._storage_type, self._scope, self._validity_period, **copy(self._properties))        def __getattr__(self, item: str) -> Optional[Any]:          return _tpl._replace_templates(self._properties.get(item))        @property      def storage_type(self):          return _tpl._replace_templates(self._storage_type)        @storage_type.setter  # type: ignore      @_ConfigBlocker._check()      def storage_type(self, val):          self._storage_type = val        @property      def scope(self):          return _tpl._replace_templates(self._scope)        @scope.setter  # type: ignore      @_ConfigBlocker._check()      def scope(self, val):          self._scope = val        @property      def validity_period(self):          return _tpl._replace_templates(self._validity_period)        @validity_period.setter  # type: ignore      @_ConfigBlocker._check()      def validity_period(self, val):          self._validity_period = val        @property      def cacheable(self):          _warn_deprecated(\"cacheable\", suggest=\"the skippable feature\")          cacheable = self._properties.get(\"cacheable\")          if cacheable is not None:              return _tpl._replace_templates(cacheable)          else:              return False        @cacheable.setter  # type: ignore      @_ConfigBlocker._check()      def cacheable(self, val):          _warn_deprecated(\"cacheable\", suggest=\"the skippable feature\")          self._properties[\"cacheable\"] = val        @classmethod      def default_config(cls):          return DataNodeConfig(              cls._DEFAULT_KEY, cls._DEFAULT_STORAGE_TYPE, cls._DEFAULT_SCOPE, cls._DEFAULT_VALIDITY_PERIOD          )        def _clean(self):          self._storage_type = self._DEFAULT_STORAGE_TYPE          self._scope = self._DEFAULT_SCOPE          self._validity_period = self._DEFAULT_VALIDITY_PERIOD          self._properties.clear()        def _to_dict(self):          as_dict = {}          if self._storage_type is not None:              as_dict[self._STORAGE_TYPE_KEY] = self._storage_type          if self._scope is not None:              as_dict[self._SCOPE_KEY] = self._scope          if self._validity_period is not None:              as_dict[self._VALIDITY_PERIOD_KEY] = self._validity_period          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)          storage_type = as_dict.pop(cls._STORAGE_TYPE_KEY, None)          scope = as_dict.pop(cls._SCOPE_KEY, None)          validity_perid = as_dict.pop(cls._VALIDITY_PERIOD_KEY, None)          return DataNodeConfig(id=id, storage_type=storage_type, scope=scope, validity_period=validity_perid, **as_dict)        def _update(self, as_dict, default_section=None):          self._storage_type = as_dict.pop(self._STORAGE_TYPE_KEY, self._storage_type)          if self._storage_type is None and default_section:              self._storage_type = default_section.storage_type            self._scope = as_dict.pop(self._SCOPE_KEY, self._scope)          if self._scope is None and default_section:              if default_section.scope and self._storage_type == default_section.storage_type:                  self._scope = default_section.scope              else:                  self._scope = self._DEFAULT_SCOPE            self._validity_period = as_dict.pop(self._VALIDITY_PERIOD_KEY, self._validity_period)          if self._validity_period is None and default_section:              self._validity_period = default_section.validity_period            self._properties.update(as_dict)          if default_section and self._storage_type == default_section.storage_type:              self._properties = {**default_section.properties, **self._properties}            # Assign default value to optional properties if not defined by user          if self._OPTIONAL_PROPERTIES.get(self._storage_type):              for optional_property, default_value in self._OPTIONAL_PROPERTIES[self._storage_type].items():                  if default_value is not None and self._properties.get(optional_property) is None:                      self._properties[optional_property] = default_value        @staticmethod      def _set_default_configuration(          storage_type: str, scope: Optional[Scope] = None, validity_period: Optional[timedelta] = None, **properties      ) -> \"DataNodeConfig\":          \"\"\"Set the default values for data node configurations.            This function creates the _default data node configuration_ object,          where all data node configuration objects will find their default          values when needed.            Parameters:              storage_type (str): The default storage type for all data node configurations.                  The possible values are *\"pickle\"* (the default value), *\"csv\"*, *\"excel\"*,                  *\"sql\"*, *\"mongo_collection\"*, *\"in_memory\"*, *\"json\"*, *\"parquet\"* or                  *\"generic\"*.              scope (Optional[Scope^]): The default scope for all data node configurations.<br/>                  The default value is `Scope.SCENARIO`.              validity_period (Optional[timedelta]): The duration 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 configs page](../core/config/task-config.md) for more details).                  If *validity_period* is set to None, the data node is always up-to-date.              **properties (dict[str, any]): A keyworded variable length list of additional arguments.            Returns:              The default data node configuration.          \"\"\"          section = DataNodeConfig(_Config.DEFAULT_KEY, storage_type, scope, validity_period, **properties)          Config._register_default(section)          return Config.sections[DataNodeConfig.name][_Config.DEFAULT_KEY]        @classmethod      def _configure_from(          cls,          source_configuration: \"DataNodeConfig\",          id: str,          **properties,      ) -> \"DataNodeConfig\":          \"\"\"Configure a new data node configuration from an existing one.            Parameters:              source_configuration (DataNodeConfig): The source data node configuration.              id (str): The unique identifier of the new data node configuration.              **properties (dict[str, any]): A keyworded variable length list of additional arguments.<br/>                  The default properties are the properties of the source data node configuration.            Returns:              The new data node configuration.          \"\"\"          scope = properties.pop(\"scope\", None) or source_configuration.scope          validity_period = properties.pop(\"validity_period\", None) or source_configuration.validity_period          properties = {**source_configuration.properties, **properties}  # type: ignore            return cls.__configure(id, source_configuration.storage_type, scope, validity_period, **properties)        @classmethod      def _configure(          cls,          id: str,          storage_type: Optional[str] = None,          scope: Optional[Scope] = None,          validity_period: Optional[timedelta] = None,          **properties,      ) -> \"DataNodeConfig\":          \"\"\"Configure a new data node configuration.            Parameters:              id (str): The unique identifier of the new data node configuration.              storage_type (Optional[str]): The data node configuration storage type. The possible values                  are None (which is the default value of *\"pickle\"*, unless it has been overloaded by the                  *storage_type* value set in the default data node configuration                  (see `(Config.)set_default_data_node_configuration()^`)), *\"pickle\"*, *\"csv\"*, *\"excel\"*,                  *\"sql_table\"*, *\"sql\"*, *\"json\"*, *\"parquet\"*, *\"mongo_collection\"*, *\"in_memory\"*, or                  *\"generic\"*.              scope (Optional[Scope^]): The scope of the data node configuration.<br/>                  The default value is `Scope.SCENARIO` (or the one specified in                  `(Config.)set_default_data_node_configuration()^`).              validity_period (Optional[timedelta]): The duration 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 configs page](../core/config/task-config.md) for more details).                  If *validity_period* is set to None, the data node is always up-to-date.              **properties (dict[str, any]): A keyworded variable length list of additional arguments.            Returns:              The new data node configuration.          \"\"\"          configuration_map: Dict[str, Callable] = {              cls._STORAGE_TYPE_VALUE_PICKLE: cls._configure_pickle,              cls._STORAGE_TYPE_VALUE_SQL_TABLE: cls._configure_sql_table,              cls._STORAGE_TYPE_VALUE_SQL: cls._configure_sql,              cls._STORAGE_TYPE_VALUE_MONGO_COLLECTION: cls._configure_mongo_collection,              cls._STORAGE_TYPE_VALUE_CSV: cls._configure_csv,              cls._STORAGE_TYPE_VALUE_EXCEL: cls._configure_excel,              cls._STORAGE_TYPE_VALUE_IN_MEMORY: cls._configure_in_memory,              cls._STORAGE_TYPE_VALUE_GENERIC: cls._configure_generic,              cls._STORAGE_TYPE_VALUE_JSON: cls._configure_json,              cls._STORAGE_TYPE_VALUE_PARQUET: cls._configure_parquet,          }            if storage_type in cls._ALL_STORAGE_TYPES:              return configuration_map[storage_type](id=id, scope=scope, validity_period=validity_period, **properties)            return cls.__configure(id, storage_type, scope, validity_period, **properties)        @classmethod      def _configure_csv(          cls,          id: str,          default_path: Optional[str] = None,          encoding: Optional[str] = None,          has_header: Optional[bool] = None,          exposed_type: Optional[str] = None,          scope: Optional[Scope] = None,          validity_period: Optional[timedelta] = None,          **properties,      ) -> \"DataNodeConfig\":          \"\"\"Configure a new CSV data node configuration.            Parameters:              id (str): The unique identifier of the new CSV data node configuration.              default_path (Optional[str]): The default path of the CSV file.              encoding (Optional[str]): The encoding of the CSV file.              has_header (Optional[bool]): If True, indicates that the CSV file has a header.              exposed_type (Optional[str]): The exposed type of the data read from CSV file.<br/>                  The default value is `pandas`.              scope (Optional[Scope^]): The scope of the CSV data node configuration.<br/>                  The default value is `Scope.SCENARIO`.              validity_period (Optional[timedelta]): The duration 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 configs page](../core/config/task-config.md) for more details).                  If *validity_period* is set to None, the data node is always up-to-date.              **properties (dict[str, any]): A keyworded variable length list of additional arguments.            Returns:              The new CSV data node configuration.          \"\"\"          if default_path is not None:              properties[cls._OPTIONAL_DEFAULT_PATH_CSV_PROPERTY] = default_path          if encoding is not None:              properties[cls._OPTIONAL_ENCODING_PROPERTY] = encoding          if has_header is not None:              properties[cls._OPTIONAL_HAS_HEADER_CSV_PROPERTY] = has_header          if exposed_type is not None:              properties[cls._OPTIONAL_EXPOSED_TYPE_CSV_PROPERTY] = exposed_type            return cls.__configure(id, DataNodeConfig._STORAGE_TYPE_VALUE_CSV, scope, validity_period, **properties)        @classmethod      def _configure_json(          cls,          id: str,          default_path: Optional[str] = None,          encoding: Optional[str] = None,          encoder: Optional[json.JSONEncoder] = None,          decoder: Optional[json.JSONDecoder] = None,          scope: Optional[Scope] = None,          validity_period: Optional[timedelta] = None,          **properties,      ) -> \"DataNodeConfig\":          \"\"\"Configure a new JSON data node configuration.            Parameters:              id (str): The unique identifier of the new JSON data node configuration.              default_path (Optional[str]): The default path of the JSON file.              encoding (Optional[str]): The encoding of the JSON file.              encoder (Optional[json.JSONEncoder]): The JSON encoder used to write data into the JSON file.              decoder (Optional[json.JSONDecoder]): The JSON decoder used to read data from the JSON file.              scope (Optional[Scope^]): The scope of the JSON data node configuration.<br/>                  The default value is `Scope.SCENARIO`.              validity_period (Optional[timedelta]): The duration 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 configs page](../core/config/task-config.md) for more details).                  If *validity_period* is set to None, the data node is always up-to-date.              **properties (dict[str, any]): A keyworded variable length list of additional arguments.          Returns:              The new JSON data node configuration.          \"\"\"          if default_path is not None:              properties[cls._OPTIONAL_DEFAULT_PATH_JSON_PROPERTY] = default_path          if encoding is not None:              properties[cls._OPTIONAL_ENCODING_PROPERTY] = encoding          if encoder is not None:              properties[cls._OPTIONAL_ENCODER_JSON_PROPERTY] = encoder          if decoder is not None:              properties[cls._OPTIONAL_DECODER_JSON_PROPERTY] = decoder            return cls.__configure(id, DataNodeConfig._STORAGE_TYPE_VALUE_JSON, scope, validity_period, **properties)        @classmethod      def _configure_parquet(          cls,          id: str,          default_path: Optional[str] = None,          engine: Optional[str] = None,          compression: Optional[str] = None,          read_kwargs: Optional[Dict] = None,          write_kwargs: Optional[Dict] = None,          exposed_type: Optional[str] = None,          scope: Optional[Scope] = None,          validity_period: Optional[timedelta] = None,          **properties,      ) -> \"DataNodeConfig\":          \"\"\"Configure a new Parquet data node configuration.            Parameters:              id (str): The unique identifier of the new Parquet data node configuration.              default_path (Optional[str]): The default path of the Parquet file.              engine (Optional[str]): Parquet library to use. Possible values are *\"fastparquet\"* or                  *\"pyarrow\"*.<br/>                  The default value is *\"pyarrow\"*.              compression (Optional[str]): Name of the compression to use. Possible values are *\"snappy\"*,                  *\"gzip\"*, *\"brotli\"*, or *\"none\"* (no compression). The default value is *\"snappy\"*.              read_kwargs (Optional[dict]): Additional parameters passed to the `pandas.read_parquet()`                  function.              write_kwargs (Optional[dict]): Additional parameters passed to the                  `pandas.DataFrame.write_parquet()` function.<br/>                  The parameters in *read_kwargs* and *write_kwargs* have a **higher precedence** than the                  top-level parameters which are also passed to Pandas.              exposed_type (Optional[str]): The exposed type of the data read from Parquet file.<br/>                  The default value is `pandas`.              scope (Optional[Scope^]): The scope of the Parquet data node configuration.<br/>                  The default value is `Scope.SCENARIO`.              validity_period (Optional[timedelta]): The duration 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 configs page](../core/config/task-config.md) for more details).                  If *validity_period* is set to None, the data node is always up-to-date.              **properties (dict[str, any]): A keyworded variable length list of additional arguments.            Returns:              The new Parquet data node configuration.          \"\"\"          if default_path is not None:              properties[cls._OPTIONAL_DEFAULT_PATH_PARQUET_PROPERTY] = default_path          if engine is not None:              properties[cls._OPTIONAL_ENGINE_PARQUET_PROPERTY] = engine          if compression is not None:              properties[cls._OPTIONAL_COMPRESSION_PARQUET_PROPERTY] = compression          if read_kwargs is not None:              properties[cls._OPTIONAL_READ_KWARGS_PARQUET_PROPERTY] = read_kwargs          if write_kwargs is not None:              properties[cls._OPTIONAL_WRITE_KWARGS_PARQUET_PROPERTY] = write_kwargs          if exposed_type is not None:              properties[cls._OPTIONAL_EXPOSED_TYPE_PARQUET_PROPERTY] = exposed_type            return cls.__configure(id, DataNodeConfig._STORAGE_TYPE_VALUE_PARQUET, scope, validity_period, **properties)        @classmethod      def _configure_excel(          cls,          id: str,          default_path: Optional[str] = None,          has_header: Optional[bool] = None,          sheet_name: Optional[Union[List[str], str]] = None,          exposed_type: Optional[str] = None,          scope: Optional[Scope] = None,          validity_period: Optional[timedelta] = None,          **properties,      ) -> \"DataNodeConfig\":          \"\"\"Configure a new Excel data node configuration.            Parameters:              id (str): The unique identifier of the new Excel data node configuration.              default_path (Optional[str]): The path of the Excel file.              has_header (Optional[bool]): If True, indicates that the Excel file has a header.              sheet_name (Optional[Union[List[str], str]]): The list of sheet names to be used.                  This can be a unique name.              exposed_type (Optional[str]): The exposed type of the data read from Excel file.<br/>                  The default value is `pandas`.              scope (Optional[Scope^]): The scope of the Excel data node configuration.<br/>                  The default value is `Scope.SCENARIO`.              validity_period (Optional[timedelta]): The duration 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 configs page](../core/config/task-config.md) for more details).                  If *validity_period* is set to None, the data node is always up-to-date.              **properties (dict[str, any]): A keyworded variable length list of additional arguments.            Returns:              The new Excel data node configuration.          \"\"\"          if default_path is not None:              properties[cls._OPTIONAL_DEFAULT_PATH_EXCEL_PROPERTY] = default_path          if has_header is not None:              properties[cls._OPTIONAL_HAS_HEADER_EXCEL_PROPERTY] = has_header          if sheet_name is not None:              properties[cls._OPTIONAL_SHEET_NAME_EXCEL_PROPERTY] = sheet_name          if exposed_type is not None:              properties[cls._OPTIONAL_EXPOSED_TYPE_EXCEL_PROPERTY] = exposed_type            return cls.__configure(id, DataNodeConfig._STORAGE_TYPE_VALUE_EXCEL, scope, validity_period, **properties)        @classmethod      def _configure_generic(          cls,          id: str,          read_fct: Optional[Callable] = None,          write_fct: Optional[Callable] = None,          read_fct_args: Optional[List] = None,          write_fct_args: Optional[List] = None,          scope: Optional[Scope] = None,          validity_period: Optional[timedelta] = None,          **properties,      ) -> \"DataNodeConfig\":          \"\"\"Configure a new generic data node configuration.            Parameters:              id (str): The unique identifier of the new generic data node configuration.              read_fct (Optional[Callable]): The Python function called to read the data.              write_fct (Optional[Callable]): The Python function called to write the data.                  The provided function must have at least one parameter that receives the data to be written.              read_fct_args (Optional[List]): The list of arguments that are passed to the function                  *read_fct* to read data.              write_fct_args (Optional[List]): The list of arguments that are passed to the function                  *write_fct* to write the data.              scope (Optional[Scope^]): The scope of the Generic data node configuration.<br/>                  The default value is `Scope.SCENARIO`.              validity_period (Optional[timedelta]): The duration 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 configs page](../core/config/task-config.md) for more details).                  If *validity_period* is set to None, the data node is always up-to-date.              **properties (dict[str, any]): A keyworded variable length list of additional arguments.          Returns:              The new Generic data node configuration.          \"\"\"          if read_fct is not None:              properties[cls._OPTIONAL_READ_FUNCTION_GENERIC_PROPERTY] = read_fct          if write_fct is not None:              properties[cls._OPTIONAL_WRITE_FUNCTION_GENERIC_PROPERTY] = write_fct          if read_fct_args is not None:              properties[cls._OPTIONAL_READ_FUNCTION_ARGS_GENERIC_PROPERTY] = read_fct_args          if write_fct_args is not None:              properties[cls._OPTIONAL_WRITE_FUNCTION_ARGS_GENERIC_PROPERTY] = write_fct_args            return cls.__configure(id, DataNodeConfig._STORAGE_TYPE_VALUE_GENERIC, scope, validity_period, **properties)        @classmethod      def _configure_in_memory(          cls,          id: str,          default_data: Optional[Any] = None,          scope: Optional[Scope] = None,          validity_period: Optional[timedelta] = None,          **properties,      ) -> \"DataNodeConfig\":          \"\"\"Configure a new *in-memory* data node configuration.            Parameters:              id (str): The unique identifier of the new in_memory data node configuration.              default_data (Optional[any]): The default data of the data nodes instantiated from                  this in_memory data node configuration.              scope (Optional[Scope^]): The scope of the in_memory data node configuration.<br/>                  The default value is `Scope.SCENARIO`.              validity_period (Optional[timedelta]): The duration 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 configs page](../core/config/task-config.md) for more details).                  If *validity_period* is set to None, the data node is always up-to-date.              **properties (dict[str, any]): A keyworded variable length list of additional arguments.            Returns:              The new *in-memory* data node configuration.          \"\"\"          if default_data is not None:              properties[cls._OPTIONAL_DEFAULT_DATA_IN_MEMORY_PROPERTY] = default_data            return cls.__configure(id, DataNodeConfig._STORAGE_TYPE_VALUE_IN_MEMORY, scope, validity_period, **properties)        @classmethod      def _configure_pickle(          cls,          id: str,          default_path: Optional[str] = None,          default_data: Optional[Any] = None,          scope: Optional[Scope] = None,          validity_period: Optional[timedelta] = None,          **properties,      ) -> \"DataNodeConfig\":          \"\"\"Configure a new pickle data node configuration.            Parameters:              id (str): The unique identifier of the new pickle data node configuration.              default_path (Optional[str]): The path of the pickle file.              default_data (Optional[any]): The default data of the data nodes instantiated from                  this pickle data node configuration.              scope (Optional[Scope^]): The scope of the pickle data node configuration.<br/>                  The default value is `Scope.SCENARIO`.              validity_period (Optional[timedelta]): The duration 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 configs page](../core/config/task-config.md) for more details).                  If *validity_period* is set to None, the data node is always up-to-date.              **properties (dict[str, any]): A keyworded variable length list of additional arguments.            Returns:              The new pickle data node configuration.          \"\"\"          if default_path is not None:              properties[cls._OPTIONAL_DEFAULT_PATH_PICKLE_PROPERTY] = default_path          if default_data is not None:              properties[cls._OPTIONAL_DEFAULT_DATA_PICKLE_PROPERTY] = default_data            return cls.__configure(id, DataNodeConfig._STORAGE_TYPE_VALUE_PICKLE, scope, validity_period, **properties)        @classmethod      def _configure_sql_table(          cls,          id: str,          db_name: str,          db_engine: str,          table_name: str,          db_username: Optional[str] = None,          db_password: Optional[str] = None,          db_host: Optional[str] = None,          db_port: Optional[int] = None,          db_driver: Optional[str] = None,          sqlite_folder_path: Optional[str] = None,          sqlite_file_extension: Optional[str] = None,          db_extra_args: Optional[Dict[str, Any]] = None,          exposed_type: Optional[str] = None,          scope: Optional[Scope] = None,          validity_period: Optional[timedelta] = None,          **properties,      ) -> \"DataNodeConfig\":          \"\"\"Configure a new SQL table data node configuration.            Parameters:              id (str): The unique identifier of the new SQL data node configuration.              db_name (str): The database name, or the name of the SQLite database file.              db_engine (str): The database engine. Possible values are *\"sqlite\"*, *\"mssql\"*, *\"mysql\"*,                  or *\"postgresql\"*.              table_name (str): The name of the SQL table.              db_username (Optional[str]): The database username. Required by the *\"mssql\"*, *\"mysql\"*, and                  *\"postgresql\"* engines.              db_password (Optional[str]): The database password. Required by the *\"mssql\"*, *\"mysql\"*, and                  *\"postgresql\"* engines.              db_host (Optional[str]): The database host.<br/>                  The default value is \"localhost\".              db_port (Optional[int]): The database port.<br/>                  The default value is 1433.              db_driver (Optional[str]): The database driver.              sqlite_folder_path (Optional[str]): The path to the folder that contains SQLite file.<br/>                  The default value is the current working folder.              sqlite_file_extension (Optional[str]): The file extension of the SQLite file.<br/>                  The default value is \".db\".              db_extra_args (Optional[dict[str, any]]): A dictionary of additional arguments to be passed                  into database connection string.              exposed_type (Optional[str]): The exposed type of the data read from SQL table.<br/>                  The default value is \"pandas\".              scope (Optional[Scope^]): The scope of the SQL data node configuration.<br/>                  The default value is `Scope.SCENARIO`.              validity_period (Optional[timedelta]): The duration 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 configs page](../core/config/task-config.md) for more details).                  If *validity_period* is set to None, the data node is always up-to-date.              **properties (dict[str, any]): A keyworded variable length list of additional arguments.            Returns:              The new SQL data node configuration.          \"\"\"          properties.update(              {                  cls._REQUIRED_DB_NAME_SQL_PROPERTY: db_name,                  cls._REQUIRED_DB_ENGINE_SQL_PROPERTY: db_engine,                  cls._REQUIRED_TABLE_NAME_SQL_TABLE_PROPERTY: table_name,              }          )            if db_username is not None:              properties[cls._OPTIONAL_DB_USERNAME_SQL_PROPERTY] = db_username          if db_password is not None:              properties[cls._OPTIONAL_DB_PASSWORD_SQL_PROPERTY] = db_password          if db_host is not None:              properties[cls._OPTIONAL_HOST_SQL_PROPERTY] = db_host          if db_port is not None:              properties[cls._OPTIONAL_PORT_SQL_PROPERTY] = db_port          if db_driver is not None:              properties[cls._OPTIONAL_DRIVER_SQL_PROPERTY] = db_driver          if sqlite_folder_path is not None:              properties[cls._OPTIONAL_FOLDER_PATH_SQLITE_PROPERTY] = sqlite_folder_path          if sqlite_file_extension is not None:              properties[cls._OPTIONAL_FILE_EXTENSION_SQLITE_PROPERTY] = sqlite_file_extension          if db_extra_args is not None:              properties[cls._OPTIONAL_DB_EXTRA_ARGS_SQL_PROPERTY] = db_extra_args          if exposed_type is not None:              properties[cls._OPTIONAL_EXPOSED_TYPE_SQL_PROPERTY] = exposed_type            return cls.__configure(id, DataNodeConfig._STORAGE_TYPE_VALUE_SQL_TABLE, scope, validity_period, **properties)        @classmethod      def _configure_sql(          cls,          id: str,          db_name: str,          db_engine: str,          read_query: str,          write_query_builder: Callable,          append_query_builder: Optional[Callable] = None,          db_username: Optional[str] = None,          db_password: Optional[str] = None,          db_host: Optional[str] = None,          db_port: Optional[int] = None,          db_driver: Optional[str] = None,          sqlite_folder_path: Optional[str] = None,          sqlite_file_extension: Optional[str] = None,          db_extra_args: Optional[Dict[str, Any]] = None,          exposed_type: Optional[str] = None,          scope: Optional[Scope] = None,          validity_period: Optional[timedelta] = None,          **properties,      ) -> \"DataNodeConfig\":          \"\"\"Configure a new SQL data node configuration.            Parameters:              id (str): The unique identifier of the new SQL data node configuration.              db_name (str): The database name, or the name of the SQLite database file.              db_engine (str): The database engine. Possible values are *\"sqlite\"*, *\"mssql\"*, *\"mysql\"*,                  or *\"postgresql\"*.              read_query (str): The SQL query string used to read the data from the database.              write_query_builder (Callable): A callback function that takes the data as an input parameter                  and returns a list of SQL queries to be executed when writing data to the data node.              append_query_builder (Optional[Callable]): A callback function that takes the data as an input parameter                  and returns a list of SQL queries to be executed when appending data to the data node.              db_username (Optional[str]): The database username. Required by the *\"mssql\"*, *\"mysql\"*, and                  *\"postgresql\"* engines.              db_password (Optional[str]): The database password. Required by the *\"mssql\"*, *\"mysql\"*, and                  *\"postgresql\"* engines.              db_host (Optional[str]): The database host.<br/>                  The default value is \"localhost\".              db_port (Optional[int]): The database port.<br/>                  The default value is 1433.              db_driver (Optional[str]): The database driver.              sqlite_folder_path (Optional[str]): The path to the folder that contains SQLite file.<br/>                  The default value is the current working folder.              sqlite_file_extension (Optional[str]): The file extension of the SQLite file.<br/>                  The default value is \".db\".              db_extra_args (Optional[dict[str, any]]): A dictionary of additional arguments to be passed                  into database connection string.              exposed_type (Optional[str]): The exposed type of the data read from SQL query.<br/>                  The default value is \"pandas\".              scope (Optional[Scope^]): The scope of the SQL data node configuration.<br/>                  The default value is `Scope.SCENARIO`.              validity_period (Optional[timedelta]): The duration 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 configs page](../core/config/task-config.md) for more details).                  If *validity_period* is set to None, the data node is always up-to-date.              **properties (dict[str, any]): A keyworded variable length list of additional arguments.          Returns:              The new SQL data node configuration.          \"\"\"          properties.update(              {                  cls._REQUIRED_DB_NAME_SQL_PROPERTY: db_name,                  cls._REQUIRED_DB_ENGINE_SQL_PROPERTY: db_engine,                  cls._REQUIRED_READ_QUERY_SQL_PROPERTY: read_query,                  cls._REQUIRED_WRITE_QUERY_BUILDER_SQL_PROPERTY: write_query_builder,              }          )            if append_query_builder is not None:              properties[cls._OPTIONAL_APPEND_QUERY_BUILDER_SQL_PROPERTY] = append_query_builder          if db_username is not None:              properties[cls._OPTIONAL_DB_USERNAME_SQL_PROPERTY] = db_username          if db_password is not None:              properties[cls._OPTIONAL_DB_PASSWORD_SQL_PROPERTY] = db_password          if db_host is not None:              properties[cls._OPTIONAL_HOST_SQL_PROPERTY] = db_host          if db_port is not None:              properties[cls._OPTIONAL_PORT_SQL_PROPERTY] = db_port          if db_driver is not None:              properties[cls._OPTIONAL_DRIVER_SQL_PROPERTY] = db_driver          if sqlite_folder_path is not None:              properties[cls._OPTIONAL_FOLDER_PATH_SQLITE_PROPERTY] = sqlite_folder_path          if sqlite_file_extension is not None:              properties[cls._OPTIONAL_FILE_EXTENSION_SQLITE_PROPERTY] = sqlite_file_extension          if db_extra_args is not None:              properties[cls._OPTIONAL_DB_EXTRA_ARGS_SQL_PROPERTY] = db_extra_args          if exposed_type is not None:              properties[cls._OPTIONAL_EXPOSED_TYPE_SQL_PROPERTY] = exposed_type            return cls.__configure(id, DataNodeConfig._STORAGE_TYPE_VALUE_SQL, scope, validity_period, **properties)        @classmethod      def _configure_mongo_collection(          cls,          id: str,          db_name: str,          collection_name: str,          custom_document: Optional[Any] = None,          db_username: Optional[str] = None,          db_password: Optional[str] = None,          db_host: Optional[str] = None,          db_port: Optional[int] = None,          db_driver: Optional[str] = None,          db_extra_args: Optional[Dict[str, Any]] = None,          scope: Optional[Scope] = None,          validity_period: Optional[timedelta] = None,          **properties,      ) -> \"DataNodeConfig\":          \"\"\"Configure a new Mongo collection data node configuration.            Parameters:              id (str): The unique identifier of the new Mongo collection data node configuration.              db_name (str): The database name.              collection_name (str): The collection in the database to read from and to write the data to.              custom_document (Optional[any]): The custom document class to store, encode, and decode data                  when reading and writing to a Mongo collection. The custom_document can have an optional                  *decode()* method to decode data in the Mongo collection to a custom object, and an                  optional *encode()*) method to encode the object's properties to the Mongo collection                  when writing.              db_username (Optional[str]): The database username.              db_password (Optional[str]): The database password.              db_host (Optional[str]): The database host.<br/>                  The default value is \"localhost\".              db_port (Optional[int]): The database port.<br/>                  The default value is 27017.              db_driver (Optional[str]): The database driver.              db_extra_args (Optional[dict[str, any]]): A dictionary of additional arguments to be passed                  into database connection string.              scope (Optional[Scope^]): The scope of the Mongo collection data node configuration.<br/>                  The default value is `Scope.SCENARIO`.              validity_period (Optional[timedelta]): The duration 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 configs page](../core/config/task-config.md) for more details).                  If *validity_period* is set to None, the data node is always up-to-date.              **properties (dict[str, any]): A keyworded variable length list of additional arguments.            Returns:              The new Mongo collection data node configuration.          \"\"\"          properties.update(              {                  cls._REQUIRED_DB_NAME_MONGO_PROPERTY: db_name,                  cls._REQUIRED_COLLECTION_NAME_MONGO_PROPERTY: collection_name,              }          )            if custom_document is not None:              properties[cls._OPTIONAL_CUSTOM_DOCUMENT_MONGO_PROPERTY] = custom_document          if db_username is not None:              properties[cls._OPTIONAL_USERNAME_MONGO_PROPERTY] = db_username          if db_password is not None:              properties[cls._OPTIONAL_PASSWORD_MONGO_PROPERTY] = db_password          if db_host is not None:              properties[cls._OPTIONAL_HOST_MONGO_PROPERTY] = db_host          if db_port is not None:              properties[cls._OPTIONAL_PORT_MONGO_PROPERTY] = db_port          if db_driver is not None:              properties[cls._OPTIONAL_DRIVER_MONGO_PROPERTY] = db_driver          if db_extra_args is not None:              properties[cls._OPTIONAL_DB_EXTRA_ARGS_MONGO_PROPERTY] = db_extra_args            return cls.__configure(              id, DataNodeConfig._STORAGE_TYPE_VALUE_MONGO_COLLECTION, scope, validity_period, **properties          )        @staticmethod      def __configure(          id: str,          storage_type: Optional[str] = None,          scope: Optional[Scope] = None,          validity_period: Optional[timedelta] = None,          **properties,      ):          section = DataNodeConfig(id, storage_type, scope, validity_period, **properties)          Config._register(section)          return Config.sections[DataNodeConfig.name][id] "}
{"text": "from copy import copy  from typing import Any, Dict, List, 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 ..common._warnings import _warn_deprecated  from .data_node_config import DataNodeConfig      class TaskConfig(Section):      \"\"\"      Configuration fields needed to instantiate an actual `Task^`.        Attributes:          id (str): Identifier of the task config. Must be a valid Python variable name.          inputs (Union[DataNodeConfig^, List[DataNodeConfig^]]): The optional list of              `DataNodeConfig^` inputs.<br/>              The default value is [].          outputs (Union[DataNodeConfig^, List[DataNodeConfig^]]): The optional list of              `DataNodeConfig^` outputs.<br/>              The default value is [].          skippable (bool): If True, indicates that the task can be skipped if no change has              been made on inputs.<br/>              The default value is False.          function (Callable): User function taking as inputs some parameters compatible with the              exposed types (*exposed_type* field) of the input data nodes and returning results              compatible with the exposed types (*exposed_type* field) of the outputs list.<br/>              The default value is None.          **properties (dict[str, any]): A dictionary of additional properties.      \"\"\"        name = \"TASK\"        _INPUT_KEY = \"inputs\"      _FUNCTION = \"function\"      _OUTPUT_KEY = \"outputs\"      _IS_SKIPPABLE_KEY = \"skippable\"        def __init__(          self,          id: str,          function,          inputs: Optional[Union[DataNodeConfig, List[DataNodeConfig]]] = None,          outputs: Optional[Union[DataNodeConfig, List[DataNodeConfig]]] = None,          skippable: Optional[bool] = False,          **properties,      ):          if inputs:              self._inputs = [inputs] if isinstance(inputs, DataNodeConfig) else copy(inputs)          else:              self._inputs = []          if outputs:              self._outputs = [outputs] if isinstance(outputs, DataNodeConfig) else copy(outputs)              outputs_all_cacheable = all(output.cacheable for output in self._outputs)              if not skippable and outputs_all_cacheable:                  _warn_deprecated(\"cacheable\", suggest=\"the skippable feature\")                  skippable = True          else:              self._outputs = []          self._skippable = skippable          self.function = function          super().__init__(id, **properties)        def __copy__(self):          return TaskConfig(              self.id, self.function, copy(self._inputs), copy(self._outputs), self.skippable, **copy(self._properties)          )        def __getattr__(self, item: str) -> Optional[Any]:          return _tpl._replace_templates(self._properties.get(item))        @property      def input_configs(self) -> List[DataNodeConfig]:          return list(self._inputs)        @property      def inputs(self) -> List[DataNodeConfig]:          return list(self._inputs)        @property      def output_configs(self) -> List[DataNodeConfig]:          return list(self._outputs)        @property      def outputs(self) -> List[DataNodeConfig]:          return list(self._outputs)        @property      def skippable(self):          return _tpl._replace_templates(self._skippable)        @classmethod      def default_config(cls):          return TaskConfig(cls._DEFAULT_KEY, None, [], [], False)        def _clean(self):          self.function = None          self._inputs = []          self._outputs = []          self._skippable = False          self._properties.clear()        def _to_dict(self):          return {              self._FUNCTION: self.function,              self._INPUT_KEY: self._inputs,              self._OUTPUT_KEY: self._outputs,              self._IS_SKIPPABLE_KEY: self._skippable,              **self._properties,          }        @classmethod      def _from_dict(cls, as_dict: Dict[str, Any], id: str, config: Optional[_Config]):          as_dict.pop(cls._ID_KEY, id)          funct = as_dict.pop(cls._FUNCTION, None)          dn_configs = config._sections.get(DataNodeConfig.name, None) or []  # type: ignore          inputs = []          if inputs_as_str := as_dict.pop(cls._INPUT_KEY, None):              inputs = [dn_configs[dn_id] for dn_id in inputs_as_str if dn_id in dn_configs]          outputs = []          if outputs_as_str := as_dict.pop(cls._OUTPUT_KEY, None):              outputs = [dn_configs[ds_id] for ds_id in outputs_as_str if ds_id in dn_configs]          skippable = as_dict.pop(cls._IS_SKIPPABLE_KEY, False)          return TaskConfig(id=id, function=funct, inputs=inputs, outputs=outputs, skippable=skippable, **as_dict)        def _update(self, as_dict, default_section=None):          function = as_dict.pop(self._FUNCTION, None)          if function is not None and type(function) is not str:              self.function = function          self._inputs = as_dict.pop(self._INPUT_KEY, self._inputs)          if self._inputs is None and default_section:              self._inputs = default_section._inputs          self._outputs = as_dict.pop(self._OUTPUT_KEY, self._outputs)          if self._outputs is None and default_section:              self._outputs = default_section._outputs          self._skippable = as_dict.pop(self._IS_SKIPPABLE_KEY, self._skippable)          self._properties.update(as_dict)          if default_section:              self._properties = {**default_section.properties, **self._properties}        @staticmethod      def _configure(          id: str,          function,          input: Optional[Union[DataNodeConfig, List[DataNodeConfig]]] = None,          output: Optional[Union[DataNodeConfig, List[DataNodeConfig]]] = None,          skippable: Optional[bool] = False,          **properties,      ) -> \"TaskConfig\":          \"\"\"Configure a new task configuration.            Parameters:              id (str): The unique identifier of this task configuration.              function (Callable): The python function called by Taipy to run the task.              input (Optional[Union[DataNodeConfig^, List[DataNodeConfig^]]]): The list of the                  function input data node configurations. This can be a unique data node                  configuration if there is a single input data node, or None if there are none.              output (Optional[Union[DataNodeConfig^, List[DataNodeConfig^]]]): The list of the                  function output data node configurations. This can be a unique data node                  configuration if there is a single output data node, or None if there are none.              skippable (bool): If True, indicates that the task can be skipped if no change has                  been made on inputs.<br/>                  The default value is False.              **properties (dict[str, any]): A keyworded variable length list of additional arguments.            Returns:              The new task configuration.          \"\"\"          section = TaskConfig(id, function, input, output, skippable, **properties)          Config._register(section)          return Config.sections[TaskConfig.name][id]        @staticmethod      def _set_default_configuration(          function,          input: Optional[Union[DataNodeConfig, List[DataNodeConfig]]] = None,          output: Optional[Union[DataNodeConfig, List[DataNodeConfig]]] = None,          skippable: Optional[bool] = False,          **properties,      ) -> \"TaskConfig\":          \"\"\"Set the default values for task configurations.            This function creates the *default task configuration* object,          where all task configuration objects will find their default          values when needed.            Parameters:              function (Callable): The python function called by Taipy to run the task.              input (Optional[Union[DataNodeConfig^, List[DataNodeConfig^]]]): The list of the                  input data node configurations. This can be a unique data node                  configuration if there is a single input data node, or None if there are none.              output (Optional[Union[DataNodeConfig^, List[DataNodeConfig^]]]): The list of the                  output data node configurations. This can be a unique data node                  configuration if there is a single output data node, or None if there are none.              skippable (bool): If True, indicates that the task can be skipped if no change has                  been made on inputs.<br/>                  The default value is False.              **properties (dict[str, any]): A keyworded variable length list of additional                  arguments.          Returns:              The default task configuration.          \"\"\"          section = TaskConfig(_Config.DEFAULT_KEY, function, input, output, skippable, **properties)          Config._register(section)          return Config.sections[TaskConfig.name][_Config.DEFAULT_KEY] "}
{"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 import Config  from taipy.config._config import _Config  from taipy.config.checker._checkers._config_checker import _ConfigChecker  from taipy.config.checker.issue_collector import IssueCollector  from taipy.config.common.frequency import Frequency    from ..data_node_config import DataNodeConfig  from ..scenario_config import ScenarioConfig  from ..task_config import TaskConfig      class _ScenarioConfigChecker(_ConfigChecker):      def __init__(self, config: _Config, collector: IssueCollector):          super().__init__(config, collector)        def _check(self) -> IssueCollector:          scenario_configs = self._config._sections[ScenarioConfig.name]          for scenario_config_id, scenario_config in scenario_configs.items():              if scenario_config_id != _Config.DEFAULT_KEY:                  self._check_if_entity_property_key_used_is_predefined(scenario_config)                  self._check_existing_config_id(scenario_config)                  self._check_frequency(scenario_config_id, scenario_config)                  self._check_task_configs(scenario_config_id, scenario_config)                  self._check_addition_data_node_configs(scenario_config_id, scenario_config)                  self._check_additional_dns_not_overlapping_tasks_dns(scenario_config_id, scenario_config)                  self._check_tasks_in_sequences_exist_in_scenario_tasks(scenario_config_id, scenario_config)                  self._check_comparators(scenario_config_id, scenario_config)            return self._collector        def _check_task_configs(self, scenario_config_id: str, scenario_config: ScenarioConfig):          self._check_children(              ScenarioConfig,              scenario_config_id,              scenario_config._TASKS_KEY,              scenario_config.tasks,              TaskConfig,          )        def _check_addition_data_node_configs(self, scenario_config_id: str, scenario_config: ScenarioConfig):          self._check_children(              ScenarioConfig,              scenario_config_id,              scenario_config._ADDITIONAL_DATA_NODES_KEY,              scenario_config.additional_data_nodes,              DataNodeConfig,              can_be_empty=True,          )        def _check_frequency(self, scenario_config_id: str, scenario_config: ScenarioConfig):          if scenario_config.frequency and not isinstance(scenario_config.frequency, Frequency):              self._error(                  scenario_config._FREQUENCY_KEY,                  scenario_config.frequency,                  f\"{scenario_config._FREQUENCY_KEY} field of ScenarioConfig `{scenario_config_id}` must be\"                  f\" populated with a Frequency value.\",              )        def _check_comparators(self, scenario_config_id: str, scenario_config: ScenarioConfig):          if scenario_config.comparators is not None and not isinstance(scenario_config.comparators, dict):              self._error(                  ScenarioConfig._COMPARATOR_KEY,                  scenario_config.comparators,                  f\"{ScenarioConfig._COMPARATOR_KEY} field of ScenarioConfig\"                  f\" `{scenario_config_id}` must be populated with a dictionary value.\",              )          else:              for data_node_id, comparator in scenario_config.comparators.items():                  if data_node_id not in Config.data_nodes:                      self._error(                          ScenarioConfig._COMPARATOR_KEY,                          scenario_config.comparators,                          f\"The key `{data_node_id}` in {ScenarioConfig._COMPARATOR_KEY} field of ScenarioConfig\"                          f\" `{scenario_config_id}` must be populated with a valid data node configuration id.\",                      )                  if not callable(comparator):                      if not isinstance(comparator, list) or not all(callable(comp) for comp in comparator):                          self._error(                              ScenarioConfig._COMPARATOR_KEY,                              scenario_config.comparators,                              f\"The value of `{data_node_id}` in {ScenarioConfig._COMPARATOR_KEY} field of ScenarioConfig\"                              f\" `{scenario_config_id}` must be populated with a list of Callable values.\",                          )        def _check_additional_dns_not_overlapping_tasks_dns(self, scenario_config_id: str, scenario_config: ScenarioConfig):          data_node_configs = set()          for task_config in scenario_config.task_configs:              if isinstance(task_config, TaskConfig):                  input_dn_configs = task_config.input_configs if task_config.input_configs else []                  output_dn_configs = task_config.output_configs if task_config.output_configs else []                  data_node_configs.update({*input_dn_configs, *output_dn_configs})            for additional_data_node_config in scenario_config.additional_data_node_configs:              if additional_data_node_config in data_node_configs:                  self._warning(                      ScenarioConfig._ADDITIONAL_DATA_NODES_KEY,                      scenario_config.additional_data_node_configs,                      f\"The additional data node `{additional_data_node_config.id}` in\"                      f\" {ScenarioConfig._ADDITIONAL_DATA_NODES_KEY} field of ScenarioConfig\"                      f\" `{scenario_config_id}` has already existed as an input or output data node of\"                      f\" ScenarioConfig `{scenario_config_id}` tasks.\",                  )        def _check_tasks_in_sequences_exist_in_scenario_tasks(          self, scenario_config_id: str, scenario_config: ScenarioConfig      ):          scenario_task_ids = set()          for task_config in scenario_config.tasks:              if isinstance(task_config, TaskConfig):                  scenario_task_ids.add(task_config.id)          for sequence_tasks in scenario_config.sequences.values():              self._check_children(                  ScenarioConfig,                  scenario_config_id,                  scenario_config._SEQUENCES_KEY,                  sequence_tasks,                  TaskConfig,                  can_be_empty=True,              )              for task in sequence_tasks:                  if isinstance(task, TaskConfig) and task.id not in scenario_task_ids:                      self._error(                          ScenarioConfig._SEQUENCES_KEY,                          scenario_config.sequences,                          f\"The task `{task.id}` in {ScenarioConfig._SEQUENCES_KEY} field of ScenarioConfig\"                          f\" `{scenario_config_id}` must exist in {ScenarioConfig._TASKS_KEY} field of ScenarioConfig\"                          f\" `{scenario_config_id}`.\",                      ) "}
{"text": "from datetime import timedelta  from typing import Dict    from taipy.config._config import _Config  from taipy.config.checker._checker import _ConfigChecker  from taipy.config.checker.issue_collector import IssueCollector  from taipy.config.common.scope import Scope    from ..data_node_config import DataNodeConfig      class _DataNodeConfigChecker(_ConfigChecker):      def __init__(self, config: _Config, collector: IssueCollector):          super().__init__(config, collector)        def _check(self) -> IssueCollector:          data_node_configs: Dict[str, DataNodeConfig] = self._config._sections[DataNodeConfig.name]          for data_node_config_id, data_node_config in data_node_configs.items():              self._check_existing_config_id(data_node_config)              self._check_if_entity_property_key_used_is_predefined(data_node_config)              self._check_storage_type(data_node_config_id, data_node_config)              self._check_scope(data_node_config_id, data_node_config)              self._check_validity_period(data_node_config_id, data_node_config)              self._check_required_properties(data_node_config_id, data_node_config)              self._check_callable(data_node_config_id, data_node_config)              self._check_generic_read_write_fct_and_args(data_node_config_id, data_node_config)              self._check_exposed_type(data_node_config_id, data_node_config)          return self._collector        def _check_storage_type(self, data_node_config_id: str, data_node_config: DataNodeConfig):          if data_node_config.storage_type not in DataNodeConfig._ALL_STORAGE_TYPES:              self._error(                  data_node_config._STORAGE_TYPE_KEY,                  data_node_config.storage_type,                  f\"`{data_node_config._STORAGE_TYPE_KEY}` field of DataNodeConfig `{data_node_config_id}` must be\"                  f\" either csv, sql_table, sql, mongo_collection, pickle, excel, generic, json, parquet, or in_memory.\",              )        def _check_scope(self, data_node_config_id: str, data_node_config: DataNodeConfig):          if not isinstance(data_node_config.scope, Scope):              self._error(                  data_node_config._SCOPE_KEY,                  data_node_config.scope,                  f\"`{data_node_config._SCOPE_KEY}` field of DataNodeConfig `{data_node_config_id}` must be\"                  f\" populated with a Scope value.\",              )        def _check_validity_period(self, data_node_config_id: str, data_node_config: DataNodeConfig):          if data_node_config.validity_period and not isinstance(data_node_config.validity_period, timedelta):              self._error(                  data_node_config._VALIDITY_PERIOD_KEY,                  data_node_config.validity_period,                  f\"`{data_node_config._VALIDITY_PERIOD_KEY}` field of DataNodeConfig `{data_node_config_id}` must be\"                  f\" None or populated with a timedelta value.\",              )        def _check_required_properties(self, data_node_config_id: str, data_node_config: DataNodeConfig):          if storage_type := data_node_config.storage_type:              if storage_type in DataNodeConfig._REQUIRED_PROPERTIES:                  required_properties = DataNodeConfig._REQUIRED_PROPERTIES[storage_type]                  if storage_type == DataNodeConfig._STORAGE_TYPE_VALUE_SQL:                      if data_node_config.properties:                          if engine := data_node_config.properties.get(DataNodeConfig._REQUIRED_DB_ENGINE_SQL_PROPERTY):                              if engine == DataNodeConfig._DB_ENGINE_SQLITE:                                  required_properties = [                                      DataNodeConfig._REQUIRED_DB_NAME_SQL_PROPERTY,                                      DataNodeConfig._REQUIRED_DB_ENGINE_SQL_PROPERTY,                                      DataNodeConfig._REQUIRED_READ_QUERY_SQL_PROPERTY,                                      DataNodeConfig._REQUIRED_WRITE_QUERY_BUILDER_SQL_PROPERTY,                                  ]                              else:                                  required_properties = [                                      DataNodeConfig._OPTIONAL_DB_USERNAME_SQL_PROPERTY,                                      DataNodeConfig._OPTIONAL_DB_PASSWORD_SQL_PROPERTY,                                      DataNodeConfig._REQUIRED_DB_NAME_SQL_PROPERTY,                                      DataNodeConfig._REQUIRED_DB_ENGINE_SQL_PROPERTY,                                      DataNodeConfig._REQUIRED_READ_QUERY_SQL_PROPERTY,                                      DataNodeConfig._REQUIRED_WRITE_QUERY_BUILDER_SQL_PROPERTY,                                  ]                  if storage_type == DataNodeConfig._STORAGE_TYPE_VALUE_SQL_TABLE:                      if data_node_config.properties:                          if engine := data_node_config.properties.get(DataNodeConfig._REQUIRED_DB_ENGINE_SQL_PROPERTY):                              if engine == DataNodeConfig._DB_ENGINE_SQLITE:                                  required_properties = [                                      DataNodeConfig._REQUIRED_DB_NAME_SQL_PROPERTY,                                      DataNodeConfig._REQUIRED_DB_ENGINE_SQL_PROPERTY,                                      DataNodeConfig._REQUIRED_TABLE_NAME_SQL_TABLE_PROPERTY,                                  ]                              else:                                  required_properties = [                                      DataNodeConfig._OPTIONAL_DB_USERNAME_SQL_PROPERTY,                                      DataNodeConfig._OPTIONAL_DB_PASSWORD_SQL_PROPERTY,                                      DataNodeConfig._REQUIRED_DB_NAME_SQL_PROPERTY,                                      DataNodeConfig._REQUIRED_DB_ENGINE_SQL_PROPERTY,                                      DataNodeConfig._REQUIRED_TABLE_NAME_SQL_TABLE_PROPERTY,                                  ]                  for required_property in required_properties:                      if not data_node_config.properties or required_property not in data_node_config.properties:                          if data_node_config_id == DataNodeConfig._DEFAULT_KEY:                              self._warning(                                  required_property,                                  None,                                  f\"DataNodeConfig `{data_node_config_id}` is missing the required \"                                  f\"property `{required_property}` for type `{storage_type}`.\",                              )                          else:                              self._error(                                  required_property,                                  None,                                  f\"DataNodeConfig `{data_node_config_id}` is missing the required \"                                  f\"property `{required_property}` for type `{storage_type}`.\",                              )        def _check_generic_read_write_fct_and_args(self, data_node_config_id: str, data_node_config: DataNodeConfig):          if data_node_config.storage_type == DataNodeConfig._STORAGE_TYPE_VALUE_GENERIC:              properties_to_check = [                  DataNodeConfig._OPTIONAL_READ_FUNCTION_ARGS_GENERIC_PROPERTY,                  DataNodeConfig._OPTIONAL_WRITE_FUNCTION_ARGS_GENERIC_PROPERTY,              ]              for prop_key in properties_to_check:                  if data_node_config.properties and prop_key in data_node_config.properties:                      prop_value = data_node_config.properties[prop_key]                      if not isinstance(prop_value, list):                          self._error(                              prop_key,                              prop_value,                              f\"`{prop_key}` field of DataNodeConfig\"                              f\" `{data_node_config_id}` must be populated with a List value.\",                          )              if data_node_config_id != DataNodeConfig._DEFAULT_KEY:                  properties_to_check_at_least_one = [                      DataNodeConfig._OPTIONAL_READ_FUNCTION_GENERIC_PROPERTY,                      DataNodeConfig._OPTIONAL_WRITE_FUNCTION_GENERIC_PROPERTY,                  ]                  has_at_least_one = False                  for prop_key in properties_to_check_at_least_one:                      if data_node_config.properties and prop_key in data_node_config.properties:                          has_at_least_one = True                  if not has_at_least_one:                      self._error(                          \", \".join(properties_to_check_at_least_one),                          None,                          f\"Either `{DataNodeConfig._OPTIONAL_READ_FUNCTION_GENERIC_PROPERTY}` field or \"                          f\"`{DataNodeConfig._OPTIONAL_WRITE_FUNCTION_GENERIC_PROPERTY}` field of \"                          f\"DataNodeConfig `{data_node_config_id}` must be populated with a Callable function.\",                      )        def _check_callable(self, data_node_config_id: str, data_node_config: DataNodeConfig):          properties_to_check = {              DataNodeConfig._STORAGE_TYPE_VALUE_GENERIC: [                  DataNodeConfig._OPTIONAL_READ_FUNCTION_GENERIC_PROPERTY,                  DataNodeConfig._OPTIONAL_WRITE_FUNCTION_GENERIC_PROPERTY,              ],              DataNodeConfig._STORAGE_TYPE_VALUE_SQL: [                  DataNodeConfig._REQUIRED_WRITE_QUERY_BUILDER_SQL_PROPERTY,                  DataNodeConfig._OPTIONAL_APPEND_QUERY_BUILDER_SQL_PROPERTY,              ],          }            if data_node_config.storage_type in properties_to_check.keys():              for prop_key in properties_to_check[data_node_config.storage_type]:                  prop_value = data_node_config.properties.get(prop_key) if data_node_config.properties else None                  if prop_value and not callable(prop_value):                      self._error(                          prop_key,                          prop_value,                          f\"`{prop_key}` of DataNodeConfig `{data_node_config_id}` must be\"                          f\" populated with a Callable function.\",                      )        def _check_exposed_type(self, data_node_config_id: str, data_node_config: DataNodeConfig):          if not isinstance(data_node_config.exposed_type, str):              return          if data_node_config.exposed_type not in DataNodeConfig._ALL_EXPOSED_TYPES:              self._error(                  data_node_config._EXPOSED_TYPE_KEY,                  data_node_config.exposed_type,                  f\"The `{data_node_config._EXPOSED_TYPE_KEY}` of DataNodeConfig `{data_node_config_id}` \"                  f'must be either \"pandas\", \"modin\", \"numpy\", or a custom type.',              ) "}
{"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": "from queue import SimpleQueue  from typing import Any, Dict, Optional, Set, Tuple    from ._registration import _Registration  from ._topic import _Topic  from .event import Event, EventEntityType, EventOperation      def _publish_event(      entity_type: EventEntityType,      operation: EventOperation,      /,      entity_id: Optional[str] = None,      attribute_name: Optional[str] = None,      attribute_value: Optional[Any] = None,      **kwargs,  ):      \"\"\"Internal helper function to send events.        It basically creates an event corresponding to the given arguments      and send it using `Notifier.publish(event)`        Parameters:          entity_type (EventEntityType^)          operation (EventOperation^)          entity_id (Optional[str])          attribute_name (Optional[str])          attribute_value (Optional[Any])          **kwargs      \"\"\"      event = Event(          entity_id=entity_id,          entity_type=entity_type,          operation=operation,          attribute_name=attribute_name,          attribute_value=attribute_value,          metadata=kwargs,      )      Notifier.publish(event)      class Notifier:      \"\"\"A class for managing event registrations and publishing `Core^` service events.\"\"\"        _topics_registrations_list: Dict[_Topic, Set[_Registration]] = {}        @classmethod      def register(          cls,          entity_type: Optional[EventEntityType] = None,          entity_id: Optional[str] = None,          operation: Optional[EventOperation] = None,          attribute_name: Optional[str] = None,      ) -> Tuple[str, SimpleQueue]:          \"\"\"Register a listener for a specific event topic.            The topic is defined by the combination of the entity type, the entity id,          the operation and the attribute name.            Parameters:              entity_type (Optional[EventEntityType^]): If provided, the listener will                  be notified for all events related to this entity type. Otherwise,                  the listener will be notified for events related to all entity types.                  <br>                  The possible entity type values are defined in the `EventEntityType^`                  enum. The possible values are:                  <ul>                      <li>CYCLE</li>                      <li>SCENARIO</li>                      <li>SEQUENCE</li>                      <li>TASK</li>                      <li>DATA_NODE</li>                      <li>JOB</li>                  </ul>              entity_id (Optional[str]): If provided, the listener will be notified                  for all events related to this entity. Otherwise, the listener                  will be notified for events related to all entities.              operation (Optional[EventOperation^]): If provided, the listener will                  be notified for all events related to this operation. Otherwise,                  the listener will be notified for events related to all operations.                  <br>                  The possible operation values are defined in the `EventOperation^`                  enum. The possible values are:                  <ul>                      <li>CREATION</li>                      <li>UPDATE</li>                      <li>DELETION</li>                      <li>SUBMISSION</li>                  </ul>              attribute_name (Optional[str]): If provided, the listener will be notified                  for all events related to this entity's attribute. Otherwise, the listener                  will be notified for events related to all attributes.            Returns:              A tuple containing the registration id and the event queue.          \"\"\"          registration = _Registration(entity_type, entity_id, operation, attribute_name)            if registrations := cls._topics_registrations_list.get(registration.topic, None):              registrations.add(registration)          else:              cls._topics_registrations_list[registration.topic] = {registration}            return registration.registration_id, registration.queue        @classmethod      def unregister(cls, registration_id: str):          \"\"\"Unregister a listener.            Parameters:              registration_id (RegistrationId^): The registration id returned by the `register` method.          \"\"\"          to_remove_registration: Optional[_Registration] = None            for _, registrations in cls._topics_registrations_list.items():              for registration in registrations:                  if registration.registration_id == registration_id:                      to_remove_registration = registration                      break            if to_remove_registration:              registrations = cls._topics_registrations_list[to_remove_registration.topic]              registrations.remove(to_remove_registration)              if len(registrations) == 0:                  del cls._topics_registrations_list[to_remove_registration.topic]        @classmethod      def publish(cls, event):          \"\"\"Publish a `Core^` service event to all registered listeners whose topic matches the event.            Parameters:              event (Event^): The event to publish.          \"\"\"          for topic, registrations in cls._topics_registrations_list.items():              if Notifier._is_matching(event, topic):                  for registration in registrations:                      registration.queue.put(event)        @staticmethod      def _is_matching(event: Event, topic: _Topic) -> bool:          \"\"\"Check if an event matches a topic.\"\"\"          if topic.entity_type is not None and event.entity_type != topic.entity_type:              return False          if topic.entity_id is not None and event.entity_id != topic.entity_id:              return False          if topic.operation is not None and event.operation != topic.operation:              return False          if topic.attribute_name is not None and event.attribute_name and event.attribute_name != topic.attribute_name:              return False          return True "}
{"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": "import re  import uuid  from datetime import datetime  from typing import Any, Dict, Optional    from taipy.config.common.frequency import Frequency    from .._entity._entity import _Entity  from .._entity._labeled import _Labeled  from .._entity._properties import _Properties  from .._entity._reload import _Reloader, _self_reload, _self_setter  from ..exceptions.exceptions import _SuspiciousFileOperation  from ..notification.event import Event, EventEntityType, EventOperation, _make_event  from .cycle_id import CycleId      class Cycle(_Entity, _Labeled):      \"\"\"An iteration of a recurrent work pattern.        Attributes:          id (str): The unique identifier of the cycle.          frequency (Frequency^): The frequency of this cycle.          creation_date (datetime): The date and time of the creation of this cycle.          start_date (datetime): The date and time of the start of this cycle.          end_date (datetime): The date and time of the end of this cycle.          name (str): The name of this cycle.          properties (dict[str, Any]): A dictionary of additional properties.      \"\"\"        _ID_PREFIX = \"CYCLE\"      __SEPARATOR = \"_\"      _MANAGER_NAME = \"cycle\"        def __init__(          self,          frequency: Frequency,          properties: Dict[str, Any],          creation_date: datetime,          start_date: datetime,          end_date: datetime,          name: Optional[str] = None,          id: Optional[CycleId] = None,      ):          self._frequency = frequency          self._creation_date = creation_date          self._start_date = start_date          self._end_date = end_date          self._name = self._new_name(name)          self.id = id or self._new_id(self._name)          self._properties = _Properties(self, **properties)        def _new_name(self, name: Optional[str] = None) -> str:          if name:              return name          if self._frequency == Frequency.DAILY:              # Example \"Monday, 2. January 2023\"              return self._start_date.strftime(\"%A, %d. %B %Y\")          if self._frequency == Frequency.WEEKLY:              # Example \"Week 01 2023, from 2. January\"              return self._start_date.strftime(\"Week %W %Y, from %d. %B\")          if self._frequency == Frequency.MONTHLY:              # Example \"January 2023\"              return self._start_date.strftime(\"%B %Y\")          if self._frequency == Frequency.QUARTERLY:              # Example \"2023 Q1\"              return f\"{self._start_date.strftime('%Y')} Q{(self._start_date.month-1)//3+1}\"          if self._frequency == Frequency.YEARLY:              # Example \"2023\"              return self._start_date.strftime(\"%Y\")          return Cycle.__SEPARATOR.join([str(self._frequency.value), self._start_date.ctime()])        @property  # type: ignore      @_self_reload(_MANAGER_NAME)      def frequency(self):          return self._frequency        @frequency.setter  # type: ignore      @_self_setter(_MANAGER_NAME)      def frequency(self, val):          self._frequency = val        @property  # type: ignore      @_self_reload(_MANAGER_NAME)      def creation_date(self):          return self._creation_date        @creation_date.setter  # type: ignore      @_self_setter(_MANAGER_NAME)      def creation_date(self, val):          self._creation_date = val        @property  # type: ignore      @_self_reload(_MANAGER_NAME)      def start_date(self):          return self._start_date        @start_date.setter  # type: ignore      @_self_setter(_MANAGER_NAME)      def start_date(self, val):          self._start_date = val        @property  # type: ignore      @_self_reload(_MANAGER_NAME)      def end_date(self):          return self._end_date        @end_date.setter  # type: ignore      @_self_setter(_MANAGER_NAME)      def end_date(self, val):          self._end_date = val        @property  # type: ignore      @_self_reload(_MANAGER_NAME)      def name(self):          return self._name        @name.setter  # type: ignore      @_self_setter(_MANAGER_NAME)      def name(self, val):          self._name = val        @property      def properties(self):          self._properties = _Reloader()._reload(self._MANAGER_NAME, self)._properties          return self._properties        @staticmethod      def _new_id(name: str) -> CycleId:          def _get_valid_filename(name: str) -> str:              \"\"\"              Source: https://github.com/django/django/blob/main/django/utils/text.py              \"\"\"              s = str(name).strip().replace(\" \", \"_\")              s = re.sub(r\"(?u)[^-\\w.]\", \"\", s)              if s in {\"\", \".\", \"..\"}:                  raise _SuspiciousFileOperation(\"Could not derive file name from '%s'\" % name)              s = str(s).strip().replace(\" \", \"_\")              return re.sub(r\"(?u)[^-\\w.]\", \"\", s)            return CycleId(_get_valid_filename(Cycle.__SEPARATOR.join([Cycle._ID_PREFIX, name, str(uuid.uuid4())])))        def __getattr__(self, attribute_name):          protected_attribute_name = attribute_name          if protected_attribute_name in self._properties:              return self._properties[protected_attribute_name]          raise AttributeError(f\"{attribute_name} is not an attribute of cycle {self.id}\")        def __eq__(self, other):          return self.id == other.id        def __hash__(self):          return hash(self.id)        def get_label(self) -> str:          \"\"\"Returns the cycle label.            Returns:              The label of the cycle as a string.          \"\"\"          return self._get_label()        def get_simple_label(self) -> str:          \"\"\"Returns the cycle simple label.            Returns:              The simple label of the cycle as a string.          \"\"\"          return self._get_simple_label()      @_make_event.register(Cycle)  def _make_event_for_cycle(      cycle: Cycle,      operation: EventOperation,      /,      attribute_name: Optional[str] = None,      attribute_value: Optional[Any] = None,      **kwargs,  ) -> Event:      metadata = {**kwargs}      return Event(          entity_type=EventEntityType.CYCLE,          entity_id=cycle.id,          operation=operation,          attribute_name=attribute_name,          attribute_value=attribute_value,          metadata=metadata,      ) "}
{"text": "import calendar  from datetime import datetime, time, timedelta  from typing import Callable, Dict, List, Optional    from taipy.config.common.frequency import Frequency    from .._entity._entity_ids import _EntityIds  from .._manager._manager import _Manager  from .._repository._abstract_repository import _AbstractRepository  from ..job._job_manager_factory import _JobManagerFactory  from ..notification import EventEntityType, EventOperation, _publish_event  from ..submission._submission_manager_factory import _SubmissionManagerFactory  from .cycle import Cycle  from .cycle_id import CycleId      class _CycleManager(_Manager[Cycle]):      _ENTITY_NAME = Cycle.__name__      _repository: _AbstractRepository      _EVENT_ENTITY_TYPE = EventEntityType.CYCLE        @classmethod      def _create(          cls, frequency: Frequency, name: Optional[str] = None, creation_date: Optional[datetime] = None, **properties      ):          creation_date = creation_date if creation_date else datetime.now()          start_date = _CycleManager._get_start_date_of_cycle(frequency, creation_date)          end_date = _CycleManager._get_end_date_of_cycle(frequency, start_date)          cycle = Cycle(              frequency, properties, creation_date=creation_date, start_date=start_date, end_date=end_date, name=name          )          cls._set(cycle)          _publish_event(              cls._EVENT_ENTITY_TYPE,              EventOperation.CREATION,              entity_id=cycle.id,          )          return cycle        @classmethod      def _get_or_create(          cls, frequency: Frequency, creation_date: Optional[datetime] = None, name: Optional[str] = None      ) -> Cycle:          creation_date = creation_date if creation_date else datetime.now()          start_date = _CycleManager._get_start_date_of_cycle(frequency, creation_date)          cycles = cls._get_cycles_by_frequency_and_start_date(              frequency=frequency, start_date=start_date, cycles=cls._get_all()          )          if len(cycles) > 0:              return cycles[0]          else:              return cls._create(frequency=frequency, creation_date=creation_date, name=name)        @staticmethod      def _get_start_date_of_cycle(frequency: Frequency, creation_date: datetime):          start_date = creation_date.date()          start_time = time()          if frequency == Frequency.DAILY:              start_date = start_date          if frequency == Frequency.WEEKLY:              start_date = start_date - timedelta(days=start_date.weekday())          if frequency == Frequency.MONTHLY:              start_date = start_date.replace(day=1)          if frequency == Frequency.YEARLY:              start_date = start_date.replace(day=1, month=1)          return datetime.combine(start_date, start_time)        @staticmethod      def _get_end_date_of_cycle(frequency: Frequency, start_date: datetime):          end_date = start_date          if frequency == Frequency.DAILY:              end_date = end_date + timedelta(days=1)          if frequency == Frequency.WEEKLY:              end_date = end_date + timedelta(7 - end_date.weekday())          if frequency == Frequency.MONTHLY:              last_day_of_month = calendar.monthrange(start_date.year, start_date.month)[1]              end_date = end_date.replace(day=last_day_of_month) + timedelta(days=1)          if frequency == Frequency.YEARLY:              end_date = end_date.replace(month=12, day=31) + timedelta(days=1)          return end_date - timedelta(microseconds=1)        @classmethod      def _hard_delete(cls, cycle_id: CycleId):          cycle = cls._get(cycle_id)          entity_ids_to_delete = cls._get_children_entity_ids(cycle)          entity_ids_to_delete.cycle_ids.add(cycle.id)          cls._delete_entities_of_multiple_types(entity_ids_to_delete)        @classmethod      def _get_children_entity_ids(cls, cycle: Cycle) -> _EntityIds:          from ..scenario._scenario_manager_factory import _ScenarioManagerFactory            entity_ids = _EntityIds()            scenarios = _ScenarioManagerFactory._build_manager()._get_all_by_cycle(cycle)            for scenario in scenarios:              entity_ids.scenario_ids.add(scenario.id)              owner_ids = {scenario.id, cycle.id}              for sequence in scenario.sequences.values():                  if sequence.owner_id in owner_ids:                      entity_ids.sequence_ids.add(sequence.id)              for task in scenario.tasks.values():                  if task.owner_id in owner_ids:                      entity_ids.task_ids.add(task.id)              for data_node in scenario.data_nodes.values():                  if data_node.owner_id in owner_ids:                      entity_ids.data_node_ids.add(data_node.id)            jobs = _JobManagerFactory._build_manager()._get_all()          for job in jobs:              if job.task.id in entity_ids.task_ids:                  entity_ids.job_ids.add(job.id)            submissions = _SubmissionManagerFactory._build_manager()._get_all()          submitted_entity_ids = list(entity_ids.scenario_ids.union(entity_ids.sequence_ids, entity_ids.task_ids))          for submission in submissions:              if submission.entity_id in submitted_entity_ids:                  entity_ids.submission_ids.add(submission.id)            return entity_ids        @classmethod      def _get_cycles_by_frequency_and_start_date(          cls, frequency: Frequency, start_date: datetime, cycles: List[Cycle]      ) -> List[Cycle]:          return cls._get_cycles_cdt(              lambda cycle: cycle.frequency == frequency and cycle.start_date == start_date, cycles          )        @classmethod      def _get_cycles_by_frequency_and_overlapping_date(          cls, frequency: Frequency, date: datetime, cycles: List[Cycle]      ) -> List[Cycle]:          return cls._get_cycles_cdt(              lambda cycle: cycle.frequency == frequency and cycle.start_date <= date <= cycle.end_date, cycles          )        @classmethod      def _get_cycles_cdt(cls, cdt: Callable[[Cycle], bool], cycles: List[Cycle]) -> List[Cycle]:          return [cycle for cycle in cycles if cdt(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. "}
{"text": "#  # Licensed under the Apache License, Version 2.0 (the \"License\"); you may not use this file except in compliance with  # the License. You may obtain a copy of the License at  #  #        http://www.apache.org/licenses/LICENSE-2.0  #  # Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on  # an \"AS IS\" BASIS, WITHOUT 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": "import uuid  from typing import List, Optional, Union    from taipy.config import Config  from taipy.config._config_comparator._comparator_result import _ComparatorResult  from taipy.config.checker.issue_collector import IssueCollector  from taipy.config.exceptions.exceptions import InconsistentEnvVariableError  from taipy.logger._taipy_logger import _TaipyLogger    from .._manager._manager import _Manager  from ..exceptions.exceptions import ConflictedConfigurationError, ModelNotFound, NonExistingVersion  from ._version import _Version  from ._version_fs_repository import _VersionFSRepository      class _VersionManager(_Manager[_Version]):      _ENTITY_NAME = _Version.__name__        __logger = _TaipyLogger._get_logger()        __DEVELOPMENT_VERSION = [\"development\", \"dev\"]      __LATEST_VERSION = \"latest\"      __PRODUCTION_VERSION = \"production\"      __ALL_VERSION = [\"all\", \"\"]        _DEFAULT_VERSION = __LATEST_VERSION        _repository: _VersionFSRepository        @classmethod      def _get(cls, entity: Union[str, _Version], default=None) -> _Version:          \"\"\"          Returns the version entity by id or reference.          \"\"\"          entity_id = entity if isinstance(entity, str) else entity.id          try:              return cls._repository._load(entity_id)          except ModelNotFound:              return default        @classmethod      def _get_or_create(cls, id: str, force: bool) -> _Version:          if version := cls._get(id):              comparator_result = Config._comparator._find_conflict_config(version.config, Config._applied_config, id)              if comparator_result.get(_ComparatorResult.CONFLICTED_SECTION_KEY):                  if force:                      cls.__logger.warning(                          f\"Option --force is detected, overriding the configuration of version {id} ...\"                      )                      version.config = Config._applied_config                  else:                      raise ConflictedConfigurationError()            else:              version = _Version(id=id, config=Config._applied_config)            cls._set(version)          return version        @classmethod      def _get_all(cls, version_number: Optional[Union[str, List]] = \"all\") -> List[_Version]:          \"\"\"          Returns all entities.          \"\"\"          version_number = cls._replace_version_number(version_number)  # type: ignore          if not isinstance(version_number, List):              version_number = [version_number] if version_number else []          filters = [{\"version\": version} for version in version_number]          return cls._repository._load_all(filters)        @classmethod      def _set_development_version(cls, version_number: str) -> str:          cls._get_or_create(version_number, force=True)          cls._repository._set_development_version(version_number)          return version_number        @classmethod      def _get_development_version(cls) -> str:          try:              return cls._repository._get_development_version()          except (FileNotFoundError, ModelNotFound):              return cls._set_development_version(str(uuid.uuid4()))        @classmethod      def _set_experiment_version(cls, version_number: str, force: bool = False) -> str:          if version_number == cls._get_development_version():              raise SystemExit(                  f\"Version number {version_number} is the development version. Please choose a different name\"                  f\" for this experiment.\"              )            if version_number in cls._get_production_versions():              raise SystemExit(                  f\"Version number {version_number} is already a production version. Please choose a different name\"                  f\" for this experiment.\"              )            try:              cls._get_or_create(version_number, force)          except ConflictedConfigurationError:              raise SystemExit(                  f\"Please add a new experiment version or run your application with --force option to\"                  f\" override the Config of experiment {version_number}.\"              )          cls._repository._set_latest_version(version_number)          return version_number        @classmethod      def _get_latest_version(cls) -> str:          try:              return cls._repository._get_latest_version()          except (FileNotFoundError, ModelNotFound):              # If there is no version in the system yet, create a new version as development version              # This set the default versioning behavior on Jupyter notebook to Development mode              return cls._set_development_version(str(uuid.uuid4()))        @classmethod      def _set_production_version(cls, version_number: str, force: bool = False) -> str:          if version_number == cls._get_development_version():              cls._set_development_version(str(uuid.uuid4()))            try:              cls._get_or_create(version_number, force)          except ConflictedConfigurationError:              raise SystemExit(                  f\"Please add a new production version with migration functions.\\n\"                  f\"If old entities remain compatible with the new configuration, you can also run your application with\"                  f\" --force option to override the production configuration of version {version_number}.\"              )          cls._repository._set_production_version(version_number)          return version_number        @classmethod      def _get_production_versions(cls) -> List[str]:          try:              return cls._repository._get_production_versions()          except (FileNotFoundError, ModelNotFound):              return []        @classmethod      def _delete_production_version(cls, version_number) -> str:          return cls._repository._delete_production_version(version_number)        @classmethod      def _replace_version_number(cls, version_number: Optional[str] = None):          if version_number is None:              version_number = cls._replace_version_number(cls._DEFAULT_VERSION)                production_versions = cls._get_production_versions()              if version_number in production_versions:                  return production_versions                return version_number            if version_number == cls.__LATEST_VERSION:              return cls._get_latest_version()          if version_number in cls.__DEVELOPMENT_VERSION:              return cls._get_development_version()          if version_number == cls.__PRODUCTION_VERSION:              return cls._get_production_versions()          if version_number in cls.__ALL_VERSION:              return \"\"            try:              if version := cls._get(version_number):                  return version.id          except InconsistentEnvVariableError:  # The version exist but the Config is alternated              return version_number            raise NonExistingVersion(version_number)        @classmethod      def _manage_version(cls):          from ..taipy import clean_all_entities_by_version            if Config.core.mode == \"development\":              current_version_number = cls._get_development_version()              cls.__logger.info(f\"Development mode: Clean all entities of version {current_version_number}\")              clean_all_entities_by_version(current_version_number)              cls._set_development_version(current_version_number)            elif Config.core.mode in [\"experiment\", \"production\"]:              default_version_number = {                  \"experiment\": str(uuid.uuid4()),                  \"production\": cls._get_latest_version(),              }              version_setter = {                  \"experiment\": cls._set_experiment_version,                  \"production\": cls._set_production_version,              }                if Config.core.version_number:                  current_version_number = Config.core.version_number              else:                  current_version_number = default_version_number[Config.core.mode]                version_setter[Config.core.mode](current_version_number, Config.core.force)              if Config.core.mode == \"production\":                  cls.__check_production_migration_config()          else:              raise SystemExit(f\"Undefined execution mode: {Config.core.mode}.\")        @classmethod      def __check_production_migration_config(self):          from ..config.checkers._migration_config_checker import _MigrationConfigChecker            collector = _MigrationConfigChecker(Config._applied_config, IssueCollector())._check()          for issue in collector._warnings:              self.__logger.warning(str(issue))          for issue in collector._infos:              self.__logger.info(str(issue))          for issue in collector._errors:              self.__logger.error(str(issue))          if len(collector._errors) != 0:              raise SystemExit(\"Configuration errors found. Please check the error log for more information.\")        @classmethod      def _delete_entities_of_multiple_types(cls, _entity_ids):          raise NotImplementedError "}
{"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": "import sys    from taipy._cli._base_cli import _CLI  from taipy.config import Config  from taipy.config.exceptions.exceptions import InconsistentEnvVariableError  from taipy.logger._taipy_logger import _TaipyLogger    from ...data._data_manager_factory import _DataManagerFactory  from ...exceptions.exceptions import VersionIsNotProductionVersion  from ...job._job_manager_factory import _JobManagerFactory  from ...scenario._scenario_manager_factory import _ScenarioManagerFactory  from ...sequence._sequence_manager_factory import _SequenceManagerFactory  from ...taipy import clean_all_entities_by_version  from ...task._task_manager_factory import _TaskManagerFactory  from .._version_manager_factory import _VersionManagerFactory  from ._bcolor import _Bcolors      class _VersionCLI:      \"\"\"Command-line interface of the versioning system.\"\"\"        __logger = _TaipyLogger._get_logger()        @classmethod      def create_parser(cls):          version_parser = _CLI._add_subparser(\"manage-versions\", help=\"Taipy version control system.\")            version_parser.add_argument(              \"-l\", \"--list\", action=\"store_true\", help=\"List all existing versions of the Taipy application.\"          )            version_parser.add_argument(              \"--rename\", nargs=2, metavar=(\"OLD_VERSION\", \"NEW_VERSION\"), help=\"Rename a Taipy version.\"          )            version_parser.add_argument(              \"--compare-config\",              nargs=2,              metavar=(\"VERSION_1\", \"VERSION_2\"),              help=\"Compare the Configuration of 2 Taipy versions.\",          )            version_parser.add_argument(              \"-d\", \"--delete\", metavar=\"VERSION\", help=\"Delete a Taipy version by version number.\"          )            version_parser.add_argument(              \"-dp\",              \"--delete-production\",              metavar=\"VERSION\",              help=\"Delete a Taipy version from production by version number. The version is still kept as an experiment \"              \"version.\",          )        @classmethod      def parse_arguments(cls):          args = _CLI._parse()            if getattr(args, \"which\", None) != \"manage-versions\":              return            if args.list:              print(cls.__list_versions())              sys.exit(0)            if args.rename:              try:                  cls.__rename_version(args.rename[0], args.rename[1])              except InconsistentEnvVariableError as error:                  cls.__logger.error(                      f\"Fail to rename version {args.rename[0]} to {args.rename[1]} due to outdated Configuration.\"                      f\"Detail: {str(error)}\"                  )                  sys.exit(1)                cls.__logger.info(f\"Successfully renamed version '{args.rename[0]}' to '{args.rename[1]}'.\")              sys.exit(0)            if args.compare_config:              cls.__compare_version_config(args.compare_config[0], args.compare_config[1])              sys.exit(0)            if args.delete_production:              try:                  _VersionManagerFactory._build_manager()._delete_production_version(args.delete_production)                  cls.__logger.info(                      f\"Successfully delete version {args.delete_production} from the production version list.\"                  )                  sys.exit(0)              except VersionIsNotProductionVersion as e:                  raise SystemExit(e)            if args.delete:              if clean_all_entities_by_version(args.delete):                  cls.__logger.info(f\"Successfully delete version {args.delete}.\")              else:                  sys.exit(1)                sys.exit(0)        @classmethod      def __list_versions(cls):          list_version_message = f\"\\n{'Version number':<36}   {'Mode':<20}   {'Creation date':<20}\\n\"            latest_version_number = _VersionManagerFactory._build_manager()._get_latest_version()          development_version_number = _VersionManagerFactory._build_manager()._get_development_version()          production_version_numbers = _VersionManagerFactory._build_manager()._get_production_versions()            versions = _VersionManagerFactory._build_manager()._get_all()          versions.sort(key=lambda x: x.creation_date, reverse=True)            bold = False          for version in versions:              if version.id == development_version_number:                  list_version_message += _Bcolors.GREEN                  mode = \"Development\"              elif version.id in production_version_numbers:                  list_version_message += _Bcolors.PURPLE                  mode = \"Production\"              else:                  list_version_message += _Bcolors.BLUE                  mode = \"Experiment\"                if version.id == latest_version_number:                  list_version_message += _Bcolors.BOLD                  bold = True                  mode += \" (latest)\"                list_version_message += (                  f\"{(version.id):<36}   {mode:<20}   {version.creation_date.strftime('%Y-%m-%d %H:%M:%S'):<20}\"              )              list_version_message += _Bcolors.END                if bold:                  list_version_message += _Bcolors.END              list_version_message += \"\\n\"            return list_version_message        @classmethod      def __rename_version(cls, old_version: str, new_version: str):          _version_manager = _VersionManagerFactory._build_manager()            # Check if the new version already exists, return an error          if _version_manager._get(new_version):              cls.__logger.error(f\"Version name '{new_version}' is already used.\")              sys.exit(1)            # Make sure that all entities of the old version are exists and loadable          version_entity = _version_manager._get(old_version)          if version_entity is None:              cls.__logger.error(f\"Version '{old_version}' does not exist.\")              sys.exit(1)            jobs = _JobManagerFactory._build_manager()._get_all(version_number=old_version)          scenarios = _ScenarioManagerFactory._build_manager()._get_all(version_number=old_version)          sequences = _SequenceManagerFactory._build_manager()._get_all(version_number=old_version)          tasks = _TaskManagerFactory._build_manager()._get_all(version_number=old_version)          datanodes = _DataManagerFactory._build_manager()._get_all(version_number=old_version)            # Update the version of all entities          for job in jobs:              job._version = new_version              _JobManagerFactory._build_manager()._set(job)          for scenario in scenarios:              scenario._version = new_version              _ScenarioManagerFactory._build_manager()._set(scenario)          for sequence in sequences:              sequence._version = new_version              _SequenceManagerFactory._build_manager()._set(sequence)          for task in tasks:              task._version = new_version              _TaskManagerFactory._build_manager()._set(task)          for datanode in datanodes:              datanode._version = new_version              _DataManagerFactory._build_manager()._set(datanode)            # Update the version entity          if old_version in _version_manager._get_production_versions():              _version_manager._set_production_version(new_version)          if old_version == _version_manager._get_latest_version():              _version_manager._set_experiment_version(new_version)          if old_version == _version_manager._get_development_version():              _version_manager._set_development_version(new_version)          _version_manager._delete(old_version)            try:              _version_manager._delete_production_version(old_version)          except VersionIsNotProductionVersion:              pass            if not _version_manager._get(new_version):              version_entity.id = new_version              _version_manager._set(version_entity)        @classmethod      def __compare_version_config(cls, version_1: str, version_2: str):          version_entity_1 = _VersionManagerFactory._build_manager()._get(version_1)          if version_entity_1 is None:              cls.__logger.error(f\"Version '{version_1}' does not exist.\")              sys.exit(1)            version_entity_2 = _VersionManagerFactory._build_manager()._get(version_2)          if version_entity_2 is None:              cls.__logger.error(f\"Version '{version_2}' does not exist.\")              sys.exit(1)            Config._comparator._compare(              version_entity_1.config,              version_entity_2.config,              version_1,              version_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": "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": "  from typing import List, Optional      class ConfigCoreVersionMismatched(Exception):      \"\"\"Raised if core version in Config does not match with the version of Taipy Core.\"\"\"        def __init__(self, config_core_version: str, core_version: str) -> None:          self.message = (              f\"Core version {config_core_version} in Config does not match with version of Taipy Core {core_version}.\"          )      class CoreServiceIsAlreadyRunning(Exception):      \"\"\"Raised if the Core service is already running.\"\"\"      class CycleAlreadyExists(Exception):      \"\"\"Raised if it is trying to create a Cycle that has already exists.\"\"\"      class NonExistingCycle(Exception):      \"\"\"Raised if a requested cycle is not known by the Cycle manager.\"\"\"        def __init__(self, cycle_id: str):          self.message = f\"Cycle: {cycle_id} does not exist.\"      class MissingRequiredProperty(Exception):      \"\"\"Raised if a required property is missing when creating a Data Node.\"\"\"      class InvalidDataNodeType(Exception):      \"\"\"Raised if a data node storage type does not exist.\"\"\"      class MultipleDataNodeFromSameConfigWithSameOwner(Exception):      \"\"\"      Raised if there are multiple data nodes from the same data node configuration and the same owner identifier.      \"\"\"      class NoData(Exception):      \"\"\"Raised if a data node is read before it has been written.        This exception can be raised by `DataNode.read_or_raise()^`.      \"\"\"      class UnknownDatabaseEngine(Exception):      \"\"\"Raised if the database engine is not known when creating a connection with a SQLDataNode.\"\"\"      class MissingAppendQueryBuilder(Exception):      \"\"\"Raised if no append query build is provided when appending data to a SQLDataNode.\"\"\"      class UnknownParquetEngine(Exception):      \"\"\"Raised if the parquet engine is not known or not supported when create a ParquetDataNode.\"\"\"      class UnknownCompressionAlgorithm(Exception):      \"\"\"Raised if the compression algorithm is not supported by ParquetDataNode.\"\"\"      class NonExistingDataNode(Exception):      \"\"\"Raised if a requested DataNode is not known by the DataNode Manager.\"\"\"        def __init__(self, data_node_id: str):          self.message = f\"DataNode: {data_node_id} does not exist.\"      class DataNodeIsBeingEdited(Exception):      \"\"\"Raised if a DataNode is being edited.\"\"\"        def __init__(self, data_node_id: str, editor_id: Optional[str] = None):          self.message = f\"DataNode {data_node_id} is being edited{ ' by ' + editor_id if editor_id else ''}.\"      class NonExistingDataNodeConfig(Exception):      \"\"\"Raised if a requested DataNodeConfig is not known by the DataNode Manager.\"\"\"        def __init__(self, data_node_config_id: str):          self.message = f\"Data node config: {data_node_config_id} does not exist.\"      class NonExistingExcelSheet(Exception):      \"\"\"Raised if a requested Sheet name does not exist in the provided Excel file.\"\"\"        def __init__(self, sheet_name: str, excel_file_name: str):          self.message = f\"{sheet_name} does not exist in {excel_file_name}.\"      class ExposedTypeLengthMismatch(Exception):      \"\"\"Raised if length of exposed type list does not match with number of sheets in the provided Excel file.\"\"\"      class SheetNameLengthMismatch(Exception):      \"\"\"Raised if length of sheet_name list does not match      with number of sheets in the data to be written to Excel file.\"\"\"      class InvalidExposedType(Exception):      \"\"\"Raised if an invalid exposed type is provided.\"\"\"      class InvalidCustomDocument(Exception):      \"\"\"Raised if an invalid custom document class is provided to a `MongoCollectionDataNode`.\"\"\"      class DataNodeConfigIsNotGlobal(Exception):      \"\"\"Raised if a DataNode is not global.\"\"\"        def __init__(self, data_node_config_id: str):          self.message = f\"Data node config `{data_node_config_id}` does not have GLOBAL scope.\"      class MissingReadFunction(Exception):      \"\"\"Raised if no read function is provided for the GenericDataNode.\"\"\"      class MissingWriteFunction(Exception):      \"\"\"Raised if no write function is provided for the GenericDataNode.\"\"\"      class JobNotDeletedException(RuntimeError):      \"\"\"Raised if there is an attempt to delete a job that cannot be deleted.        This exception can be raised by `taipy.delete_job()^`.      \"\"\"        def __init__(self, job_id: str):          self.message = f\"Job: {job_id} cannot be deleted.\"      class NonExistingJob(RuntimeError):      \"\"\"Raised if a requested job is not known by the Job manager.\"\"\"        def __init__(self, job_id: str):          self.message = f\"Job: {job_id} does not exist.\"      class DataNodeWritingError(RuntimeError):      \"\"\"Raised if an error happens during the writing in a data node.\"\"\"      class InvalidSubscriber(RuntimeError):      \"\"\"Raised if the loaded function is not valid.\"\"\"      class InvalidSequenceId(Exception):      \"\"\"Raised if a Sequence id can not be broken down.\"\"\"        def __init__(self, sequence_id: str):          self.message = f\"Sequence: {sequence_id} is invalid.\"      class InvalidSequence(Exception):      \"\"\"Raised if a Sequence is not a connected Directed Acyclic Graph.\"\"\"        def __init__(self, sequence_id: str):          self.message = f\"Sequence: {sequence_id} is not a connected Directed Acyclic Graph.\"      class NonExistingSequence(Exception):      \"\"\"Raised if a requested Sequence is not known by the Sequence Manager.\"\"\"        def __init__(self, sequence_id: str):          self.message = f\"Sequence: {sequence_id} does not exist.\"      class SequenceBelongsToNonExistingScenario(Exception):      \"\"\"Raised if a Sequence does not belong to an existing Scenario.\"\"\"        def __init__(self, sequence_id: str, scenario_id: str):          self.message = f\"Sequence: {sequence_id} belongs to a non-existing Scenario: {scenario_id}.\"      class SequenceTaskDoesNotExistInScenario(Exception):      \"\"\"Raised if Tasks of a Sequence do not exist in the same Scenario that the Sequence belongs to.\"\"\"        def __init__(self, task_ids: List[Optional[str]], sequence_name: str, scenario_id: str):          self.message = f\"Tasks {task_ids} of Sequence {sequence_name} does not exist in Scenario {scenario_id}.\"      class SequenceTaskConfigDoesNotExistInSameScenarioConfig(Exception):      \"\"\"Raised if TaskConfigs of a Sequence do not exist in the same ScenarioConfig that the Sequence belongs to.\"\"\"        def __init__(self, task_config_ids: List[Optional[str]], sequence_name: str, scenario_config_id: str):          self.message = f\"TaskConfig {task_config_ids} of Sequence name {sequence_name} \"          self.message += f\"does not exist in ScenarioConfig {scenario_config_id}.\"      class NonExistingSequenceConfig(Exception):      \"\"\"Raised if a requested Sequence configuration is not known by the Sequence Manager.\"\"\"        def __init__(self, sequence_config_id: str):          self.message = f\"Sequence config: {sequence_config_id} does not exist.\"      class MultipleSequenceFromSameConfigWithSameOwner(Exception):      \"\"\"Raised if it exists multiple sequences from the same sequence config and with the same _owner_id_.\"\"\"      class ModelNotFound(Exception):      \"\"\"Raised when trying to fetch a non-existent model.        This exception can be raised by `taipy.get()^` and `taipy.delete()^`.      \"\"\"        def __init__(self, model_name: str, model_id: str):          self.message = f\"A {model_name} model with id {model_id} could not be found.\"      class NonExistingScenario(Exception):      \"\"\"Raised if a requested scenario is not known by the Scenario Manager.\"\"\"        def __init__(self, scenario_id: str):          self.message = f\"Scenario: {scenario_id} does not exist.\"      class NonExistingScenarioConfig(Exception):      \"\"\"Raised if a requested scenario configuration is not known by the Scenario Manager.        This exception can be raised by `taipy.compare_scenarios()^`.      \"\"\"        def __init__(self, scenario_config_id: str):          self.message = f\"Scenario config: {scenario_config_id} does not exist.\"      class InvalidSscenario(Exception):      \"\"\"Raised if a Scenario is not a Directed Acyclic Graph.\"\"\"        def __init__(self, scenario_id: str):          self.message = f\"Scenario: {scenario_id} is not a Directed Acyclic Graph.\"      class DoesNotBelongToACycle(Exception):      \"\"\"Raised if a scenario without any cycle is promoted as primary scenario.\"\"\"      class DeletingPrimaryScenario(Exception):      \"\"\"Raised if a primary scenario is deleted.\"\"\"      class DifferentScenarioConfigs(Exception):      \"\"\"Raised if scenario comparison is requested on scenarios with different scenario configs.        This exception can be raised by `taipy.compare_scenarios()^`.      \"\"\"      class InsufficientScenarioToCompare(Exception):      \"\"\"Raised if too few scenarios are requested to be compared.        Scenario comparison need at least two scenarios to compare.        This exception can be raised by `taipy.compare_scenarios()^`.      \"\"\"      class NonExistingComparator(Exception):      \"\"\"Raised if a scenario comparator does not exist.        This exception can be raised by `taipy.compare_scenarios()^`.      \"\"\"      class UnauthorizedTagError(Exception):      \"\"\"Must provide an authorized tag.\"\"\"      class DependencyNotInstalled(Exception):      \"\"\"Raised if a package is missing.\"\"\"        def __init__(self, package_name: str):          self.message = f\"\"\"          Package '{package_name}' should be installed.          Run 'pip install taipy[{package_name}]' to installed it.          \"\"\"      class NonExistingTask(Exception):      \"\"\"Raised if a requested task is not known by the Task Manager.\"\"\"        def __init__(self, task_id: str):          self.message = f\"Task: {task_id} does not exist.\"      class NonExistingTaskConfig(Exception):      \"\"\"Raised if a requested task configuration is not known by the Task Manager.\"\"\"        def __init__(self, id: str):          self.message = f\"Task config: {id} does not exist.\"      class MultipleTaskFromSameConfigWithSameOwner(Exception):      \"\"\"Raised if there are multiple tasks from the same task configuration and the same owner identifier.\"\"\"      class OrchestratorNotBuilt(Exception):      \"\"\"Raised if the orchestrator was not built in the OrchestratorFactory\"\"\"      class ModeNotAvailable(Exception):      \"\"\"Raised if the mode in JobConfig is not supported.\"\"\"      class InvalidExportPath(Exception):      \"\"\"Raised if the export path is not valid.\"\"\"      class NonExistingVersion(Exception):      \"\"\"Raised if request a Version that is not known by the Version Manager.\"\"\"        def __init__(self, version_number: str):          self.message = f\"Version '{version_number}' does not exist.\"      class VersionIsNotProductionVersion(Exception):      \"\"\"Raised if the version is not a production version.\"\"\"      class ConflictedConfigurationError(Exception):      \"\"\"Conflicts have been detected between the current and previous Configurations.\"\"\"      class InvalidEventAttributeName(Exception):      \"\"\"      Raised if the attribute doesn't exist or an attribute name is provided      when operation is either creation, deletion or submission      \"\"\"      class InvalidEventOperation(Exception):      \"\"\"Raised when operation doesn't belong to the entity\"\"\"      class FileCannotBeRead(Exception):      \"\"\"Raised when a file cannot be read.\"\"\"      class _SuspiciousFileOperation(Exception):      pass "}
{"text": "#  # Licensed under the Apache License, Version 2.0 (the \"License\"); you may not use this file except in compliance with  # the License. You may obtain a copy of the License at  #  #        http://www.apache.org/licenses/LICENSE-2.0  #  # Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on  # an \"AS IS\" BASIS, WITHOUT 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": "import json  from typing import Dict, List, Optional, Tuple    from taipy.logger._taipy_logger import _TaipyLogger    __logger = _TaipyLogger._get_logger()      def __update_parent_ids(entity: Dict, data: Dict) -> Dict:      # parent_ids was not present in 2.0, need to be search for in tasks      parent_ids = entity.get(\"parent_ids\", [])      if not parent_ids:          parent_ids = __search_parent_ids(entity[\"id\"], data)      entity[\"parent_ids\"] = parent_ids        return entity      def __update_config_parent_ids(id: str, entity: Dict, entity_type: str, config: Dict) -> Dict:      # parent_ids was not present in 2.0, need to be search for in tasks      parent_ids = entity.get(\"parent_ids\", [])        if not parent_ids:          parent_ids = __search_parent_config(id, config, entity_type)      entity[\"parent_ids\"] = parent_ids        return entity      def __search_parent_ids(entity_id: str, data: Dict) -> List:      parents = []      entity_type = entity_id.split(\"_\", 1)[0]        for _id, entity_data in data.items():          entity_data = entity_data[\"data\"]          if entity_type == \"DATANODE\" and \"TASK\" in _id:              if entity_id in entity_data[\"input_ids\"] or entity_id in entity_data[\"output_ids\"]:                  parents.append(_id)            if entity_type == \"TASK\" and \"SCENARIO\" in _id:              if entity_id in entity_data[\"tasks\"]:                  parents.append(_id)      parents.sort()      return parents      def __search_parent_config(entity_id: str, config: Dict, entity_type: str) -> List:      parents = []      possible_parents = \"TASK\" if entity_type == \"DATA_NODE\" else \"SCENARIO\"      data = config[possible_parents]        for _id, entity_data in data.items():          section_id = f\"{entity_id}:SECTION\"          if entity_type == \"DATANODE\" and possible_parents == \"TASK\":              if section_id in entity_data[\"input_ids\"] or section_id in entity_data[\"output_ids\"]:                  parents.append(section_id)            if entity_type == \"TASK\" and possible_parents == \"SCENARIO\":              if section_id in entity_data[\"tasks\"]:                  parents.append(section_id)        parents.sort()      return parents      def __fetch_tasks_from_pipelines(pipelines: List, data: Dict) -> List:      tasks = []      for pipeline in pipelines:          pipeline_data = data[pipeline][\"data\"]          tasks.extend(pipeline_data[\"tasks\"])      return tasks      def __migrate_subscriber(fct_module, fct_name):      \"\"\"Rename scheduler by orchestrator on old jobs. Used to migrate from <=2.2 to >=2.3 version.\"\"\"      if fct_module == \"taipy.core._scheduler._scheduler\":          fct_module = fct_module.replace(\"_scheduler\", \"_orchestrator\")          fct_name = fct_name.replace(\"_Scheduler\", \"_Orchestrator\")      return fct_module, fct_name      def __migrate_scenario(scenario: Dict, data: Dict) -> Dict:      # pipelines were replaced by tasks      scenario[\"tasks\"] = __fetch_tasks_from_pipelines(scenario[\"pipelines\"], data)        # pipeline attribute not removed in 3.0      scenario[\"pipelines\"] = None        # additional_data_nodes attribute added      scenario[\"additional_data_nodes\"] = []        return scenario      def __is_cacheable(task: Dict, data: Dict) -> bool:      output_ids = task.get(\"output_ids\", []) or task.get(\"outputs\", [])  # output_ids is on entity, outputs is on config        for output_id in output_ids:          if output_id.endswith(\":SECTION\"):  # Get the config_id if the task is a Config              output_id = output_id.split(\":\")[0]          dn = data.get(output_id, {})          if \"data\" in dn:              dn = dn.get(\"data\", {})            if \"cacheable\" not in dn or not dn[\"cacheable\"] or dn[\"cacheable\"] == \"False:bool\":              return False      return True      def __migrate_task(task: Dict, data: Dict, is_entity: bool = True) -> Dict:      if is_entity:          # parent_id has been renamed to owner_id          try:              task[\"owner_id\"] = task[\"parent_id\"]              del task[\"parent_id\"]          except KeyError:              pass            # properties was not present in 2.0          task[\"properties\"] = task.get(\"properties\", {})        # skippable was not present in 2.0      task[\"skippable\"] = task.get(\"skippable\", False) or __is_cacheable(task, data)        return task      def __migrate_task_entity(task: Dict, data: Dict) -> Dict:      task = __update_parent_ids(task, data)      return __migrate_task(task, data)      def __migrate_task_config(task: Dict, config: Dict) -> Dict:      task = __migrate_task(task, config[\"DATA_NODE\"], False)        # Convert the skippable boolean to a string if needed      if isinstance(task.get(\"skippable\"), bool):          task[\"skippable\"] = str(task[\"skippable\"]) + \":bool\"      return task      def __update_scope(scope: str):      if scope in \"<Scope.SCENARIO: 2>\":          return \"<Scope.SCENARIO: 1>\"      elif scope == \"<Scope.CYCLE: 3>\":          return \"<Scope.CYCLE: 2>\"      elif scope == \"<Scope.GLOBAL: 4>\":          return \"<Scope.GLOBAL: 3>\"      return scope      def __migrate_datanode(datanode: Dict) -> Dict:      # cacheable was removed in after 2.0      _ = datanode.pop(\"cacheable\", False)        # job_ids was replaced by edits      if \"job_ids\" in datanode:          datanode[\"edits\"] = [{\"job_id\": job, \"timestamp\": datanode[\"last_edit_date\"]} for job in datanode[\"job_ids\"]]      elif \"edits\" in datanode:          # make sure timestamp inside edits is a string          edits = []          for edit in datanode[\"edits\"]:              timestamp = edit.get(\"timestamp\")              if isinstance(timestamp, dict):                  timestamp = timestamp.get(\"__value__\")              new_edit = {\"timestamp\": timestamp}              if \"job_id\" in edit:                  new_edit[\"job_id\"] = edit[\"job_id\"]              edits.append(new_edit)          datanode[\"edits\"] = edits        # parent_id has been renamed to owner_id      try:          datanode[\"owner_id\"] = datanode[\"parent_id\"]          del datanode[\"parent_id\"]      except KeyError:          pass        # Update Scope enum after Pipeline removal      datanode[\"scope\"] = __update_scope(datanode[\"scope\"])        # Update move name attribute to properties dictionary      datanode[\"data_node_properties\"][\"name\"] = datanode.pop(\"name\", None)        if \"last_edit_date\" not in datanode:          datanode[\"last_edit_date\"] = datanode.get(\"last_edition_date\")          if \"last_edition_date\" in datanode:              del datanode[\"last_edition_date\"]        if \"edit_in_progress\" not in datanode:          datanode[\"edit_in_progress\"] = datanode.get(\"edition_in_progress\")          if \"edition_in_progress\" in datanode:              del datanode[\"edition_in_progress\"]        return datanode      def __migrate_datanode_entity(datanode: Dict, data: Dict) -> Dict:      datanode = __update_parent_ids(datanode, data)      return __migrate_datanode(datanode)      def __migrate_datanode_config(datanode: Dict) -> Dict:      if datanode[\"storage_type\"] in [\"csv\", \"json\"]:          datanode[\"encoding\"] = \"utf-8\"      return datanode      def __migrate_job(job: Dict) -> Dict:      # submit_entity_id was not present before 3.0      job[\"submit_entity_id\"] = job.get(\"submit_entity_id\", None)      if \"subscribers\" in job:          for sub in job[\"subscribers\"]:              sub[\"fct_module\"], sub[\"fct_name\"] = __migrate_subscriber(sub[\"fct_module\"], sub[\"fct_name\"])      return job      def __migrate_global_config(config: Dict):      fields_to_remove = [\"clean_entities_enabled\"]      fields_to_move = [\"root_folder\", \"storage_folder\", \"repository_type\", \"read_entity_retry\"]        for field in fields_to_remove:          if field in config[\"TAIPY\"]:              del config[\"TAIPY\"][field]      try:          for field in fields_to_move:              if field not in config[\"CORE\"]:                  config[\"CORE\"][field] = config[\"TAIPY\"][field]                  del config[\"TAIPY\"][field]      except KeyError:          pass        return config      def __migrate_version(version: Dict) -> Dict:      config_str = version[\"config\"]        # Remove PIPELINE scope      config_str = config_str.replace(\"PIPELINE:SCOPE\", \"SCENARIO:SCOPE\")      config = json.loads(config_str)        # remove unused fields and move others from TAIPY to CORE section      config = __migrate_global_config(config)        # replace pipelines for tasks      pipelines_section = config[\"PIPELINE\"]      for id, content in config[\"SCENARIO\"].items():          tasks = []          for _pipeline in content[\"pipelines\"]:              pipeline_id = _pipeline.split(\":\")[0]              tasks = pipelines_section[pipeline_id][\"tasks\"]          config[\"SCENARIO\"][id][\"tasks\"] = tasks          del config[\"SCENARIO\"][id][\"pipelines\"]        for id, content in config[\"TASK\"].items():          config[\"TASK\"][id] = __migrate_task_config(content, config)        for id, content in config[\"DATA_NODE\"].items():          config[\"DATA_NODE\"][id] = __migrate_datanode_config(content)        del config[\"PIPELINE\"]        version[\"config\"] = json.dumps(config, ensure_ascii=False, indent=0)      return version      def __migrate_entities(entity_type: str, data: Dict) -> Dict:      migration_fct = FCT_MIGRATION_MAP.get(entity_type)      _entities = {k: data[k] for k in data if entity_type in k}        for k, v in _entities.items():          if entity_type in [\"JOB\", \"VERSION\"]:              v[\"data\"] = migration_fct(v[\"data\"])  # type: ignore          else:              v[\"data\"] = migration_fct(v[\"data\"], data)  # type: ignore          data[k] = v      return data      FCT_MIGRATION_MAP = {      \"SCENARIO\": __migrate_scenario,      \"TASK\": __migrate_task_entity,      \"DATANODE\": __migrate_datanode_entity,      \"JOB\": __migrate_job,      \"VERSION\": __migrate_version,  }      def _migrate(entities: Dict, versions: Optional[Dict] = None) -> Tuple[Dict, Dict]:      __logger.info(\"Migrating SCENARIOS\")      entities = __migrate_entities(\"SCENARIO\", entities)        __logger.info(\"Migrating TASKS\")      entities = __migrate_entities(\"TASK\", entities)        __logger.info(\"Migrating DATANODES\")      entities = __migrate_entities(\"DATANODE\", entities)        __logger.info(\"Migrating JOBS\")      entities = __migrate_entities(\"JOB\", entities)        __logger.info(\"Migrating VERSION\")      if versions:          versions = __migrate_entities(\"VERSION\", versions)      else:          entities = __migrate_entities(\"VERSION\", entities)          versions = {}      return entities, versions "}
{"text": "import json  import os  import shutil  import sqlite3  from typing import Dict, Tuple    from taipy.logger._taipy_logger import _TaipyLogger    from ._utils import _migrate    __logger = _TaipyLogger._get_logger()      def _load_all_entities_from_sql(db_file: str) -> Tuple[Dict, Dict]:      conn = sqlite3.connect(db_file)      query = \"SELECT model_id, document FROM taipy_model\"      query_version = \"SELECT * FROM taipy_version\"      cursor = conn.execute(query)      entities = {}      versions = {}        for row in cursor:          _id = row[0]          document = row[1]          entities[_id] = {\"data\": json.loads(document)}        cursor = conn.execute(query_version)      for row in cursor:          id = row[0]          config_id = row[1]          creation_date = row[2]          is_production = row[3]          is_development = row[4]          is_latest = row[5]          versions[id] = {              \"config_id\": config_id,              \"creation_date\": creation_date,              \"is_production\": is_production,              \"is_development\": is_development,              \"is_latest\": is_latest,          }      return entities, versions      def __insert_scenario(scenario: dict, conn):      query = f\"\"\"          INSERT INTO scenario (id, config_id, tasks, additional_data_nodes, creation_date, primary_scenario, subscribers,           tags, version, pipelines, cycle)          VALUES ({scenario['id']}, {scenario['config_id']}, {scenario['tasks']}, {scenario['additional_data_nodes']},          {scenario['creation_date']}, {scenario['primary_scenario']}, {scenario['subscribers']}, {scenario['tags']},          {scenario['version']}, {scenario['pipelines']}, {scenario['cycle']})          \"\"\"      conn.execute(query)      conn.commit()      def __insert_task(task: dict, conn):      query = f\"\"\"          INSERT INTO task (id, owner_id, parent_ids, config_id, input_ids, function_name, function_module, output_ids,          version, skippable, properties)          VALUES ({task['id']}, {task['owner_id']}, {task['parent_ids']}, {task['config_id']}, {task['input_ids']},           {task['function_name']}, {task['function_module']}, {task['output_ids']}, {task['version']},           {task['skippable']}, {task['properties']})      \"\"\"      conn.execute(query)      conn.commit()      def __insert_datanode(datanode: dict, conn):      query = f\"\"\"          INSERT INTO data_node (id, config_id, scope, storage_type, name, owner_id, parent_ids, last_edit_date, edits,          version, validity_days, validity_seconds, edit_in_progress, data_node_properties)          VALUES ({datanode['id']}, {datanode['config_id']}, {datanode['scope']}, {datanode['storage_type']},          {datanode['name']}, {datanode['owner_id']}, {datanode['parent_ids']}, {datanode['last_edit_date']},          {datanode['edits']}, {datanode['version']}, {datanode['validity_days']}, {datanode['validity_seconds']},          {datanode['edit_in_progress']}, {datanode['data_node_properties']})      \"\"\"      conn.execute(query)      conn.commit()      def __insert_job(job: dict, conn):      query = f\"\"\"          INSERT INTO job (id, task_id, status, force, submit_id, submit_entity_id, creation_date, subscribers,          stacktrace, version)          VALUES ({job['id']}, {job['task_id']}, {job['status']}, {job['force']}, {job['submit_id']},          {job['submit_entity_id']}, {job['creation_date']}, {job['subscribers']}, {job['stacktrace']}, {job['version']})      \"\"\"      conn.execute(query)      conn.commit()      def __insert_cycle(cycle: dict, conn):      query = f\"\"\"          INSERT INTO scenario (id, name, frequency, properties, creation_date, start_date, end_date)          VALUES ({cycle['id']}, {cycle['name']}, {cycle['frequency']}, {cycle['properties']}, {cycle['creation_date']},          {cycle['start_date']}, {cycle['end_date']})      \"\"\"      conn.execute(query)      conn.commit()      def __insert_version(version: dict, conn):      query = f\"\"\"          INSERT INTO version (id, config_id, creation_date, is_production, is_development, is_latest)          VALUES ({version['id']}, {version['config_id']}, {version['creation_date']}, {version['is_production']},          {version['is_development']}, {version['is_latest']})      \"\"\"      conn.execute(query)      conn.commit()      def __write_entities_to_sql(_entities: Dict, _versions: Dict, db_file: str):      conn = sqlite3.connect(db_file)        for k, entity in _entities.items():          if \"SCENARIO\" in k:              __insert_scenario(entity[\"data\"], conn)          elif \"TASK\" in k:              __insert_task(entity[\"data\"], conn)          elif \"DATANODE\" in k:              __insert_datanode(entity[\"data\"], conn)          elif \"JOB\" in k:              __insert_job(entity[\"data\"], conn)          elif \"CYCLE\" in k:              __insert_cycle(entity[\"data\"], conn)        for k, version in _versions.items():          __insert_version(version, conn)      def _restore_migrate_sql_entities(path: str) -> bool:      file_name, file_extension = path.rsplit(\".\", 1)      backup_path = f\"{file_name}_backup.{file_extension}\"        if not os.path.exists(backup_path):          __logger.error(f\"The backup database '{backup_path}' does not exist.\")          return False        if os.path.exists(path):          os.remove(path)      else:          __logger.warning(f\"The original entities database '{path}' does not exist.\")        os.rename(backup_path, path)      __logger.info(f\"Restored entities from the backup database '{backup_path}' to '{path}'.\")      return True      def _remove_backup_sql_entities(path: str) -> bool:      file_name, file_extension = path.rsplit(\".\", 1)      backup_path = f\"{file_name}_backup.{file_extension}\"      if not os.path.exists(backup_path):          __logger.error(f\"The backup database '{backup_path}' does not exist.\")          return False        os.remove(backup_path)      __logger.info(f\"Removed backup entities from the backup database '{backup_path}'.\")      return True      def _migrate_sql_entities(path: str, backup: bool = True) -> bool:      \"\"\"Migrate entities from sqlite database to the current version.        Args:          path (str): The path to the sqlite database.          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 path:          __logger.error(\"Missing the required sqlite path.\")          return False      if not os.path.exists(path):          __logger.error(f\"File '{path}' does not exist.\")          return False        if backup:          file_name, file_extension = path.rsplit(\".\", 1)          shutil.copyfile(path, f\"{file_name}_backup.{file_extension}\")          __logger.info(f\"Backed up entities from '{path}' to '{file_name}_backup.{file_extension}' before migration.\")        __logger.info(f\"Starting entity migration from sqlite database '{path}'\")        entities, versions = _load_all_entities_from_sql(path)      entities, versions = _migrate(entities, versions)      __write_entities_to_sql(entities, versions, 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": "from __future__ import annotations    import pathlib  import uuid  from datetime import datetime  from typing import Any, Callable, Dict, List, Optional, Set, Union    import networkx as nx    from taipy.config.common._template_handler import _TemplateHandler as _tpl  from taipy.config.common._validate_id import _validate_id    from .._entity._entity import _Entity  from .._entity._labeled import _Labeled  from .._entity._properties import _Properties  from .._entity._reload import _Reloader, _self_reload, _self_setter  from .._entity.submittable import Submittable  from .._version._version_manager_factory import _VersionManagerFactory  from ..common._listattributes import _ListAttributes  from ..common._utils import _Subscriber  from ..cycle.cycle import Cycle  from ..data._data_manager_factory import _DataManagerFactory  from ..data.data_node import DataNode  from ..data.data_node_id import DataNodeId  from ..exceptions.exceptions import (      InvalidSequence,      NonExistingDataNode,      NonExistingSequence,      NonExistingTask,      SequenceTaskDoesNotExistInScenario,  )  from ..job.job import Job  from ..notification import Event, EventEntityType, EventOperation, Notifier, _make_event  from ..sequence.sequence import Sequence  from ..task._task_manager_factory import _TaskManagerFactory  from ..task.task import Task  from ..task.task_id import TaskId  from .scenario_id import ScenarioId      class Scenario(_Entity, Submittable, _Labeled):      \"\"\"Instance of a Business case to solve.        A scenario holds a set of tasks (instances of `Task^` class) to submit for execution in order to      solve the Business case. It also holds a set of additional data nodes (instances of `DataNode` class)      for extra data related to the scenario.        Attributes:          config_id (str): The identifier of the `ScenarioConfig^`.          tasks (Set[Task^]): The set of tasks.          additional_data_nodes (Set[DataNode^]): The set of additional data nodes.          sequences (Dict[str, Sequence^]): The dictionary of sequences: subsets of tasks that can be submitted              together independently of the rest of the scenario's tasks.          properties (dict[str, Any]): A dictionary of additional properties.          scenario_id (str): The unique identifier of this scenario.          creation_date (datetime): The date and time of the scenario's creation.          is_primary (bool): True if the scenario is the primary of its cycle. False otherwise.          cycle (Cycle^): The cycle of the scenario.          subscribers (List[Callable]): The list of callbacks to be called on `Job^`'s status change.          tags (Set[str]): The list of scenario's tags.          version (str): The string indicates the application version of the scenario to instantiate.              If not provided, the latest version is used.      \"\"\"        _ID_PREFIX = \"SCENARIO\"      _MANAGER_NAME = \"scenario\"      _MIGRATED_SEQUENCES_KEY = \"sequences\"      __SEPARATOR = \"_\"      _SEQUENCE_TASKS_KEY = \"tasks\"      _SEQUENCE_PROPERTIES_KEY = \"properties\"      _SEQUENCE_SUBSCRIBERS_KEY = \"subscribers\"        def __init__(          self,          config_id: str,          tasks: Optional[Union[Set[TaskId], Set[Task]]],          properties: Dict[str, Any],          additional_data_nodes: Optional[Union[Set[DataNodeId], Set[DataNode]]] = None,          scenario_id: Optional[ScenarioId] = None,          creation_date: Optional[datetime] = None,          is_primary: bool = False,          cycle: Optional[Cycle] = None,          subscribers: Optional[List[_Subscriber]] = None,          tags: Optional[Set[str]] = None,          version: str = None,          sequences: Optional[Dict[str, Dict]] = None,      ):          super().__init__(subscribers or [])          self.config_id = _validate_id(config_id)          self.id: ScenarioId = scenario_id or self._new_id(self.config_id)            self._tasks: Union[Set[TaskId], Set[Task], Set] = tasks or set()          self._additional_data_nodes: Union[Set[DataNodeId], Set[DataNode], Set] = additional_data_nodes or set()            self._creation_date = creation_date or datetime.now()          self._cycle = cycle          self._primary_scenario = is_primary          self._tags = tags or set()          self._properties = _Properties(self, **properties)          self._sequences: Dict[str, Dict] = sequences or {}            _scenario_task_ids = set([task.id if isinstance(task, Task) else task for task in self._tasks])          for sequence_name, sequence_data in self._sequences.items():              sequence_task_ids = set(                  [task.id if isinstance(task, Task) else task for task in sequence_data.get(\"tasks\", [])]              )              self.__check_sequence_tasks_exist_in_scenario_tasks(                  sequence_name, sequence_task_ids, self.id, _scenario_task_ids              )            self._version = version or _VersionManagerFactory._build_manager()._get_latest_version()        @staticmethod      def _new_id(config_id: str) -> ScenarioId:          \"\"\"Generate a unique scenario identifier.\"\"\"          return ScenarioId(Scenario.__SEPARATOR.join([Scenario._ID_PREFIX, _validate_id(config_id), str(uuid.uuid4())]))        def __getstate__(self):          return self.id        def __setstate__(self, id):          from ... import core as tp            sc = tp.get(id)          self.__dict__ = sc.__dict__        def __hash__(self):          return hash(self.id)        def __eq__(self, other):          return self.id == other.id        def __getattr__(self, attribute_name):          protected_attribute_name = _validate_id(attribute_name)          if protected_attribute_name in self._properties:              return _tpl._replace_templates(self._properties[protected_attribute_name])            sequences = self._get_sequences()          if protected_attribute_name in sequences:              return sequences[protected_attribute_name]          tasks = self.tasks          if protected_attribute_name in tasks:              return tasks[protected_attribute_name]          data_nodes = self.data_nodes          if protected_attribute_name in data_nodes:              return data_nodes[protected_attribute_name]          raise AttributeError(f\"{attribute_name} is not an attribute of scenario {self.id}\")        @property  # type: ignore      @_self_reload(_MANAGER_NAME)      def sequences(self) -> Dict[str, Sequence]:          return self._get_sequences()        @sequences.setter  # type: ignore      @_self_setter(_MANAGER_NAME)      def sequences(          self, sequences: Dict[str, Dict[str, Union[List[Task], List[TaskId], _ListAttributes, List[_Subscriber], Dict]]]      ):          self._sequences = sequences          actual_sequences = self._get_sequences()          for sequence_name in sequences.keys():              if not actual_sequences[sequence_name]._is_consistent():                  raise InvalidSequence(actual_sequences[sequence_name].id)        def add_sequence(          self,          name: str,          tasks: Union[List[Task], List[TaskId]],          properties: Optional[Dict] = None,          subscribers: Optional[List[_Subscriber]] = None,      ):          \"\"\"Add a sequence to the scenario.            Parameters:              name (str): The name of the sequence.              tasks (Union[List[Task], List[TaskId]]): The list of scenario's tasks to add to the sequence.              properties (Optional[Dict]): The optional properties of the sequence.              subscribers (Optional[List[_Subscriber]]): The optional list of callbacks to be called on                  `Job^`'s status change.            Raises:              SequenceTaskDoesNotExistInScenario^: If a task in the sequence does not exist in the scenario.          \"\"\"          _scenario = _Reloader()._reload(self._MANAGER_NAME, self)          _scenario_task_ids = set([task.id if isinstance(task, Task) else task for task in _scenario._tasks])          _sequence_task_ids: Set[TaskId] = set([task.id if isinstance(task, Task) else task for task in tasks])          self.__check_sequence_tasks_exist_in_scenario_tasks(name, _sequence_task_ids, self.id, _scenario_task_ids)          _sequences = _Reloader()._reload(self._MANAGER_NAME, self)._sequences          _sequences.update(              {                  name: {                      self._SEQUENCE_TASKS_KEY: tasks,                      self._SEQUENCE_PROPERTIES_KEY: properties or {},                      self._SEQUENCE_SUBSCRIBERS_KEY: subscribers or [],                  }              }          )          self.sequences = _sequences  # type: ignore          if not self.sequences[name]._is_consistent():              raise InvalidSequence(name)          Notifier.publish(_make_event(self.sequences[name], EventOperation.CREATION))        def add_sequences(self, sequences: Dict[str, Union[List[Task], List[TaskId]]]):          \"\"\"Add multiple sequences to the scenario.            Note:              To provide properties and subscribers for the sequences, use `Scenario.add_sequence^` instead.            Parameters:              sequences (Dict[str, Union[List[Task], List[TaskId]]]):                  A dictionary containing sequences to add. Each key is a sequence name, and the value must                  be a list of the scenario tasks.            Raises:              SequenceTaskDoesNotExistInScenario^: If a task in the sequence does not exist in the scenario.          \"\"\"          _scenario = _Reloader()._reload(self._MANAGER_NAME, self)          _sc_task_ids = set([task.id if isinstance(task, Task) else task for task in _scenario._tasks])          for name, tasks in sequences.items():              _seq_task_ids: Set[TaskId] = set([task.id if isinstance(task, Task) else task for task in tasks])              self.__check_sequence_tasks_exist_in_scenario_tasks(name, _seq_task_ids, self.id, _sc_task_ids)          # Need to parse twice the sequences to avoid adding some sequences and not others in case of exception          for name, tasks in sequences.items():              self.add_sequence(name, tasks)        def remove_sequence(self, name: str):          \"\"\"Remove a sequence from the scenario.            Parameters:              name (str): The name of the sequence to remove.          \"\"\"          seq_id = self.sequences[name].id          _sequences = _Reloader()._reload(self._MANAGER_NAME, self)._sequences          _sequences.pop(name)          self.sequences = _sequences  # type: ignore          Notifier.publish(Event(EventEntityType.SEQUENCE, EventOperation.DELETION, entity_id=seq_id))        def remove_sequences(self, sequence_names: List[str]):          \"\"\"          Remove multiple sequences from the scenario.            Parameters:              sequence_names (List[str]): A list of sequence names to remove.          \"\"\"          _sequences = _Reloader()._reload(self._MANAGER_NAME, self)._sequences          for sequence_name in sequence_names:              seq_id = self.sequences[sequence_name].id              _sequences.pop(sequence_name)              Notifier.publish(                  Event(                      EventEntityType.SEQUENCE,                      EventOperation.DELETION,                      entity_id=seq_id,                  )              )          self.sequences = _sequences  # type: ignore        @staticmethod      def __check_sequence_tasks_exist_in_scenario_tasks(          sequence_name: str, sequence_task_ids: Set[TaskId], scenario_id: ScenarioId, scenario_task_ids: Set[TaskId]      ):          non_existing_sequence_task_ids_in_scenario = set()          for sequence_task_id in sequence_task_ids:              if sequence_task_id not in scenario_task_ids:                  non_existing_sequence_task_ids_in_scenario.add(sequence_task_id)          if len(non_existing_sequence_task_ids_in_scenario) > 0:              raise SequenceTaskDoesNotExistInScenario(                  list(non_existing_sequence_task_ids_in_scenario), sequence_name, scenario_id              )        def _get_sequences(self) -> Dict[str, Sequence]:          _sequences = {}            from ..sequence._sequence_manager_factory import _SequenceManagerFactory            sequence_manager = _SequenceManagerFactory._build_manager()            for sequence_name, sequence_data in self._sequences.items():              p = sequence_manager._create(                  sequence_name,                  sequence_data.get(self._SEQUENCE_TASKS_KEY, []),                  sequence_data.get(self._SEQUENCE_SUBSCRIBERS_KEY, []),                  sequence_data.get(self._SEQUENCE_PROPERTIES_KEY, {}),                  self.id,                  self.version,              )              if not isinstance(p, Sequence):                  raise NonExistingSequence(sequence_name)              _sequences[sequence_name] = p          return _sequences        @property  # type: ignore      @_self_reload(_MANAGER_NAME)      def tasks(self) -> Dict[str, Task]:          return self.__get_tasks()        def __get_tasks(self) -> Dict[str, Task]:          _tasks = {}          task_manager = _TaskManagerFactory._build_manager()            for task_or_id in self._tasks:              t = task_manager._get(task_or_id, task_or_id)                if not isinstance(t, Task):                  raise NonExistingTask(task_or_id)              _tasks[t.config_id] = t          return _tasks        @tasks.setter  # type: ignore      @_self_setter(_MANAGER_NAME)      def tasks(self, val: Union[Set[TaskId], Set[Task]]):          self._tasks = set(val)        @property  # type: ignore      @_self_reload(_MANAGER_NAME)      def additional_data_nodes(self) -> Dict[str, DataNode]:          return self.__get_additional_data_nodes()        def __get_additional_data_nodes(self):          additional_data_nodes = {}          data_manager = _DataManagerFactory._build_manager()            for dn_or_id in self._additional_data_nodes:              dn = data_manager._get(dn_or_id, dn_or_id)                if not isinstance(dn, DataNode):                  raise NonExistingDataNode(dn_or_id)              additional_data_nodes[dn.config_id] = dn          return additional_data_nodes        @additional_data_nodes.setter  # type: ignore      @_self_setter(_MANAGER_NAME)      def additional_data_nodes(self, val: Union[Set[TaskId], Set[DataNode]]):          self._additional_data_nodes = set(val)        def _get_set_of_tasks(self) -> Set[Task]:          return set(self.tasks.values())        @property  # type: ignore      @_self_reload(_MANAGER_NAME)      def data_nodes(self) -> Dict[str, DataNode]:          data_nodes_dict = self.__get_additional_data_nodes()          for _, task in self.__get_tasks().items():              data_nodes_dict.update(task.data_nodes)          return data_nodes_dict        @property  # type: ignore      @_self_reload(_MANAGER_NAME)      def creation_date(self):          return self._creation_date        @creation_date.setter  # type: ignore      @_self_setter(_MANAGER_NAME)      def creation_date(self, val):          self._creation_date = val        @property  # type: ignore      @_self_reload(_MANAGER_NAME)      def cycle(self):          return self._cycle        @cycle.setter  # type: ignore      @_self_setter(_MANAGER_NAME)      def cycle(self, val):          self._cycle = val        @property  # type: ignore      @_self_reload(_MANAGER_NAME)      def is_primary(self):          return self._primary_scenario        @is_primary.setter  # type: ignore      @_self_setter(_MANAGER_NAME)      def is_primary(self, val):          self._primary_scenario = val        @property  # type: ignore      @_self_reload(_MANAGER_NAME)      def subscribers(self):          return self._subscribers        @subscribers.setter  # type: ignore      @_self_setter(_MANAGER_NAME)      def subscribers(self, val):          self._subscribers = _ListAttributes(self, val)        @property  # type: ignore      @_self_reload(_MANAGER_NAME)      def tags(self):          return self._tags        @tags.setter  # type: ignore      @_self_setter(_MANAGER_NAME)      def tags(self, val):          self._tags = val or set()        @property      def version(self):          return self._version        @property      def owner_id(self):          return self._cycle.id        @property      def properties(self):          self._properties = _Reloader()._reload(self._MANAGER_NAME, self)._properties          return self._properties        @property  # type: ignore      def name(self) -> Optional[str]:          return self.properties.get(\"name\")        @name.setter  # type: ignore      def name(self, val):          self.properties[\"name\"] = val        def has_tag(self, tag: str) -> bool:          \"\"\"Indicate if the scenario has a given tag.            Parameters:              tag (str): The tag to search among the set of scenario's tags.          Returns:              True if the scenario has the tag given as parameter. False otherwise.          \"\"\"          return tag in self.tags        def _add_tag(self, tag: str):          self._tags = _Reloader()._reload(\"scenario\", self)._tags          self._tags.add(tag)        def _remove_tag(self, tag: str):          self._tags = _Reloader()._reload(\"scenario\", self)._tags          if self.has_tag(tag):              self._tags.remove(tag)        def subscribe(          self,          callback: Callable[[Scenario, Job], None],          params: Optional[List[Any]] = None,      ):          \"\"\"Subscribe a function to be called on `Job^` status change.            The subscription is applied to all jobs created from the scenario's execution.            Parameters:              callback (Callable[[Scenario^, Job^], None]): The callable function to be called                  on status change.              params (Optional[List[Any]]): The parameters to be passed to the _callback_.            Note:              Notification will be available only for jobs created after this subscription.          \"\"\"          from ... import core as tp            return tp.subscribe_scenario(callback, params, self)        def unsubscribe(self, callback: Callable[[Scenario, Job], None], params: Optional[List[Any]] = None):          \"\"\"Unsubscribe a function that is called when the status of a `Job^` changes.            Parameters:              callback (Callable[[Scenario^, Job^], None]): The callable function to unsubscribe.              params (Optional[List[Any]]): The parameters to be passed to the _callback_.            Note:              The function will continue to be called for ongoing jobs.          \"\"\"          from ... import core as tp            return tp.unsubscribe_scenario(callback, params, self)        def submit(          self,          callbacks: Optional[List[Callable]] = None,          force: bool = False,          wait: bool = False,          timeout: Optional[Union[float, int]] = None,      ) -> List[Job]:          \"\"\"Submit this scenario for execution.            All the `Task^`s of the scenario will be submitted for execution.            Parameters:              callbacks (List[Callable]): The list of callable functions to be called on status                  change.              force (bool): Force execution even if the data nodes are in cache.              wait (bool): Wait for the orchestrated jobs created from the scenario submission to be finished in                  asynchronous mode.              timeout (Union[float, int]): The optional maximum number of seconds to wait for the jobs to be finished                  before returning.            Returns:              A list of created `Job^`s.          \"\"\"          from ._scenario_manager_factory import _ScenarioManagerFactory            return _ScenarioManagerFactory._build_manager()._submit(self, callbacks, force, wait, timeout)        def export(          self,          folder_path: Union[str, pathlib.Path],      ):          \"\"\"Export all related entities of this scenario to a folder.            Parameters:              folder_path (Union[str, pathlib.Path]): The folder path to export the scenario to.          \"\"\"          from ... import core as tp            return tp.export_scenario(self.id, folder_path)        def set_primary(self):          \"\"\"Promote the scenario as the primary scenario of its cycle.            If the cycle already has a primary scenario, it will be demoted, and it will no longer          be primary for the cycle.          \"\"\"          from ... import core as tp            return tp.set_primary(self)        def add_tag(self, tag: str):          \"\"\"Add a tag to this scenario.            If the scenario's cycle already have another scenario tagged with _tag_ the other          scenario will be untagged.            Parameters:              tag (str): The tag to add to this scenario.          \"\"\"          from ... import core as tp            return tp.tag(self, tag)        def remove_tag(self, tag: str):          \"\"\"Remove a tag from this scenario.            Parameters:              tag (str): The tag to remove from the set of the scenario's tags.          \"\"\"          from ... import core as tp            return tp.untag(self, tag)        def is_deletable(self) -> bool:          \"\"\"Indicate if the scenario can be deleted.            Returns:              True if the scenario can be deleted. False otherwise.          \"\"\"          from ... import core as tp            return tp.is_deletable(self)        def get_label(self) -> str:          \"\"\"Returns the scenario simple label prefixed by its owner label.            Returns:              The label of the scenario as a string.          \"\"\"          return self._get_label()        def get_simple_label(self) -> str:          \"\"\"Returns the scenario simple label.            Returns:              The simple label of the scenario as a string.          \"\"\"          return self._get_simple_label()        def _is_consistent(self) -> bool:          dag = self._build_dag()          if dag.number_of_nodes() == 0:              return True          if not nx.is_directed_acyclic_graph(dag):              return False          for left_node, right_node in dag.edges:              if (isinstance(left_node, DataNode) and isinstance(right_node, Task)) or (                  isinstance(left_node, Task) and isinstance(right_node, DataNode)              ):                  continue              return False          return True      @_make_event.register(Scenario)  def _make_event_for_scenario(      scenario: Scenario,      operation: EventOperation,      /,      attribute_name: Optional[str] = None,      attribute_value: Optional[Any] = None,      **kwargs,  ) -> Event:      metadata = {\"config_id\": scenario.config_id, \"version\": scenario.version, **kwargs}      return Event(          entity_type=EventEntityType.SCENARIO,          entity_id=scenario.id,          operation=operation,          attribute_name=attribute_name,          attribute_value=attribute_value,          metadata=metadata,      ) "}
{"text": "import datetime  from functools import partial  from typing import Any, Callable, List, Optional, Union    from taipy.config import Config    from .._entity._entity_ids import _EntityIds  from .._manager._manager import _Manager  from .._repository._abstract_repository import _AbstractRepository  from .._version._version_mixin import _VersionMixin  from ..common.warn_if_inputs_not_ready import _warn_if_inputs_not_ready  from ..config.scenario_config import ScenarioConfig  from ..cycle._cycle_manager_factory import _CycleManagerFactory  from ..cycle.cycle import Cycle  from ..data._data_manager_factory import _DataManagerFactory  from ..exceptions.exceptions import (      DeletingPrimaryScenario,      DifferentScenarioConfigs,      DoesNotBelongToACycle,      InsufficientScenarioToCompare,      InvalidSequence,      InvalidSscenario,      NonExistingComparator,      NonExistingScenario,      NonExistingScenarioConfig,      SequenceTaskConfigDoesNotExistInSameScenarioConfig,      UnauthorizedTagError,  )  from ..job._job_manager_factory import _JobManagerFactory  from ..job.job import Job  from ..notification import EventEntityType, EventOperation, Notifier, _make_event  from ..submission._submission_manager_factory import _SubmissionManagerFactory  from ..task._task_manager_factory import _TaskManagerFactory  from .scenario import Scenario  from .scenario_id import ScenarioId      class _ScenarioManager(_Manager[Scenario], _VersionMixin):      _AUTHORIZED_TAGS_KEY = \"authorized_tags\"      _ENTITY_NAME = Scenario.__name__      _EVENT_ENTITY_TYPE = EventEntityType.SCENARIO        _repository: _AbstractRepository        @classmethod      def _get_all(cls, version_number: Optional[str] = None) -> List[Scenario]:          \"\"\"          Returns all entities.          \"\"\"          filters = cls._build_filters_with_version(version_number)          return cls._repository._load_all(filters)        @classmethod      def _subscribe(          cls,          callback: Callable[[Scenario, Job], None],          params: Optional[List[Any]] = None,          scenario: Optional[Scenario] = None,      ):          if scenario is None:              scenarios = cls._get_all()              for scn in scenarios:                  cls.__add_subscriber(callback, params, scn)              return            cls.__add_subscriber(callback, params, scenario)        @classmethod      def _unsubscribe(          cls,          callback: Callable[[Scenario, Job], None],          params: Optional[List[Any]] = None,          scenario: Optional[Scenario] = None,      ):          if scenario is None:              scenarios = cls._get_all()              for scn in scenarios:                  cls.__remove_subscriber(callback, params, scn)              return            cls.__remove_subscriber(callback, params, scenario)        @classmethod      def __add_subscriber(cls, callback, params, scenario: Scenario):          scenario._add_subscriber(callback, params)          Notifier.publish(              _make_event(scenario, EventOperation.UPDATE, attribute_name=\"subscribers\", attribute_value=params)          )        @classmethod      def __remove_subscriber(cls, callback, params, scenario: Scenario):          scenario._remove_subscriber(callback, params)          Notifier.publish(              _make_event(scenario, EventOperation.UPDATE, attribute_name=\"subscribers\", attribute_value=params)          )        @classmethod      def _create(          cls,          config: ScenarioConfig,          creation_date: Optional[datetime.datetime] = None,          name: Optional[str] = None,      ) -> Scenario:          _task_manager = _TaskManagerFactory._build_manager()          _data_manager = _DataManagerFactory._build_manager()            scenario_id = Scenario._new_id(str(config.id))          cycle = (              _CycleManagerFactory._build_manager()._get_or_create(config.frequency, creation_date)              if config.frequency              else None          )          cycle_id = cycle.id if cycle else None          tasks = (              _task_manager._bulk_get_or_create(config.task_configs, cycle_id, scenario_id) if config.task_configs else []          )          additional_data_nodes = (              _data_manager._bulk_get_or_create(config.additional_data_node_configs, cycle_id, scenario_id)              if config.additional_data_node_configs              else {}          )            sequences = {}          tasks_and_config_id_maps = {task.config_id: task for task in tasks}          for sequence_name, sequence_task_configs in config.sequences.items():              sequence_tasks = []              non_existing_sequence_task_config_in_scenario_config = set()              for sequence_task_config in sequence_task_configs:                  if task := tasks_and_config_id_maps.get(sequence_task_config.id):                      sequence_tasks.append(task)                  else:                      non_existing_sequence_task_config_in_scenario_config.add(sequence_task_config.id)              if len(non_existing_sequence_task_config_in_scenario_config) > 0:                  raise SequenceTaskConfigDoesNotExistInSameScenarioConfig(                      list(non_existing_sequence_task_config_in_scenario_config), sequence_name, str(config.id)                  )              sequences[sequence_name] = {Scenario._SEQUENCE_TASKS_KEY: sequence_tasks}            is_primary_scenario = len(cls._get_all_by_cycle(cycle)) == 0 if cycle else False          props = config._properties.copy()          if name:              props[\"name\"] = name          version = cls._get_latest_version()            scenario = Scenario(              config_id=str(config.id),              tasks=set(tasks),              properties=props,              additional_data_nodes=set(additional_data_nodes.values()),              scenario_id=scenario_id,              creation_date=creation_date,              is_primary=is_primary_scenario,              cycle=cycle,              version=version,              sequences=sequences,          )            for task in tasks:              if scenario_id not in task._parent_ids:                  task._parent_ids.update([scenario_id])                  _task_manager._set(task)            for dn in additional_data_nodes.values():              if scenario_id not in dn._parent_ids:                  dn._parent_ids.update([scenario_id])                  _data_manager._set(dn)            cls._set(scenario)            if not scenario._is_consistent():              raise InvalidSscenario(scenario.id)            actual_sequences = scenario._get_sequences()          for sequence_name in sequences.keys():              if not actual_sequences[sequence_name]._is_consistent():                  raise InvalidSequence(actual_sequences[sequence_name].id)              Notifier.publish(_make_event(actual_sequences[sequence_name], EventOperation.CREATION))            Notifier.publish(_make_event(scenario, EventOperation.CREATION))          return scenario        @classmethod      def _is_submittable(cls, scenario: Union[Scenario, ScenarioId]) -> bool:          if isinstance(scenario, str):              scenario = cls._get(scenario)          return isinstance(scenario, Scenario) and scenario.is_ready_to_run()        @classmethod      def _submit(          cls,          scenario: Union[Scenario, ScenarioId],          callbacks: Optional[List[Callable]] = None,          force: bool = False,          wait: bool = False,          timeout: Optional[Union[float, int]] = None,          check_inputs_are_ready: bool = True,      ) -> List[Job]:          scenario_id = scenario.id if isinstance(scenario, Scenario) else scenario          scenario = cls._get(scenario_id)          if scenario is None:              raise NonExistingScenario(scenario_id)          callbacks = callbacks or []          scenario_subscription_callback = cls.__get_status_notifier_callbacks(scenario) + callbacks          if check_inputs_are_ready:              _warn_if_inputs_not_ready(scenario.get_inputs())            jobs = (              _TaskManagerFactory._build_manager()              ._orchestrator()              .submit(scenario, callbacks=scenario_subscription_callback, force=force, wait=wait, timeout=timeout)          )          Notifier.publish(_make_event(scenario, EventOperation.SUBMISSION))          return jobs        @classmethod      def __get_status_notifier_callbacks(cls, scenario: Scenario) -> List:          return [partial(c.callback, *c.params, scenario) for c in scenario.subscribers]        @classmethod      def _get_primary(cls, cycle: Cycle) -> Optional[Scenario]:          scenarios = cls._get_all_by_cycle(cycle)          for scenario in scenarios:              if scenario.is_primary:                  return scenario          return None        @classmethod      def _get_by_tag(cls, cycle: Cycle, tag: str) -> Optional[Scenario]:          scenarios = cls._get_all_by_cycle(cycle)          for scenario in scenarios:              if scenario.has_tag(tag):                  return scenario          return None        @classmethod      def _get_all_by_tag(cls, tag: str) -> List[Scenario]:          scenarios = []          for scenario in cls._get_all():              if scenario.has_tag(tag):                  scenarios.append(scenario)          return scenarios        @classmethod      def _get_all_by_cycle(cls, cycle: Cycle) -> List[Scenario]:          filters = cls._build_filters_with_version(\"all\")            if not filters:              filters = [{}]          for fil in filters:              fil.update({\"cycle\": cycle.id})          return cls._get_all_by(filters)        @classmethod      def _get_primary_scenarios(cls) -> List[Scenario]:          primary_scenarios = []          for scenario in cls._get_all():              if scenario.is_primary:                  primary_scenarios.append(scenario)          return primary_scenarios        @classmethod      def _is_promotable_to_primary(cls, scenario: Union[Scenario, ScenarioId]) -> bool:          if isinstance(scenario, str):              scenario = cls._get(scenario)          if scenario and not scenario.is_primary and scenario.cycle:              return True          return False        @classmethod      def _set_primary(cls, scenario: Scenario):          if scenario.cycle:              primary_scenario = cls._get_primary(scenario.cycle)              # To prevent SAME scenario updating out of Context Manager              if primary_scenario and primary_scenario != scenario:                  primary_scenario.is_primary = False  # type: ignore              scenario.is_primary = True  # type: ignore          else:              raise DoesNotBelongToACycle(                  f\"Can't set scenario {scenario.id} to primary because it doesn't belong to a cycle.\"              )        @classmethod      def _tag(cls, scenario: Scenario, tag: str):          tags = scenario.properties.get(cls._AUTHORIZED_TAGS_KEY, set())          if len(tags) > 0 and tag not in tags:              raise UnauthorizedTagError(f\"Tag `{tag}` not authorized by scenario configuration `{scenario.config_id}`\")          if scenario.cycle:              old_tagged_scenario = cls._get_by_tag(scenario.cycle, tag)              if old_tagged_scenario:                  old_tagged_scenario.remove_tag(tag)                  cls._set(old_tagged_scenario)          scenario._add_tag(tag)          cls._set(scenario)          Notifier.publish(              _make_event(scenario, EventOperation.UPDATE, attribute_name=\"tags\", attribute_value=scenario.tags)          )        @classmethod      def _untag(cls, scenario: Scenario, tag: str):          scenario._remove_tag(tag)          cls._set(scenario)          Notifier.publish(              _make_event(scenario, EventOperation.UPDATE, attribute_name=\"tags\", attribute_value=scenario.tags)          )        @classmethod      def _compare(cls, *scenarios: Scenario, data_node_config_id: Optional[str] = None):          if len(scenarios) < 2:              raise InsufficientScenarioToCompare(\"At least two scenarios are required to compare.\")            if not all(scenarios[0].config_id == scenario.config_id for scenario in scenarios):              raise DifferentScenarioConfigs(\"Scenarios to compare must have the same configuration.\")            if scenario_config := _ScenarioManager.__get_config(scenarios[0]):              results = {}              if data_node_config_id:                  if data_node_config_id in scenario_config.comparators.keys():                      dn_comparators = {data_node_config_id: scenario_config.comparators[data_node_config_id]}                  else:                      raise NonExistingComparator(f\"Data node config {data_node_config_id} has no comparator.\")              else:                  dn_comparators = scenario_config.comparators                for data_node_config_id, comparators in dn_comparators.items():                  data_nodes = [scenario.__getattr__(data_node_config_id).read() for scenario in scenarios]                  results[data_node_config_id] = {                      comparator.__name__: comparator(*data_nodes) for comparator in comparators                  }                return results            else:              raise NonExistingScenarioConfig(scenarios[0].config_id)        @staticmethod      def __get_config(scenario: Scenario):          return Config.scenarios.get(scenario.config_id, None)        @classmethod      def _is_deletable(cls, scenario: Union[Scenario, ScenarioId]) -> bool:          if isinstance(scenario, str):              scenario = cls._get(scenario)          if scenario.is_primary:              if len(cls._get_all_by_cycle(scenario.cycle)) > 1:                  return False          return True        @classmethod      def _delete(cls, scenario_id: ScenarioId):          scenario = cls._get(scenario_id)          if not cls._is_deletable(scenario):              raise DeletingPrimaryScenario(                  f\"Scenario {scenario.id}, which has config id {scenario.config_id}, is primary and there are \"                  f\"other scenarios in the same cycle. \"              )          if scenario.is_primary:              _CycleManagerFactory._build_manager()._delete(scenario.cycle.id)          super()._delete(scenario_id)        @classmethod      def _hard_delete(cls, scenario_id: ScenarioId):          scenario = cls._get(scenario_id)          if not cls._is_deletable(scenario):              raise DeletingPrimaryScenario(                  f\"Scenario {scenario.id}, which has config id {scenario.config_id}, is primary and there are \"                  f\"other scenarios in the same cycle. \"              )          if scenario.is_primary:              _CycleManagerFactory._build_manager()._hard_delete(scenario.cycle.id)          else:              entity_ids_to_delete = cls._get_children_entity_ids(scenario)              entity_ids_to_delete.scenario_ids.add(scenario.id)              cls._delete_entities_of_multiple_types(entity_ids_to_delete)        @classmethod      def _delete_by_version(cls, version_number: str):          \"\"\"          Deletes scenario by the version number.            Check if the cycle is only attached to this scenario, then delete it.          \"\"\"          for scenario in cls._repository._search(\"version\", version_number):              if scenario.cycle and len(cls._get_all_by_cycle(scenario.cycle)) == 1:                  _CycleManagerFactory._build_manager()._delete(scenario.cycle.id)              super()._delete(scenario.id)        @classmethod      def _get_children_entity_ids(cls, scenario: Scenario) -> _EntityIds:          entity_ids = _EntityIds()          for sequence in scenario.sequences.values():              if sequence.owner_id == scenario.id:                  entity_ids.sequence_ids.add(sequence.id)          for task in scenario.tasks.values():              if task.owner_id == scenario.id:                  entity_ids.task_ids.add(task.id)          for data_node in scenario.data_nodes.values():              if data_node.owner_id == scenario.id:                  entity_ids.data_node_ids.add(data_node.id)            jobs = _JobManagerFactory._build_manager()._get_all()          for job in jobs:              if job.task.id in entity_ids.task_ids:                  entity_ids.job_ids.add(job.id)            submissions = _SubmissionManagerFactory._build_manager()._get_all()          submitted_entity_ids = list(entity_ids.scenario_ids.union(entity_ids.sequence_ids, entity_ids.task_ids))          for submission in submissions:              if submission.entity_id in submitted_entity_ids:                  entity_ids.submission_ids.add(submission.id)            return entity_ids        @classmethod      def _get_by_config_id(cls, config_id: str, version_number: Optional[str] = None) -> List[Scenario]:          \"\"\"          Get all scenarios by its config id.          \"\"\"          filters = cls._build_filters_with_version(version_number)          if not filters:              filters = [{}]          for fil in filters:              fil.update({\"config_id\": config_id})          return cls._repository._load_all(filters) "}
{"text": "#  # Licensed under the Apache License, Version 2.0 (the \"License\"); you may not use this file except in compliance with  # the License. You may obtain a copy of the License at  #  #        http://www.apache.org/licenses/LICENSE-2.0  #  # Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on  # an \"AS IS\" BASIS, WITHOUT 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": "import itertools  import uuid  from datetime import datetime  from multiprocessing import Lock  from queue import Queue  from time import sleep  from typing import Callable, Iterable, List, Optional, Set, Union    from taipy.config.config import Config  from taipy.logger._taipy_logger import _TaipyLogger    from .._entity.submittable import Submittable  from ..data._data_manager_factory import _DataManagerFactory  from ..job._job_manager_factory import _JobManagerFactory  from ..job.job import Job  from ..job.job_id import JobId  from ..submission._submission_manager_factory import _SubmissionManagerFactory  from ..task.task import Task  from ._abstract_orchestrator import _AbstractOrchestrator      class _Orchestrator(_AbstractOrchestrator):      \"\"\"      Handles the functional orchestrating.      \"\"\"        jobs_to_run: Queue = Queue()      blocked_jobs: List = []      lock = Lock()      __logger = _TaipyLogger._get_logger()        @classmethod      def initialize(cls):          pass        @classmethod      def submit(          cls,          submittable: Submittable,          callbacks: Optional[Iterable[Callable]] = None,          force: bool = False,          wait: bool = False,          timeout: Optional[Union[float, int]] = None,      ) -> List[Job]:          \"\"\"Submit the given `Scenario^` or `Sequence^` for an execution.            Parameters:               submittable (Union[SCenario^, Sequence^]): The scenario or sequence to submit for execution.               callbacks: The optional list of functions that should be executed on jobs status change.               force (bool) : Enforce execution of the scenario's or sequence's tasks even if their output data                  nodes are cached.               wait (bool): Wait for the orchestrated jobs created from the scenario or sequence submission to be                  finished in asynchronous mode.               timeout (Union[float, int]): The optional maximum number of seconds to wait for the jobs to be finished                  before returning.          Returns:              The created Jobs.          \"\"\"          submission = _SubmissionManagerFactory._build_manager()._create(submittable.id)  # type: ignore          jobs = []          tasks = submittable._get_sorted_tasks()          with cls.lock:              for ts in tasks:                  for task in ts:                      jobs.append(                          cls._lock_dn_output_and_create_job(                              task,                              submission.id,                              submission.entity_id,                              callbacks=itertools.chain([submission._update_submission_status], callbacks or []),                              force=force,  # type: ignore                          )                      )            submission.jobs = jobs  # type: ignore            cls._orchestrate_job_to_run_or_block(jobs)            if Config.job_config.is_development:              cls._check_and_execute_jobs_if_development_mode()          else:              if wait:                  cls.__wait_until_job_finished(jobs, timeout=timeout)            return jobs        @classmethod      def submit_task(          cls,          task: Task,          callbacks: Optional[Iterable[Callable]] = None,          force: bool = False,          wait: bool = False,          timeout: Optional[Union[float, int]] = None,      ) -> Job:          \"\"\"Submit the given `Task^` for an execution.            Parameters:               task (Task^): The task to submit for execution.               submit_id (str): The optional id to differentiate each submission.               callbacks: The optional list of functions that should be executed on job status change.               force (bool): Enforce execution of the task even if its output data nodes are cached.               wait (bool): Wait for the orchestrated job created from the task submission to be finished                  in asynchronous mode.               timeout (Union[float, int]): The optional maximum number of seconds to wait for the job                  to be finished before returning.          Returns:              The created `Job^`.          \"\"\"          submission = _SubmissionManagerFactory._build_manager()._create(task.id)          submit_id = submission.id          with cls.lock:              job = cls._lock_dn_output_and_create_job(                  task,                  submit_id,                  submission.entity_id,                  itertools.chain([submission._update_submission_status], callbacks or []),                  force,              )            jobs = [job]          submission.jobs = jobs  # type: ignore            cls._orchestrate_job_to_run_or_block(jobs)            if Config.job_config.is_development:              cls._check_and_execute_jobs_if_development_mode()          else:              if wait:                  cls.__wait_until_job_finished(job, timeout=timeout)            return job        @classmethod      def _lock_dn_output_and_create_job(          cls,          task: Task,          submit_id: str,          submit_entity_id: str,          callbacks: Optional[Iterable[Callable]] = None,          force: bool = False,      ) -> Job:          for dn in task.output.values():              dn.lock_edit()          job = _JobManagerFactory._build_manager()._create(              task, itertools.chain([cls._on_status_change], callbacks or []), submit_id, submit_entity_id, force=force          )            return job        @classmethod      def _orchestrate_job_to_run_or_block(cls, jobs: List[Job]):          blocked_jobs = []          pending_jobs = []            for job in jobs:              if cls._is_blocked(job):                  job.blocked()                  blocked_jobs.append(job)              else:                  job.pending()                  pending_jobs.append(job)            cls.blocked_jobs.extend(blocked_jobs)          for job in pending_jobs:              cls.jobs_to_run.put(job)        @classmethod      def __wait_until_job_finished(cls, jobs: Union[List[Job], Job], timeout: Optional[Union[float, int]] = None):          def __check_if_timeout(start, timeout):              if timeout:                  return (datetime.now() - start).seconds < timeout              return True            start = datetime.now()          jobs = jobs if isinstance(jobs, Iterable) else [jobs]          index = 0            while __check_if_timeout(start, timeout) and index < len(jobs):              try:                  if jobs[index]._is_finished():                      index = index + 1                  else:                      sleep(0.5)  # Limit CPU usage                except Exception:                  pass        @classmethod      def _is_blocked(cls, obj: Union[Task, Job]) -> bool:          \"\"\"Returns True if the execution of the `Job^` or the `Task^` is blocked by the execution of another `Job^`.            Parameters:               obj (Union[Task^, Job^]): The job or task entity to run.            Returns:               True if one of its input data nodes is blocked.          \"\"\"          input_data_nodes = obj.task.input.values() if isinstance(obj, Job) else obj.input.values()          data_manager = _DataManagerFactory._build_manager()          return any(not data_manager._get(dn.id).is_ready_for_reading for dn in input_data_nodes)        @staticmethod      def _unlock_edit_on_jobs_outputs(jobs: Union[Job, List[Job], Set[Job]]):          jobs = [jobs] if isinstance(jobs, Job) else jobs          for job in jobs:              job._unlock_edit_on_outputs()        @classmethod      def _on_status_change(cls, job: Job):          if job.is_completed() or job.is_skipped():              cls.__unblock_jobs()          elif job.is_failed():              print(f\"\\nJob {job.id} failed, abandoning subsequent jobs.\\n\")              cls._fail_subsequent_jobs(job)        @classmethod      def __unblock_jobs(cls):          for job in cls.blocked_jobs:              if not cls._is_blocked(job):                  with cls.lock:                      job.pending()                      cls.__remove_blocked_job(job)                      cls.jobs_to_run.put(job)        @classmethod      def __remove_blocked_job(cls, job):          try:  # In case the job has been removed from the list of blocked_jobs.              cls.blocked_jobs.remove(job)          except Exception:              cls.__logger.warning(f\"{job.id} is not in the blocked list anymore.\")        @classmethod      def cancel_job(cls, job: Job):          if job.is_canceled():              cls.__logger.info(f\"{job.id} has already been canceled.\")          elif job.is_abandoned():              cls.__logger.info(f\"{job.id} has already been abandoned and cannot be canceled.\")          elif job.is_failed():              cls.__logger.info(f\"{job.id} has already failed and cannot be canceled.\")          else:              with cls.lock:                  to_cancel_or_abandon_jobs = set([job])                  to_cancel_or_abandon_jobs.update(cls.__find_subsequent_jobs(job.submit_id, set(job.task.output.keys())))                  cls.__remove_blocked_jobs(to_cancel_or_abandon_jobs)                  cls.__remove_jobs_to_run(to_cancel_or_abandon_jobs)                  cls._cancel_jobs(job.id, to_cancel_or_abandon_jobs)                  cls._unlock_edit_on_jobs_outputs(to_cancel_or_abandon_jobs)        @classmethod      def __find_subsequent_jobs(cls, submit_id, output_dn_config_ids: Set) -> Set[Job]:          next_output_dn_config_ids = set()          subsequent_jobs = set()          for job in cls.blocked_jobs:              job_input_dn_config_ids = job.task.input.keys()              if job.submit_id == submit_id and len(output_dn_config_ids.intersection(job_input_dn_config_ids)) > 0:                  next_output_dn_config_ids.update(job.task.output.keys())                  subsequent_jobs.update([job])          if len(next_output_dn_config_ids) > 0:              subsequent_jobs.update(                  cls.__find_subsequent_jobs(submit_id, output_dn_config_ids=next_output_dn_config_ids)              )          return subsequent_jobs        @classmethod      def __remove_blocked_jobs(cls, jobs):          for job in jobs:              cls.__remove_blocked_job(job)        @classmethod      def __remove_jobs_to_run(cls, jobs):          new_jobs_to_run: Queue = Queue()          while not cls.jobs_to_run.empty():              current_job = cls.jobs_to_run.get()              if current_job not in jobs:                  new_jobs_to_run.put(current_job)          cls.jobs_to_run = new_jobs_to_run        @classmethod      def _fail_subsequent_jobs(cls, failed_job: Job):          with cls.lock:              to_fail_or_abandon_jobs = set()              to_fail_or_abandon_jobs.update(                  cls.__find_subsequent_jobs(failed_job.submit_id, set(failed_job.task.output.keys()))              )              for job in to_fail_or_abandon_jobs:                  print(f\"Abandoning job: {job.id}\")                  job.abandoned()              to_fail_or_abandon_jobs.update([failed_job])              cls.__remove_blocked_jobs(to_fail_or_abandon_jobs)              cls.__remove_jobs_to_run(to_fail_or_abandon_jobs)              cls._unlock_edit_on_jobs_outputs(to_fail_or_abandon_jobs)        @classmethod      def _cancel_jobs(cls, job_id_to_cancel: JobId, jobs: Set[Job]):          from ._orchestrator_factory import _OrchestratorFactory            for job in jobs:              if job.id in _OrchestratorFactory._dispatcher._dispatched_processes.keys():  # type: ignore                  cls.__logger.info(f\"{job.id} is running and cannot be canceled.\")              elif job.is_completed() or job.is_skipped():                  cls.__logger.info(f\"{job.id} has already been completed and cannot be canceled.\")              elif job.is_skipped():                  cls.__logger.info(f\"{job.id} has already been skipped and cannot be canceled.\")              else:                  if job_id_to_cancel == job.id:                      job.canceled()                  else:                      job.abandoned()        @staticmethod      def _check_and_execute_jobs_if_development_mode():          from ._orchestrator_factory import _OrchestratorFactory            if dispatcher := _OrchestratorFactory._dispatcher:              dispatcher._execute_jobs_synchronously() "}
{"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": "import uuid  from typing import TYPE_CHECKING, Any, Callable, Dict, Iterable, List, Optional, Set, Union    from taipy.config.common._template_handler import _TemplateHandler as _tpl  from taipy.config.common._validate_id import _validate_id  from taipy.config.common.scope import Scope    from .._entity._entity import _Entity  from .._entity._labeled import _Labeled  from .._entity._properties import _Properties  from .._entity._reload import _Reloader, _self_reload, _self_setter  from .._version._version_manager_factory import _VersionManagerFactory  from ..data._data_manager_factory import _DataManagerFactory  from ..data.data_node import DataNode  from ..exceptions.exceptions import NonExistingDataNode  from ..notification.event import Event, EventEntityType, EventOperation, _make_event  from .task_id import TaskId    if TYPE_CHECKING:      from ..job.job import Job      class Task(_Entity, _Labeled):      \"\"\"Hold a user function that will be executed, its parameters and the results.        A `Task` brings together the user code as function, the inputs and the outputs as data nodes      (instances of the `DataNode^` class).        Attributes:          config_id (str): The identifier of the `TaskConfig^`.          properties (dict[str, Any]): A dictionary of additional properties.          function (callable): The python function to execute. The _function_ must take as parameter the              data referenced by inputs data nodes, and must return the data referenced by outputs data nodes.          input (Union[DataNode^, List[DataNode^]]): The list of inputs.          output (Union[DataNode^, List[DataNode^]]): The list of outputs.          id (str): The unique identifier of the task.          owner_id (str):  The identifier of the owner (sequence_id, scenario_id, cycle_id) or None.          parent_ids (Optional[Set[str]]): The set of identifiers of the parent sequences.          version (str): The string indicates the application version of the task to instantiate. If not provided, the              latest version is used.          skippable (bool): If True, indicates that the task can be skipped if no change has been made on inputs. The              default value is _False_.        \"\"\"        _ID_PREFIX = \"TASK\"      __ID_SEPARATOR = \"_\"      _MANAGER_NAME = \"task\"        def __init__(          self,          config_id: str,          properties: Dict[str, Any],          function,          input: Optional[Iterable[DataNode]] = None,          output: Optional[Iterable[DataNode]] = None,          id: Optional[TaskId] = None,          owner_id: Optional[str] = None,          parent_ids: Optional[Set[str]] = None,          version: Optional[str] = None,          skippable: bool = False,      ):          self.config_id = _validate_id(config_id)          self.id = id or TaskId(self.__ID_SEPARATOR.join([self._ID_PREFIX, self.config_id, str(uuid.uuid4())]))          self.owner_id = owner_id          self._parent_ids = parent_ids or set()          self.__input = {dn.config_id: dn for dn in input or []}          self.__output = {dn.config_id: dn for dn in output or []}          self._function = function          self._version = version or _VersionManagerFactory._build_manager()._get_latest_version()          self._skippable = skippable          self._properties = _Properties(self, **properties)        def __hash__(self):          return hash(self.id)        def __eq__(self, other):          return self.id == other.id        def __getstate__(self):          return vars(self)        def __setstate__(self, state):          vars(self).update(state)        def __getattr__(self, attribute_name):          protected_attribute_name = _validate_id(attribute_name)          if protected_attribute_name in self._properties:              return _tpl._replace_templates(self._properties[protected_attribute_name])          if protected_attribute_name in self.input:              return self.input[protected_attribute_name]          if protected_attribute_name in self.output:              return self.output[protected_attribute_name]          raise AttributeError(f\"{attribute_name} is not an attribute of task {self.id}\")        @property      def properties(self):          self._properties = _Reloader()._reload(self._MANAGER_NAME, self)._properties          return self._properties        def get_parents(self):          \"\"\"Get parents of the task.\"\"\"          from ... import core as tp            return tp.get_parents(self)        @property  # type: ignore      @_self_reload(_MANAGER_NAME)      def parent_ids(self):          return self._parent_ids        @property      def input(self) -> Dict[str, DataNode]:          return self.__input        @property      def output(self) -> Dict[str, DataNode]:          return self.__output        @property      def data_nodes(self) -> Dict[str, DataNode]:          return {**self.input, **self.output}        @property  # type: ignore      @_self_reload(_MANAGER_NAME)      def function(self):          return self._function        @function.setter  # type: ignore      @_self_setter(_MANAGER_NAME)      def function(self, val):          self._function = val        @property  # type: ignore      @_self_reload(_MANAGER_NAME)      def skippable(self):          return self._skippable        @skippable.setter  # type: ignore      @_self_setter(_MANAGER_NAME)      def skippable(self, val):          self._skippable = val        @property      def scope(self) -> Scope:          \"\"\"Retrieve the lowest scope of the task based on its data nodes.            Returns:              The lowest scope present in input and output data nodes or GLOBAL if there are                  either no input or no output.          \"\"\"          data_nodes = list(self.__input.values()) + list(self.__output.values())          scope = Scope(min(dn.scope for dn in data_nodes)) if len(data_nodes) != 0 else Scope.GLOBAL          return scope        @property      def version(self):          return self._version        def submit(          self,          callbacks: Optional[List[Callable]] = None,          force: bool = False,          wait: bool = False,          timeout: Optional[Union[float, int]] = None,      ) -> \"Job\":  # noqa          \"\"\"Submit the task for execution.            Parameters:              callbacks (List[Callable]): The list of callable functions to be called on status                  change.              force (bool): Force execution even if the data nodes are in cache.              wait (bool): Wait for the orchestrated job created from the task submission to be finished in asynchronous                  mode.              timeout (Union[float, int]): The maximum number of seconds to wait for the job to be finished before                  returning.            Returns:              The created `Job^`.          \"\"\"          from ._task_manager_factory import _TaskManagerFactory            return _TaskManagerFactory._build_manager()._submit(self, callbacks, force, wait, timeout)        def get_label(self) -> str:          \"\"\"Returns the task simple label prefixed by its owner label.            Returns:              The label of the task as a string.          \"\"\"          return self._get_label()        def get_simple_label(self) -> str:          \"\"\"Returns the task simple label.            Returns:              The simple label of the task as a string.          \"\"\"          return self._get_simple_label()      @_make_event.register(Task)  def _make_event_for_task(      task: Task,      operation: EventOperation,      /,      attribute_name: Optional[str] = None,      attribute_value: Optional[Any] = None,      **kwargs,  ) -> Event:      metadata = {\"version\": task.version, \"config_id\": task.config_id, **kwargs}      return Event(          entity_type=EventEntityType.TASK,          entity_id=task.id,          operation=operation,          attribute_name=attribute_name,          attribute_value=attribute_value,          metadata=metadata,      ) "}
{"text": "from typing import Callable, List, Optional, Type, Union    from taipy.config import Config  from taipy.config.common.scope import Scope    from .._entity._entity_ids import _EntityIds  from .._manager._manager import _Manager  from .._orchestrator._abstract_orchestrator import _AbstractOrchestrator  from .._repository._abstract_repository import _AbstractRepository  from .._version._version_manager_factory import _VersionManagerFactory  from .._version._version_mixin import _VersionMixin  from ..common.warn_if_inputs_not_ready import _warn_if_inputs_not_ready  from ..config.task_config import TaskConfig  from ..cycle.cycle_id import CycleId  from ..data._data_manager_factory import _DataManagerFactory  from ..exceptions.exceptions import NonExistingTask  from ..notification import EventEntityType, EventOperation, Notifier, _make_event  from ..scenario.scenario_id import ScenarioId  from ..sequence.sequence_id import SequenceId  from ..task.task import Task  from .task_id import TaskId      class _TaskManager(_Manager[Task], _VersionMixin):      _ENTITY_NAME = Task.__name__      _repository: _AbstractRepository      _EVENT_ENTITY_TYPE = EventEntityType.TASK        @classmethod      def _orchestrator(cls) -> Type[_AbstractOrchestrator]:          from .._orchestrator._orchestrator_factory import _OrchestratorFactory            return _OrchestratorFactory._build_orchestrator()        @classmethod      def _set(cls, task: Task):          cls.__save_data_nodes(task.input.values())          cls.__save_data_nodes(task.output.values())          super()._set(task)        @classmethod      def _bulk_get_or_create(          cls,          task_configs: List[TaskConfig],          cycle_id: Optional[CycleId] = None,          scenario_id: Optional[ScenarioId] = None,      ) -> List[Task]:          data_node_configs = set()          for task_config in task_configs:              data_node_configs.update([Config.data_nodes[dnc.id] for dnc in task_config.input_configs])              data_node_configs.update([Config.data_nodes[dnc.id] for dnc in task_config.output_configs])            data_nodes = _DataManagerFactory._build_manager()._bulk_get_or_create(              list(data_node_configs), cycle_id, scenario_id          )          tasks_configs_and_owner_id = []          for task_config in task_configs:              task_dn_configs = [Config.data_nodes[dnc.id] for dnc in task_config.output_configs] + [                  Config.data_nodes[dnc.id] for dnc in task_config.input_configs              ]              task_config_data_nodes = [data_nodes[dn_config] for dn_config in task_dn_configs]              scope = min(dn.scope for dn in task_config_data_nodes) if len(task_config_data_nodes) != 0 else Scope.GLOBAL              owner_id: Union[Optional[SequenceId], Optional[ScenarioId], Optional[CycleId]]              if scope == Scope.SCENARIO:                  owner_id = scenario_id              elif scope == Scope.CYCLE:                  owner_id = cycle_id              else:                  owner_id = None                tasks_configs_and_owner_id.append((task_config, owner_id))            tasks_by_config = cls._repository._get_by_configs_and_owner_ids(  # type: ignore              tasks_configs_and_owner_id, cls._build_filters_with_version(None)          )            tasks = []          for task_config, owner_id in tasks_configs_and_owner_id:              if task := tasks_by_config.get((task_config, owner_id)):                  tasks.append(task)              else:                  version = _VersionManagerFactory._build_manager()._get_latest_version()                  inputs = [                      data_nodes[input_config]                      for input_config in [Config.data_nodes[dnc.id] for dnc in task_config.input_configs]                  ]                  outputs = [                      data_nodes[output_config]                      for output_config in [Config.data_nodes[dnc.id] for dnc in task_config.output_configs]                  ]                  skippable = task_config.skippable                  task = Task(                      str(task_config.id),                      dict(**task_config._properties),                      task_config.function,                      inputs,                      outputs,                      owner_id=owner_id,                      parent_ids=set(),                      version=version,                      skippable=skippable,                  )                  for dn in set(inputs + outputs):                      dn._parent_ids.update([task.id])                  cls._set(task)                  Notifier.publish(_make_event(task, EventOperation.CREATION))                  tasks.append(task)          return tasks        @classmethod      def _get_all(cls, version_number: Optional[str] = None) -> List[Task]:          \"\"\"          Returns all entities.          \"\"\"          filters = cls._build_filters_with_version(version_number)          return cls._repository._load_all(filters)        @classmethod      def __save_data_nodes(cls, data_nodes):          data_manager = _DataManagerFactory._build_manager()          for i in data_nodes:              data_manager._set(i)        @classmethod      def _hard_delete(cls, task_id: TaskId):          task = cls._get(task_id)          entity_ids_to_delete = cls._get_children_entity_ids(task)          entity_ids_to_delete.task_ids.add(task.id)          cls._delete_entities_of_multiple_types(entity_ids_to_delete)        @classmethod      def _get_children_entity_ids(cls, task: Task):          entity_ids = _EntityIds()            from ..job._job_manager_factory import _JobManagerFactory          from ..submission._submission_manager_factory import _SubmissionManagerFactory            jobs = _JobManagerFactory._build_manager()._get_all()            for job in jobs:              if job.task.id == task.id:                  entity_ids.job_ids.add(job.id)            submissions = _SubmissionManagerFactory._build_manager()._get_all()          submitted_entity_ids = list(entity_ids.task_ids)          for submission in submissions:              if submission.entity_id in submitted_entity_ids:                  entity_ids.submission_ids.add(submission.id)            return entity_ids        @classmethod      def _is_submittable(cls, task: Union[Task, TaskId]) -> bool:          if isinstance(task, str):              task = cls._get(task)          return isinstance(task, Task) and all(input_dn.is_ready_for_reading for input_dn in task.input.values())        @classmethod      def _submit(          cls,          task: Union[TaskId, Task],          callbacks: Optional[List[Callable]] = None,          force: bool = False,          wait: bool = False,          timeout: Optional[Union[float, int]] = None,          check_inputs_are_ready: bool = True,      ):          task_id = task.id if isinstance(task, Task) else task          task = cls._get(task_id)          if task is None:              raise NonExistingTask(task_id)          if check_inputs_are_ready:              _warn_if_inputs_not_ready(task.input.values())          job = cls._orchestrator().submit_task(task, callbacks=callbacks, force=force, wait=wait, timeout=timeout)          Notifier.publish(_make_event(task, EventOperation.SUBMISSION))          return job        @classmethod      def _get_by_config_id(cls, config_id: str, version_number: Optional[str] = None) -> List[Task]:          \"\"\"          Get all tasks by its config id.          \"\"\"          filters = cls._build_filters_with_version(version_number)          if not filters:              filters = [{}]          for fil in filters:              fil.update({\"config_id\": config_id})          return cls._repository._load_all(filters) "}
{"text": "#  # Licensed under the Apache License, Version 2.0 (the \"License\"); you may not use this file except in compliance with  # the License. You may obtain a copy of the License at  #  #        http://www.apache.org/licenses/LICENSE-2.0  #  # Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on  # an \"AS IS\" BASIS, WITHOUT 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": "__all__ = [\"Job\"]    import traceback  from datetime import datetime  from typing import Any, Callable, List, Optional    from taipy.logger._taipy_logger import _TaipyLogger    from .._entity._entity import _Entity  from .._entity._labeled import _Labeled  from .._entity._reload import _self_reload, _self_setter  from .._version._version_manager_factory import _VersionManagerFactory  from ..common._utils import _fcts_to_dict  from ..notification.event import Event, EventEntityType, EventOperation, _make_event  from ..task.task import Task  from .job_id import JobId  from .status import Status      def _run_callbacks(fn):      def __run_callbacks(job):          fn(job)          for fct in job._subscribers:              fct(job)        return __run_callbacks      class Job(_Entity, _Labeled):      \"\"\"Execution of a `Task^`.        A job handles the status of the execution, contains the stacktrace of exceptions that were      raised during the execution, and notifies subscribers on status change.        Attributes:          id (str): The identifier of this job.          task (Task^): The task of this job.          force (bool): Enforce the job's execution whatever the output data nodes are in cache or              not.          status (Status^): The current status of this job.          creation_date (datetime): The date of this job's creation.          stacktrace (List[str]): The list of stacktraces of the exceptions raised during the execution.          version (str): The string indicates the application version of the job to instantiate. If not provided,              the latest version is used.      \"\"\"        _MANAGER_NAME = \"job\"      _ID_PREFIX = \"JOB\"        def __init__(self, id: JobId, task: Task, submit_id: str, submit_entity_id: str, force=False, version=None):          self.id = id          self._task = task          self._force = force          self._status = Status.SUBMITTED          self._creation_date = datetime.now()          self._submit_id: str = submit_id          self._submit_entity_id: str = submit_entity_id          self._subscribers: List[Callable] = []          self._stacktrace: List[str] = []          self.__logger = _TaipyLogger._get_logger()          self._version = version or _VersionManagerFactory._build_manager()._get_latest_version()        def get_event_context(self):          return {\"task_config_id\": self._task.config_id}        @property  # type: ignore      @_self_reload(_MANAGER_NAME)      def task(self):          return self._task        @task.setter  # type: ignore      @_self_setter(_MANAGER_NAME)      def task(self, val):          self._task = val        @property      def owner_id(self) -> str:          return self.task.id        @property  # type: ignore      @_self_reload(_MANAGER_NAME)      def force(self):          return self._force        @force.setter  # type: ignore      @_self_setter(_MANAGER_NAME)      def force(self, val):          self._force = val        @property      def submit_id(self):          return self._submit_id        @property      def submit_entity_id(self):          return self._submit_entity_id        @property  # type: ignore      def submit_entity(self):          from ..taipy import get as tp_get            return tp_get(self._submit_entity_id)        @property  # type: ignore      @_self_reload(_MANAGER_NAME)      def status(self):          return self._status        @status.setter  # type: ignore      @_self_setter(_MANAGER_NAME)      def status(self, val):          self._status = val        @property  # type: ignore      @_self_reload(_MANAGER_NAME)      def creation_date(self):          return self._creation_date        @creation_date.setter  # type: ignore      @_self_setter(_MANAGER_NAME)      def creation_date(self, val):          self._creation_date = val        @property      def stacktrace(self) -> List[str]:          return self._stacktrace        @property      def version(self):          return self._version        def __contains__(self, task: Task):          return self.task.id == task.id        def __lt__(self, other):          return self.creation_date.timestamp() < other.creation_date.timestamp()        def __le__(self, other):          return self.creation_date.timestamp() <= other.creation_date.timestamp()        def __gt__(self, other):          return self.creation_date.timestamp() > other.creation_date.timestamp()        def __ge__(self, other):          return self.creation_date.timestamp() >= other.creation_date.timestamp()        def __eq__(self, other):          return self.id == other.id        @_run_callbacks      def blocked(self):          \"\"\"Set the status to _blocked_ and notify subscribers.\"\"\"          self.status = Status.BLOCKED        @_run_callbacks      def pending(self):          \"\"\"Set the status to _pending_ and notify subscribers.\"\"\"          self.status = Status.PENDING        @_run_callbacks      def running(self):          \"\"\"Set the status to _running_ and notify subscribers.\"\"\"          self.status = Status.RUNNING        @_run_callbacks      def canceled(self):          \"\"\"Set the status to _canceled_ and notify subscribers.\"\"\"          self.status = Status.CANCELED        @_run_callbacks      def abandoned(self):          \"\"\"Set the status to _abandoned_ and notify subscribers.\"\"\"          self.status = Status.ABANDONED        @_run_callbacks      def failed(self):          \"\"\"Set the status to _failed_ and notify subscribers.\"\"\"          self.status = Status.FAILED        @_run_callbacks      def completed(self):          \"\"\"Set the status to _completed_ and notify subscribers.\"\"\"          self.status = Status.COMPLETED        @_run_callbacks      def skipped(self):          \"\"\"Set the status to _skipped_ and notify subscribers.\"\"\"          self.status = Status.SKIPPED        def is_failed(self) -> bool:          \"\"\"Indicate if the job has failed.            Returns:              True if the job has failed.          \"\"\"          return self.status == Status.FAILED        def is_blocked(self) -> bool:          \"\"\"Indicate if the job is blocked.            Returns:              True if the job is blocked.          \"\"\"          return self.status == Status.BLOCKED        def is_canceled(self) -> bool:          \"\"\"Indicate if the job was canceled.            Returns:              True if the job was canceled.          \"\"\"          return self.status == Status.CANCELED        def is_abandoned(self) -> bool:          \"\"\"Indicate if the job was abandoned.            Returns:              True if the job was abandoned.          \"\"\"          return self.status == Status.ABANDONED        def is_submitted(self) -> bool:          \"\"\"Indicate if the job is submitted.            Returns:              True if the job is submitted.          \"\"\"          return self.status == Status.SUBMITTED        def is_completed(self) -> bool:          \"\"\"Indicate if the job has completed.            Returns:              True if the job has completed.          \"\"\"          return self.status == Status.COMPLETED        def is_skipped(self) -> bool:          \"\"\"Indicate if the job was skipped.            Returns:              True if the job was skipped.          \"\"\"          return self.status == Status.SKIPPED        def is_running(self) -> bool:          \"\"\"Indicate if the job is running.            Returns:              True if the job is running.          \"\"\"          return self.status == Status.RUNNING        def is_pending(self) -> bool:          \"\"\"Indicate if the job is pending.            Returns:              True if the job is pending.          \"\"\"          return self.status == Status.PENDING        def is_finished(self) -> bool:          \"\"\"Indicate if the job is finished.            Returns:              True if the job is finished.          \"\"\"          return self.is_completed() or self.is_failed() or self.is_canceled() or self.is_skipped() or self.is_abandoned()        def _is_finished(self) -> bool:          \"\"\"Indicate if the job is finished. This function will not triggered the persistency feature like is_finished().            Returns:              True if the job is finished.          \"\"\"          return self._status in [Status.COMPLETED, Status.FAILED, Status.CANCELED, Status.SKIPPED, Status.ABANDONED]        def _on_status_change(self, *functions):          \"\"\"Get a notification when the status of the job changes.            Job are assigned different statuses (_submitted_, _pending_, etc.) before being finished.          You can be triggered on each change through this function except for the _submitted_          status.            Parameters:              functions: Callables that will be called on each status change.          \"\"\"          functions = list(functions)          function = functions.pop()          self._subscribers.append(function)            if self.status != Status.SUBMITTED:              function(self)            if functions:              self._on_status_change(*functions)        def update_status(self, exceptions):          \"\"\"Update the job status based on the success or the failure of its execution.\"\"\"          if exceptions:              self.failed()              self.__logger.error(f\" {len(exceptions)} errors occurred during execution of job {self.id}\")              for e in exceptions:                  st = \"\".join(traceback.format_exception(type(e), value=e, tb=e.__traceback__))                  self._stacktrace.append(st)                  self.__logger.error(st)          else:              self.completed()              self.__logger.info(f\"job {self.id} is completed.\")        def __hash__(self):          return hash(self.id)        def _unlock_edit_on_outputs(self):          for dn in self.task.output.values():              dn.unlock_edit()        @staticmethod      def _serialize_subscribers(subscribers: List) -> List:          return _fcts_to_dict(subscribers)        def get_label(self) -> str:          \"\"\"Returns the job simple label prefixed by its owner label.            Returns:              The label of the job as a string.          \"\"\"          return self._get_label()        def get_simple_label(self) -> str:          \"\"\"Returns the job simple label.            Returns:              The simple label of the job as a string.          \"\"\"          return self._get_simple_label()        def is_deletable(self) -> bool:          \"\"\"Indicate if the job can be deleted.            Returns:              True if the job can be deleted. False otherwise.          \"\"\"          from ... import core as tp            return tp.is_deletable(self)      @_make_event.register(Job)  def _make_event_for_job(      job: Job,      operation: EventOperation,      /,      attribute_name: Optional[str] = None,      attribute_value: Optional[Any] = None,      **kwargs,  ) -> Event:      metadata = {\"creation_date\": job.creation_date, \"task_config_id\": job._task.config_id}      return Event(          entity_type=EventEntityType.JOB,          entity_id=job.id,          operation=operation,          attribute_name=attribute_name,          attribute_value=attribute_value,          metadata={**metadata, **kwargs},      ) "}
{"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": "import json  import pathlib  from functools import partial  from typing import Any, Callable, Dict, Iterable, List, Optional, Tuple, Union    from .._entity._entity_ids import _EntityIds  from .._manager._manager import _Manager  from .._version._version_mixin import _VersionMixin  from ..common._utils import _Subscriber  from ..common.warn_if_inputs_not_ready import _warn_if_inputs_not_ready  from ..exceptions.exceptions import (      InvalidSequenceId,      ModelNotFound,      NonExistingSequence,      NonExistingTask,      SequenceBelongsToNonExistingScenario,  )  from ..job._job_manager_factory import _JobManagerFactory  from ..job.job import Job  from ..notification import Event, EventEntityType, EventOperation, Notifier  from ..notification.event import _make_event  from ..scenario._scenario_manager_factory import _ScenarioManagerFactory  from ..scenario.scenario import Scenario  from ..scenario.scenario_id import ScenarioId  from ..submission._submission_manager_factory import _SubmissionManagerFactory  from ..task._task_manager_factory import _TaskManagerFactory  from ..task.task import Task, TaskId  from .sequence import Sequence  from .sequence_id import SequenceId      class _SequenceManager(_Manager[Sequence], _VersionMixin):      _ENTITY_NAME = Sequence.__name__      _EVENT_ENTITY_TYPE = EventEntityType.SEQUENCE      _model_name = \"sequences\"        @classmethod      def _delete(cls, sequence_id: SequenceId):          \"\"\"          Deletes a Sequence by id.          \"\"\"          sequence_name, scenario_id = cls._breakdown_sequence_id(sequence_id)            if scenario := _ScenarioManagerFactory._build_manager()._get(scenario_id):              if sequence_name in scenario._sequences.keys():                  scenario.remove_sequences([sequence_name])                  if hasattr(cls, \"_EVENT_ENTITY_TYPE\"):                      Notifier.publish(Event(cls._EVENT_ENTITY_TYPE, EventOperation.DELETION, entity_id=sequence_id))                  return          raise ModelNotFound(cls._model_name, sequence_id)        @classmethod      def _delete_all(cls):          \"\"\"          Deletes all Sequences.          \"\"\"          scenarios = _ScenarioManagerFactory._build_manager()._get_all()          for scenario in scenarios:              scenario.sequences = {}          if hasattr(cls, \"_EVENT_ENTITY_TYPE\"):              Notifier.publish(Event(cls._EVENT_ENTITY_TYPE, EventOperation.DELETION, metadata={\"delete_all\": True}))        @classmethod      def _delete_many(cls, sequence_ids: Iterable[str]):          \"\"\"          Deletes Sequence entities by a list of Sequence ids.          \"\"\"          scenario_manager = _ScenarioManagerFactory._build_manager()            scenario_ids_and_sequence_names_map: Dict[str, List[str]] = {}          for sequence in sequence_ids:              sequence_id = sequence.id if isinstance(sequence, Sequence) else sequence              sequence_name, scenario_id = cls._breakdown_sequence_id(sequence_id)              sequences_names = scenario_ids_and_sequence_names_map.get(scenario_id, [])              sequences_names.append(sequence_name)              scenario_ids_and_sequence_names_map[scenario_id] = sequences_names            try:              for scenario_id, sequence_names in scenario_ids_and_sequence_names_map.items():                  scenario = scenario_manager._get(scenario_id)                  for sequence_name in sequence_names:                      del scenario._sequences[sequence_name]                  scenario_manager._set(scenario)                if hasattr(cls, \"_EVENT_ENTITY_TYPE\"):                  for sequence_id in sequence_ids:                      Notifier.publish(Event(cls._EVENT_ENTITY_TYPE, EventOperation.DELETION, entity_id=sequence_id))          except (ModelNotFound, KeyError):              cls.__log_error_entity_not_found(sequence_id)              raise ModelNotFound(cls._model_name, sequence_id)        @classmethod      def _delete_by_version(cls, version_number: str):          \"\"\"          Deletes Sequences by version number.          \"\"\"          for scenario in _ScenarioManagerFactory()._build_manager()._repository._search(\"version\", version_number):              cls._delete_many(scenario.sequences.values())        @classmethod      def _hard_delete(cls, sequence_id: SequenceId):          sequence = cls._get(sequence_id)          entity_ids_to_delete = cls._get_children_entity_ids(sequence)          entity_ids_to_delete.sequence_ids.add(sequence.id)          cls._delete_entities_of_multiple_types(entity_ids_to_delete)        @classmethod      def _set(cls, sequence: Sequence):          \"\"\"          Save or update a Sequence.          \"\"\"          sequence_name, scenario_id = cls._breakdown_sequence_id(sequence.id)          scenario_manager = _ScenarioManagerFactory._build_manager()            if scenario := scenario_manager._get(scenario_id):              sequence_data = {                  Scenario._SEQUENCE_TASKS_KEY: sequence._tasks,                  Scenario._SEQUENCE_SUBSCRIBERS_KEY: sequence._subscribers,                  Scenario._SEQUENCE_PROPERTIES_KEY: sequence._properties.data,              }              scenario._sequences[sequence_name] = sequence_data              scenario_manager._set(scenario)          else:              cls._logger.error(f\"Sequence {sequence.id} belongs to a non-existing Scenario {scenario_id}.\")              raise SequenceBelongsToNonExistingScenario(sequence.id, scenario_id)        @classmethod      def _create(          cls,          sequence_name: str,          tasks: Union[List[Task], List[TaskId]],          subscribers: Optional[List[_Subscriber]] = None,          properties: Optional[Dict] = None,          scenario_id: Optional[ScenarioId] = None,          version: Optional[str] = None,      ) -> Sequence:          sequence_id = Sequence._new_id(sequence_name, scenario_id)            task_manager = _TaskManagerFactory._build_manager()          _tasks: List[Task] = []          for task in tasks:              if not isinstance(task, Task):                  if _task := task_manager._get(task):                      _tasks.append(_task)                  else:                      raise NonExistingTask(task)              else:                  _tasks.append(task)            properties = properties if properties else {}          properties[\"name\"] = sequence_name          version = version if version else cls._get_latest_version()          sequence = Sequence(              properties=properties,              tasks=_tasks,              sequence_id=sequence_id,              owner_id=scenario_id,              parent_ids={scenario_id} if scenario_id else None,              subscribers=subscribers,              version=version,          )          for task in _tasks:              if sequence_id not in task._parent_ids:                  task._parent_ids.update([sequence_id])                  task_manager._set(task)          return sequence        @classmethod      def _breakdown_sequence_id(cls, sequence_id: str) -> Tuple[str, str]:          try:              sequence_name, scenario_id = sequence_id.split(Scenario._ID_PREFIX)              scenario_id = f\"{Scenario._ID_PREFIX}{scenario_id}\"              sequence_name = sequence_name.split(Sequence._ID_PREFIX)[1].strip(\"_\")              return sequence_name, scenario_id          except (ValueError, IndexError):              cls._logger.error(f\"SequenceId {sequence_id} is invalid.\")              raise InvalidSequenceId(sequence_id)        @classmethod      def _get(cls, sequence: Union[str, Sequence], default=None) -> Sequence:          \"\"\"          Returns a Sequence by id or reference.          \"\"\"          try:              sequence_id = sequence.id if isinstance(sequence, Sequence) else sequence              sequence_name, scenario_id = cls._breakdown_sequence_id(sequence_id)                scenario_manager = _ScenarioManagerFactory._build_manager()              if scenario := scenario_manager._get(scenario_id):                  if sequence_entity := scenario.sequences.get(sequence_name, None):                      return sequence_entity              cls.__log_error_entity_not_found(sequence_id)              return default          except (ModelNotFound, InvalidSequenceId):              cls.__log_error_entity_not_found(sequence_id)              return default        @classmethod      def _get_all(cls, version_number: Optional[str] = None) -> List[Sequence]:          \"\"\"          Returns all Sequence entities.          \"\"\"          sequences = []          scenarios = _ScenarioManagerFactory._build_manager()._get_all(version_number)          for scenario in scenarios:              sequences.extend(list(scenario.sequences.values()))          return sequences        @classmethod      def _get_all_by(cls, filters: Optional[List[Dict]] = None) -> List[Sequence]:          sequences = cls._get_all()            if not filters:              return sequences            filtered_sequences = []          for sequence in sequences:              for filter in filters:                  if all([getattr(sequence, key) == item for key, item in filter.items()]):                      filtered_sequences.append(sequence)          return filtered_sequences        @classmethod      def _get_children_entity_ids(cls, sequence: Sequence) -> _EntityIds:          entity_ids = _EntityIds()          for task in sequence.tasks.values():              if not isinstance(task, Task):                  task = _TaskManagerFactory._build_manager()._get(task)              if task.owner_id == sequence.id:                  entity_ids.task_ids.add(task.id)              for data_node in task.data_nodes.values():                  if data_node.owner_id == sequence.id:                      entity_ids.data_node_ids.add(data_node.id)            jobs = _JobManagerFactory._build_manager()._get_all()          for job in jobs:              if job.task.id in entity_ids.task_ids:                  entity_ids.job_ids.add(job.id)            submissions = _SubmissionManagerFactory._build_manager()._get_all()          submitted_entity_ids = list(entity_ids.sequence_ids.union(entity_ids.task_ids))          for submission in submissions:              if submission.entity_id in submitted_entity_ids:                  entity_ids.submission_ids.add(submission.id)            return entity_ids        @classmethod      def _subscribe(          cls,          callback: Callable[[Sequence, Job], None],          params: Optional[List[Any]] = None,          sequence: Optional[Sequence] = None,      ):          if sequence is None:              sequences = cls._get_all()              for pln in sequences:                  cls.__add_subscriber(callback, params, pln)              return          cls.__add_subscriber(callback, params, sequence)        @classmethod      def _unsubscribe(          cls,          callback: Callable[[Sequence, Job], None],          params: Optional[List[Any]] = None,          sequence: Optional[Sequence] = None,      ):          if sequence is None:              sequences = cls._get_all()              for pln in sequences:                  cls.__remove_subscriber(callback, params, pln)              return          cls.__remove_subscriber(callback, params, sequence)        @classmethod      def __add_subscriber(cls, callback, params, sequence):          sequence._add_subscriber(callback, params)          Notifier.publish(_make_event(sequence, EventOperation.UPDATE, attribute_name=\"subscribers\"))        @classmethod      def __remove_subscriber(cls, callback, params, sequence):          sequence._remove_subscriber(callback, params)          Notifier.publish(_make_event(sequence, EventOperation.UPDATE, attribute_name=\"subscribers\"))        @classmethod      def _is_submittable(cls, sequence: Union[Sequence, SequenceId]) -> bool:          if isinstance(sequence, str):              sequence = cls._get(sequence)          return isinstance(sequence, Sequence) and sequence.is_ready_to_run()        @classmethod      def _submit(          cls,          sequence: Union[SequenceId, Sequence],          callbacks: Optional[List[Callable]] = None,          force: bool = False,          wait: bool = False,          timeout: Optional[Union[float, int]] = None,          check_inputs_are_ready: bool = True,      ) -> List[Job]:          sequence_id = sequence.id if isinstance(sequence, Sequence) else sequence          sequence = cls._get(sequence_id)          if sequence is None:              raise NonExistingSequence(sequence_id)          callbacks = callbacks or []          sequence_subscription_callback = cls.__get_status_notifier_callbacks(sequence) + callbacks          if check_inputs_are_ready:              _warn_if_inputs_not_ready(sequence.get_inputs())            jobs = (              _TaskManagerFactory._build_manager()              ._orchestrator()              .submit(sequence, callbacks=sequence_subscription_callback, force=force, wait=wait, timeout=timeout)          )          Notifier.publish(_make_event(sequence, EventOperation.SUBMISSION))          return jobs        @classmethod      def _exists(cls, entity_id: str) -> bool:          \"\"\"          Returns True if the entity id exists.          \"\"\"          return True if cls._get(entity_id) else False        @classmethod      def _export(cls, id: str, folder_path: Union[str, pathlib.Path]):          \"\"\"          Export a Sequence entity.          \"\"\"          if isinstance(folder_path, str):              folder: pathlib.Path = pathlib.Path(folder_path)          else:              folder = folder_path            export_dir = folder / cls._model_name          if not export_dir.exists():              export_dir.mkdir(parents=True)            export_path = export_dir / f\"{id}.json\"          sequence_name, scenario_id = cls._breakdown_sequence_id(id)          sequence = {\"id\": id, \"owner_id\": scenario_id, \"parent_ids\": [scenario_id], \"name\": sequence_name}            scenario = _ScenarioManagerFactory._build_manager()._get(scenario_id)          if sequence_data := scenario._sequences.get(sequence_name, None):              sequence.update(sequence_data)              with open(export_path, \"w\", encoding=\"utf-8\") as export_file:                  export_file.write(json.dumps(sequence))          else:              raise ModelNotFound(cls._model_name, id)        @classmethod      def __log_error_entity_not_found(cls, sequence_id: Union[SequenceId, str]):          cls._logger.error(f\"{cls._ENTITY_NAME} not found: {str(sequence_id)}\")        @staticmethod      def __get_status_notifier_callbacks(sequence: Sequence) -> List:          return [partial(c.callback, *c.params, sequence) for c in sequence.subscribers] "}
{"text": "from typing import NewType    SequenceId = NewType(\"SequenceId\", str)  SequenceId.__doc__ = \"\"\"Type that holds a `Sequence^` identifier.\"\"\" "}
{"text": "from __future__ import annotations    from typing import Any, Callable, Dict, List, Optional, Set, Union    import networkx as nx    from taipy.config.common._template_handler import _TemplateHandler as _tpl  from taipy.config.common._validate_id import _validate_id    from .._entity._entity import _Entity  from .._entity._labeled import _Labeled  from .._entity._properties import _Properties  from .._entity._reload import _Reloader, _self_reload, _self_setter  from .._entity.submittable import Submittable  from .._version._version_manager_factory import _VersionManagerFactory  from ..common._listattributes import _ListAttributes  from ..common._utils import _Subscriber  from ..data.data_node import DataNode  from ..exceptions.exceptions import NonExistingTask  from ..job.job import Job  from ..notification.event import Event, EventEntityType, EventOperation, _make_event  from ..task.task import Task  from ..task.task_id import TaskId  from .sequence_id import SequenceId      class Sequence(_Entity, Submittable, _Labeled):      \"\"\"List of `Task^`s and additional attributes representing a set of data processing      elements connected as a direct acyclic graph.        Attributes:          properties (dict[str, Any]): A dictionary of additional properties.          tasks (List[Task^]): The list of `Task`s.          sequence_id (str): The Unique identifier of the sequence.          owner_id (str):  The identifier of the owner (scenario_id, cycle_id) or None.          parent_ids (Optional[Set[str]]): The set of identifiers of the parent scenarios.          version (str): The string indicates the application version of the sequence to instantiate. If not provided,              the latest version is used.      \"\"\"        _ID_PREFIX = \"SEQUENCE\"      _SEPARATOR = \"_\"      _MANAGER_NAME = \"sequence\"        def __init__(          self,          properties: Dict[str, Any],          tasks: Union[List[TaskId], List[Task], List[Union[TaskId, Task]]],          sequence_id: SequenceId,          owner_id: Optional[str] = None,          parent_ids: Optional[Set[str]] = None,          subscribers: Optional[List[_Subscriber]] = None,          version: Optional[str] = None,      ):          super().__init__(subscribers)          self.id: SequenceId = sequence_id          self._tasks = tasks          self.owner_id = owner_id          self._parent_ids = parent_ids or set()          self._properties = _Properties(self, **properties)          self._version = version or _VersionManagerFactory._build_manager()._get_latest_version()        @staticmethod      def _new_id(sequence_name: str, scenario_id) -> SequenceId:          return SequenceId(Sequence._SEPARATOR.join([Sequence._ID_PREFIX, _validate_id(sequence_name), scenario_id]))        def __hash__(self):          return hash(self.id)        def __eq__(self, other):          return self.id == other.id        def __getattr__(self, attribute_name):          protected_attribute_name = _validate_id(attribute_name)          if protected_attribute_name in self._properties:              return _tpl._replace_templates(self._properties[protected_attribute_name])          tasks = self._get_tasks()          if protected_attribute_name in tasks:              return tasks[protected_attribute_name]          for task in tasks.values():              if protected_attribute_name in task.input:                  return task.input[protected_attribute_name]              if protected_attribute_name in task.output:                  return task.output[protected_attribute_name]          raise AttributeError(f\"{attribute_name} is not an attribute of sequence {self.id}\")        @property  # type: ignore      @_self_reload(_MANAGER_NAME)      def tasks(self) -> Dict[str, Task]:          return self._get_tasks()        @tasks.setter  # type: ignore      @_self_setter(_MANAGER_NAME)      def tasks(self, tasks: Union[List[TaskId], List[Task]]):          self._tasks = tasks        @property      def data_nodes(self) -> Dict[str, DataNode]:          data_nodes = {}          list_data_nodes = [task.data_nodes for task in self._get_tasks().values()]          for data_node in list_data_nodes:              for k, v in data_node.items():                  data_nodes[k] = v          return data_nodes        @property      def parent_ids(self):          return self._parent_ids        @property      def version(self):          return self._version        @property      def properties(self):          self._properties = _Reloader()._reload(\"sequence\", self)._properties          return self._properties        def _is_consistent(self) -> bool:          dag = self._build_dag()          if dag.number_of_nodes() == 0:              return True          if not nx.is_directed_acyclic_graph(dag):              return False          if not nx.is_weakly_connected(dag):              return False          for left_node, right_node in dag.edges:              if (isinstance(left_node, DataNode) and isinstance(right_node, Task)) or (                  isinstance(left_node, Task) and isinstance(right_node, DataNode)              ):                  continue              return False          return True        def _get_tasks(self) -> Dict[str, Task]:          from ..task._task_manager_factory import _TaskManagerFactory            tasks = {}          task_manager = _TaskManagerFactory._build_manager()          for task_or_id in self._tasks:              t = task_manager._get(task_or_id, task_or_id)              if not isinstance(t, Task):                  raise NonExistingTask(task_or_id)              tasks[t.config_id] = t          return tasks        def _get_set_of_tasks(self) -> Set[Task]:          from ..task._task_manager_factory import _TaskManagerFactory            tasks = set()          task_manager = _TaskManagerFactory._build_manager()          for task_or_id in self._tasks:              task = task_manager._get(task_or_id, task_or_id)              if not isinstance(task, Task):                  raise NonExistingTask(task_or_id)              tasks.add(task)          return tasks        @property  # type: ignore      @_self_reload(_MANAGER_NAME)      def subscribers(self):          return self._subscribers        @subscribers.setter  # type: ignore      @_self_setter(_MANAGER_NAME)      def subscribers(self, val):          self._subscribers = _ListAttributes(self, val)        def get_parents(self):          \"\"\"Get parents of the sequence entity\"\"\"          from ... import core as tp            return tp.get_parents(self)        def subscribe(          self,          callback: Callable[[Sequence, Job], None],          params: Optional[List[Any]] = None,      ):          \"\"\"Subscribe a function to be called on `Job^` status change.          The subscription is applied to all jobs created from the sequence's execution.            Parameters:              callback (Callable[[Sequence^, Job^], None]): The callable function to be called on                  status change.              params (Optional[List[Any]]): The parameters to be passed to the _callback_.          Note:              Notification will be available only for jobs created after this subscription.          \"\"\"          from ... import core as tp            return tp.subscribe_sequence(callback, params, self)        def unsubscribe(self, callback: Callable[[Sequence, Job], None], params: Optional[List[Any]] = None):          \"\"\"Unsubscribe a function that is called when the status of a `Job^` changes.            Parameters:              callback (Callable[[Sequence^, Job^], None]): The callable function to unsubscribe.              params (Optional[List[Any]]): The parameters to be passed to the _callback_.          Note:              The function will continue to be called for ongoing jobs.          \"\"\"          from ... import core as tp            return tp.unsubscribe_sequence(callback, params, self)        def submit(          self,          callbacks: Optional[List[Callable]] = None,          force: bool = False,          wait: bool = False,          timeout: Optional[Union[float, int]] = None,      ) -> List[Job]:          \"\"\"Submit the sequence for execution.            All the `Task^`s of the sequence will be submitted for execution.            Parameters:              callbacks (List[Callable]): The list of callable functions to be called on status                  change.              force (bool): Force execution even if the data nodes are in cache.              wait (bool): Wait for the orchestrated jobs created from the sequence submission to be finished                  in asynchronous mode.              timeout (Union[float, int]): The maximum number of seconds to wait for the jobs to be finished before                  returning.          Returns:              A list of created `Job^`s.          \"\"\"          from ._sequence_manager_factory import _SequenceManagerFactory            return _SequenceManagerFactory._build_manager()._submit(self, callbacks, force, wait, timeout)        def get_label(self) -> str:          \"\"\"Returns the sequence simple label prefixed by its owner label.            Returns:              The label of the sequence as a string.          \"\"\"          return self._get_label()        def get_simple_label(self) -> str:          \"\"\"Returns the sequence simple label.            Returns:              The simple label of the sequence as a string.          \"\"\"          return self._get_simple_label()      @_make_event.register(Sequence)  def _make_event_for_sequence(      sequence: Sequence,      operation: EventOperation,      /,      attribute_name: Optional[str] = None,      attribute_value: Optional[Any] = None,      **kwargs,  ) -> Event:      metadata = {**kwargs}      return Event(          entity_type=EventEntityType.SEQUENCE,          entity_id=sequence.id,          operation=operation,          attribute_name=attribute_name,          attribute_value=attribute_value,          metadata=metadata,      ) "}
{"text": "#  # Licensed under the Apache License, Version 2.0 (the \"License\"); you may not use this file except in compliance with  # the License. You may obtain a copy of the License at  #  #        http://www.apache.org/licenses/LICENSE-2.0  #  # Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on  # an \"AS IS\" BASIS, WITHOUT 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 copy import copy  from datetime import datetime, timedelta  from pydoc import locate    from .._repository._abstract_converter import _AbstractConverter  from .._version._utils import _migrate_entity  from ..common._utils import _load_fct  from ..data._data_model import _DataNodeModel  from ..data.data_node import DataNode  from . import GenericDataNode, JSONDataNode, MongoCollectionDataNode, SQLDataNode      class _DataNodeConverter(_AbstractConverter):      _READ_FCT_NAME_KEY = \"read_fct_name\"      _READ_FCT_MODULE_KEY = \"read_fct_module\"      _WRITE_FCT_NAME_KEY = \"write_fct_name\"      _WRITE_FCT_MODULE_KEY = \"write_fct_module\"      _JSON_ENCODER_NAME_KEY = \"encoder_name\"      _JSON_ENCODER_MODULE_KEY = \"encoder_module\"      _JSON_DECODER_NAME_KEY = \"decoder_name\"      _JSON_DECODER_MODULE_KEY = \"decoder_module\"      _EXPOSED_TYPE_KEY = \"exposed_type\"      __WRITE_QUERY_BUILDER_NAME_KEY = \"write_query_builder_name\"      __WRITE_QUERY_BUILDER_MODULE_KEY = \"write_query_builder_module\"      __APPEND_QUERY_BUILDER_NAME_KEY = \"append_query_builder_name\"      __APPEND_QUERY_BUILDER_MODULE_KEY = \"append_query_builder_module\"      # TODO: This limits the valid string to only the ones provided by the Converter.      # While in practice, each data nodes might have different exposed type possibilities.      # The previous implementation used tabular datanode but it's no longer suitable so      # new proposal is needed.      _VALID_STRING_EXPOSED_TYPES = [\"numpy\", \"pandas\", \"modin\"]        @classmethod      def __serialize_generic_dn_properties(cls, datanode_properties: dict):          read_fct = datanode_properties.get(GenericDataNode._OPTIONAL_READ_FUNCTION_PROPERTY, None)          datanode_properties[cls._READ_FCT_NAME_KEY] = read_fct.__name__ if read_fct else None          datanode_properties[cls._READ_FCT_MODULE_KEY] = read_fct.__module__ if read_fct else None            write_fct = datanode_properties.get(GenericDataNode._OPTIONAL_WRITE_FUNCTION_PROPERTY, None)          datanode_properties[cls._WRITE_FCT_NAME_KEY] = write_fct.__name__ if write_fct else None          datanode_properties[cls._WRITE_FCT_MODULE_KEY] = write_fct.__module__ if write_fct else None            del (              datanode_properties[GenericDataNode._OPTIONAL_READ_FUNCTION_PROPERTY],              datanode_properties[GenericDataNode._OPTIONAL_WRITE_FUNCTION_PROPERTY],          )          return datanode_properties        @classmethod      def __serialize_json_dn_properties(cls, datanode_properties: dict):          encoder = datanode_properties.get(JSONDataNode._ENCODER_KEY)          datanode_properties[cls._JSON_ENCODER_NAME_KEY] = encoder.__name__ if encoder else None          datanode_properties[cls._JSON_ENCODER_MODULE_KEY] = encoder.__module__ if encoder else None          datanode_properties.pop(JSONDataNode._ENCODER_KEY, None)            decoder = datanode_properties.get(JSONDataNode._DECODER_KEY)          datanode_properties[cls._JSON_DECODER_NAME_KEY] = decoder.__name__ if decoder else None          datanode_properties[cls._JSON_DECODER_MODULE_KEY] = decoder.__module__ if decoder else None          datanode_properties.pop(JSONDataNode._DECODER_KEY, None)            return datanode_properties        @classmethod      def __serialize_sql_dn_properties(cls, datanode_properties: dict) -> dict:          write_qb = datanode_properties.get(SQLDataNode._WRITE_QUERY_BUILDER_KEY)          datanode_properties[cls.__WRITE_QUERY_BUILDER_NAME_KEY] = write_qb.__name__ if write_qb else None          datanode_properties[cls.__WRITE_QUERY_BUILDER_MODULE_KEY] = write_qb.__module__ if write_qb else None          datanode_properties.pop(SQLDataNode._WRITE_QUERY_BUILDER_KEY, None)            append_qb = datanode_properties.get(SQLDataNode._APPEND_QUERY_BUILDER_KEY)          datanode_properties[cls.__APPEND_QUERY_BUILDER_NAME_KEY] = append_qb.__name__ if append_qb else None          datanode_properties[cls.__APPEND_QUERY_BUILDER_MODULE_KEY] = append_qb.__module__ if append_qb else None          datanode_properties.pop(SQLDataNode._APPEND_QUERY_BUILDER_KEY, None)            return datanode_properties        @classmethod      def __serialize_mongo_collection_dn_model_properties(cls, datanode_properties: dict) -> dict:          if MongoCollectionDataNode._CUSTOM_DOCUMENT_PROPERTY in datanode_properties.keys():              datanode_properties[MongoCollectionDataNode._CUSTOM_DOCUMENT_PROPERTY] = (                  f\"{datanode_properties[MongoCollectionDataNode._CUSTOM_DOCUMENT_PROPERTY].__module__}.\"                  f\"{datanode_properties[MongoCollectionDataNode._CUSTOM_DOCUMENT_PROPERTY].__qualname__}\"              )            return datanode_properties        @classmethod      def __serialize_edits(cls, edits):          new_edits = []          for edit in edits:              new_edit = edit.copy()              if timestamp := new_edit.get(\"timestamp\", None):                  new_edit[\"timestamp\"] = timestamp.isoformat()              else:                  new_edit[\"timestamp\"] = datetime.now().isoformat()              new_edits.append(new_edit)          return new_edits        @staticmethod      def __serialize_exposed_type(properties: dict, exposed_type_key: str, valid_str_exposed_types) -> dict:          if not isinstance(properties[exposed_type_key], str):              if isinstance(properties[exposed_type_key], dict):                  properties[exposed_type_key] = {                      k: v if v in valid_str_exposed_types else f\"{v.__module__}.{v.__qualname__}\"                      for k, v in properties[exposed_type_key].items()                  }              elif isinstance(properties[exposed_type_key], list):                  properties[exposed_type_key] = [                      v if v in valid_str_exposed_types else f\"{v.__module__}.{v.__qualname__}\"                      for v in properties[exposed_type_key]                  ]              else:                  properties[                      exposed_type_key                  ] = f\"{properties[exposed_type_key].__module__}.{properties[exposed_type_key].__qualname__}\"          return properties        @classmethod      def _entity_to_model(cls, data_node: DataNode) -> _DataNodeModel:          properties = data_node._properties.data.copy()          if data_node.storage_type() == GenericDataNode.storage_type():              properties = cls.__serialize_generic_dn_properties(properties)            if data_node.storage_type() == JSONDataNode.storage_type():              properties = cls.__serialize_json_dn_properties(properties)            if data_node.storage_type() == SQLDataNode.storage_type():              properties = cls.__serialize_sql_dn_properties(properties)            if data_node.storage_type() == MongoCollectionDataNode.storage_type():              properties = cls.__serialize_mongo_collection_dn_model_properties(properties)            if cls._EXPOSED_TYPE_KEY in properties.keys():              properties = cls.__serialize_exposed_type(                  properties, cls._EXPOSED_TYPE_KEY, cls._VALID_STRING_EXPOSED_TYPES              )            return _DataNodeModel(              data_node.id,              data_node.config_id,              data_node._scope,              data_node.storage_type(),              data_node.owner_id,              list(data_node._parent_ids),              data_node._last_edit_date.isoformat() if data_node._last_edit_date else None,              cls.__serialize_edits(data_node._edits),              data_node._version,              data_node._validity_period.days if data_node._validity_period else None,              data_node._validity_period.seconds if data_node._validity_period else None,              data_node._edit_in_progress,              data_node._editor_id,              data_node._editor_expiration_date.isoformat() if data_node._editor_expiration_date else None,              properties,          )        @classmethod      def __deserialize_generic_dn_properties(cls, datanode_model_properties):          if datanode_model_properties[cls._READ_FCT_MODULE_KEY]:              datanode_model_properties[GenericDataNode._OPTIONAL_READ_FUNCTION_PROPERTY] = _load_fct(                  datanode_model_properties[cls._READ_FCT_MODULE_KEY],                  datanode_model_properties[cls._READ_FCT_NAME_KEY],              )          else:              datanode_model_properties[GenericDataNode._OPTIONAL_READ_FUNCTION_PROPERTY] = None            if datanode_model_properties[cls._WRITE_FCT_MODULE_KEY]:              datanode_model_properties[GenericDataNode._OPTIONAL_WRITE_FUNCTION_PROPERTY] = _load_fct(                  datanode_model_properties[cls._WRITE_FCT_MODULE_KEY],                  datanode_model_properties[cls._WRITE_FCT_NAME_KEY],              )          else:              datanode_model_properties[GenericDataNode._OPTIONAL_WRITE_FUNCTION_PROPERTY] = None            del datanode_model_properties[cls._READ_FCT_NAME_KEY]          del datanode_model_properties[cls._READ_FCT_MODULE_KEY]          del datanode_model_properties[cls._WRITE_FCT_NAME_KEY]          del datanode_model_properties[cls._WRITE_FCT_MODULE_KEY]            return datanode_model_properties        @classmethod      def __deserialize_json_dn_properties(cls, datanode_model_properties: dict) -> dict:          if datanode_model_properties[cls._JSON_ENCODER_MODULE_KEY]:              datanode_model_properties[JSONDataNode._ENCODER_KEY] = _load_fct(                  datanode_model_properties[cls._JSON_ENCODER_MODULE_KEY],                  datanode_model_properties[cls._JSON_ENCODER_NAME_KEY],              )          else:              datanode_model_properties[JSONDataNode._ENCODER_KEY] = None            if datanode_model_properties[cls._JSON_DECODER_MODULE_KEY]:              datanode_model_properties[JSONDataNode._DECODER_KEY] = _load_fct(                  datanode_model_properties[cls._JSON_DECODER_MODULE_KEY],                  datanode_model_properties[cls._JSON_DECODER_NAME_KEY],              )          else:              datanode_model_properties[JSONDataNode._DECODER_KEY] = None            del datanode_model_properties[cls._JSON_ENCODER_NAME_KEY]          del datanode_model_properties[cls._JSON_ENCODER_MODULE_KEY]          del datanode_model_properties[cls._JSON_DECODER_NAME_KEY]          del datanode_model_properties[cls._JSON_DECODER_MODULE_KEY]            return datanode_model_properties        @classmethod      def __deserialize_sql_dn_model_properties(cls, datanode_model_properties: dict) -> dict:          if datanode_model_properties[cls.__WRITE_QUERY_BUILDER_MODULE_KEY]:              datanode_model_properties[SQLDataNode._WRITE_QUERY_BUILDER_KEY] = _load_fct(                  datanode_model_properties[cls.__WRITE_QUERY_BUILDER_MODULE_KEY],                  datanode_model_properties[cls.__WRITE_QUERY_BUILDER_NAME_KEY],              )          else:              datanode_model_properties[SQLDataNode._WRITE_QUERY_BUILDER_KEY] = None            del datanode_model_properties[cls.__WRITE_QUERY_BUILDER_NAME_KEY]          del datanode_model_properties[cls.__WRITE_QUERY_BUILDER_MODULE_KEY]            if datanode_model_properties[cls.__APPEND_QUERY_BUILDER_MODULE_KEY]:              datanode_model_properties[SQLDataNode._APPEND_QUERY_BUILDER_KEY] = _load_fct(                  datanode_model_properties[cls.__APPEND_QUERY_BUILDER_MODULE_KEY],                  datanode_model_properties[cls.__APPEND_QUERY_BUILDER_NAME_KEY],              )          else:              datanode_model_properties[SQLDataNode._APPEND_QUERY_BUILDER_KEY] = None            del datanode_model_properties[cls.__APPEND_QUERY_BUILDER_NAME_KEY]          del datanode_model_properties[cls.__APPEND_QUERY_BUILDER_MODULE_KEY]            return datanode_model_properties        @classmethod      def __deserialize_mongo_collection_dn_model_properties(cls, datanode_model_properties: dict) -> dict:          if MongoCollectionDataNode._CUSTOM_DOCUMENT_PROPERTY in datanode_model_properties.keys():              if isinstance(datanode_model_properties[MongoCollectionDataNode._CUSTOM_DOCUMENT_PROPERTY], str):                  datanode_model_properties[MongoCollectionDataNode._CUSTOM_DOCUMENT_PROPERTY] = locate(                      datanode_model_properties[MongoCollectionDataNode._CUSTOM_DOCUMENT_PROPERTY]                  )          return datanode_model_properties        @classmethod      def __deserialize_edits(cls, edits):          for edit in edits:              if timestamp := edit.get(\"timestamp\", None):                  edit[\"timestamp\"] = datetime.fromisoformat(timestamp)              else:                  edit[\"timestamp\"] = datetime.now()          return edits        @staticmethod      def __deserialize_exposed_type(properties: dict, exposed_type_key: str, valid_str_exposed_types) -> dict:          if properties[exposed_type_key] not in valid_str_exposed_types:              if isinstance(properties[exposed_type_key], str):                  properties[exposed_type_key] = locate(properties[exposed_type_key])              elif isinstance(properties[exposed_type_key], dict):                  properties[exposed_type_key] = {                      k: v if v in valid_str_exposed_types else locate(v) for k, v in properties[exposed_type_key].items()                  }              elif isinstance(properties[exposed_type_key], list):                  properties[exposed_type_key] = [                      v if v in valid_str_exposed_types else locate(v) for v in properties[exposed_type_key]                  ]          return properties        @classmethod      def _model_to_entity(cls, model: _DataNodeModel) -> DataNode:          data_node_properties = model.data_node_properties.copy()            if model.storage_type == GenericDataNode.storage_type():              data_node_properties = cls.__deserialize_generic_dn_properties(data_node_properties)            if model.storage_type == JSONDataNode.storage_type():              data_node_properties = cls.__deserialize_json_dn_properties(data_node_properties)            if model.storage_type == SQLDataNode.storage_type():              data_node_properties = cls.__deserialize_sql_dn_model_properties(data_node_properties)            if model.storage_type == MongoCollectionDataNode.storage_type():              data_node_properties = cls.__deserialize_mongo_collection_dn_model_properties(data_node_properties)            if cls._EXPOSED_TYPE_KEY in data_node_properties.keys():              data_node_properties = cls.__deserialize_exposed_type(                  data_node_properties, cls._EXPOSED_TYPE_KEY, cls._VALID_STRING_EXPOSED_TYPES              )            validity_period = None          if model.validity_seconds is not None and model.validity_days is not None:              validity_period = timedelta(days=model.validity_days, seconds=model.validity_seconds)            exp_date = datetime.fromisoformat(model.editor_expiration_date) if model.editor_expiration_date else None          datanode = DataNode._class_map()[model.storage_type](              config_id=model.config_id,              scope=model.scope,              id=model.id,              owner_id=model.owner_id,              parent_ids=set(model.parent_ids),              last_edit_date=datetime.fromisoformat(model.last_edit_date) if model.last_edit_date else None,              edits=cls.__deserialize_edits(copy(model.edits)),              version=model.version,              validity_period=validity_period,              edit_in_progress=model.edit_in_progress,              editor_id=model.editor_id,              editor_expiration_date=exp_date,              properties=data_node_properties,          )          return _migrate_entity(datanode) "}
{"text": "import os  import re  import urllib.parse  from abc import abstractmethod  from datetime import datetime, timedelta  from typing import Dict, List, Optional, Set, Tuple, Union    import modin.pandas as modin_pd  import numpy as np  import pandas as pd  from sqlalchemy import create_engine, text    from taipy.config.common.scope import Scope    from .._version._version_manager_factory import _VersionManagerFactory  from ..data.operator import JoinOperator, Operator  from ..exceptions.exceptions import MissingRequiredProperty, UnknownDatabaseEngine  from ._abstract_tabular import _AbstractTabularDataNode  from .data_node import DataNode  from .data_node_id import DataNodeId, Edit      class _AbstractSQLDataNode(DataNode, _AbstractTabularDataNode):      \"\"\"Abstract base class for data node implementations (SQLDataNode and SQLTableDataNode) that use SQL.\"\"\"        __STORAGE_TYPE = \"NOT_IMPLEMENTED\"        __EXPOSED_TYPE_PROPERTY = \"exposed_type\"      __EXPOSED_TYPE_NUMPY = \"numpy\"      __EXPOSED_TYPE_PANDAS = \"pandas\"      __EXPOSED_TYPE_MODIN = \"modin\"      __VALID_STRING_EXPOSED_TYPES = [__EXPOSED_TYPE_PANDAS, __EXPOSED_TYPE_NUMPY, __EXPOSED_TYPE_MODIN]        __DB_NAME_KEY = \"db_name\"      __DB_USERNAME_KEY = \"db_username\"      __DB_PASSWORD_KEY = \"db_password\"      __DB_HOST_KEY = \"db_host\"      __DB_PORT_KEY = \"db_port\"      __DB_ENGINE_KEY = \"db_engine\"      __DB_DRIVER_KEY = \"db_driver\"      __DB_EXTRA_ARGS_KEY = \"db_extra_args\"      __SQLITE_FOLDER_PATH = \"sqlite_folder_path\"      __SQLITE_FILE_EXTENSION = \"sqlite_file_extension\"        __ENGINE_PROPERTIES: List[str] = [          __DB_NAME_KEY,          __DB_USERNAME_KEY,          __DB_PASSWORD_KEY,          __DB_HOST_KEY,          __DB_PORT_KEY,          __DB_DRIVER_KEY,          __DB_EXTRA_ARGS_KEY,          __SQLITE_FOLDER_PATH,          __SQLITE_FILE_EXTENSION,      ]        __DB_HOST_DEFAULT = \"localhost\"      __DB_PORT_DEFAULT = 1433      __DB_DRIVER_DEFAULT = \"\"      __SQLITE_FOLDER_PATH_DEFAULT = \"\"      __SQLITE_FILE_EXTENSION_DEFAULT = \".db\"        __ENGINE_MSSQL = \"mssql\"      __ENGINE_SQLITE = \"sqlite\"      __ENGINE_MYSQL = \"mysql\"      __ENGINE_POSTGRESQL = \"postgresql\"        _ENGINE_REQUIRED_PROPERTIES: Dict[str, List[str]] = {          __ENGINE_MSSQL: [__DB_USERNAME_KEY, __DB_PASSWORD_KEY, __DB_NAME_KEY],          __ENGINE_MYSQL: [__DB_USERNAME_KEY, __DB_PASSWORD_KEY, __DB_NAME_KEY],          __ENGINE_POSTGRESQL: [__DB_USERNAME_KEY, __DB_PASSWORD_KEY, __DB_NAME_KEY],          __ENGINE_SQLITE: [__DB_NAME_KEY],      }        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: Optional[List[Edit]] = None,          version: Optional[str] = None,          validity_period: Optional[timedelta] = None,          edit_in_progress: bool = False,          editor_id: Optional[str] = None,          editor_expiration_date: Optional[datetime] = None,          properties: Optional[Dict] = None,      ):          if properties is None:              properties = {}          self._check_required_properties(properties)            if self.__EXPOSED_TYPE_PROPERTY not in properties.keys():              properties[self.__EXPOSED_TYPE_PROPERTY] = self.__EXPOSED_TYPE_PANDAS          self._check_exposed_type(properties[self.__EXPOSED_TYPE_PROPERTY], self.__VALID_STRING_EXPOSED_TYPES)            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,          )          self._engine = None          if not self._last_edit_date:              self._last_edit_date = datetime.now()            self._TAIPY_PROPERTIES.update(              {                  self.__DB_NAME_KEY,                  self.__DB_USERNAME_KEY,                  self.__DB_PASSWORD_KEY,                  self.__DB_HOST_KEY,                  self.__DB_PORT_KEY,                  self.__DB_ENGINE_KEY,                  self.__DB_DRIVER_KEY,                  self.__DB_EXTRA_ARGS_KEY,                  self.__SQLITE_FOLDER_PATH,                  self.__SQLITE_FILE_EXTENSION,                  self.__EXPOSED_TYPE_PROPERTY,              }          )        def _check_required_properties(self, properties: Dict):          db_engine = properties.get(self.__DB_ENGINE_KEY)          if not db_engine:              raise MissingRequiredProperty(f\"{self.__DB_ENGINE_KEY} is required.\")          if db_engine not in self._ENGINE_REQUIRED_PROPERTIES.keys():              raise UnknownDatabaseEngine(f\"Unknown engine: {db_engine}\")          required = self._ENGINE_REQUIRED_PROPERTIES[db_engine]            if missing := set(required) - set(properties.keys()):              raise MissingRequiredProperty(                  f\"The following properties \" f\"{', '.join(x for x in missing)} were not informed and are required.\"              )        def _get_engine(self):          if self._engine is None:              self._engine = create_engine(self._conn_string())          return self._engine        def _conn_string(self) -> str:          engine = self.properties.get(self.__DB_ENGINE_KEY)            if self.__DB_USERNAME_KEY in self._ENGINE_REQUIRED_PROPERTIES[engine]:              username = self.properties.get(self.__DB_USERNAME_KEY)              username = urllib.parse.quote_plus(username)            if self.__DB_PASSWORD_KEY in self._ENGINE_REQUIRED_PROPERTIES[engine]:              password = self.properties.get(self.__DB_PASSWORD_KEY)              password = urllib.parse.quote_plus(password)            if self.__DB_NAME_KEY in self._ENGINE_REQUIRED_PROPERTIES[engine]:              db_name = self.properties.get(self.__DB_NAME_KEY)              db_name = urllib.parse.quote_plus(db_name)            host = self.properties.get(self.__DB_HOST_KEY, self.__DB_HOST_DEFAULT)          port = self.properties.get(self.__DB_PORT_KEY, self.__DB_PORT_DEFAULT)          driver = self.properties.get(self.__DB_DRIVER_KEY, self.__DB_DRIVER_DEFAULT)          extra_args = self.properties.get(self.__DB_EXTRA_ARGS_KEY, {})            if driver:              extra_args = {**extra_args, \"driver\": driver}          for k, v in extra_args.items():              extra_args[k] = re.sub(r\"\\s+\", \"+\", v)          extra_args_str = \"&\".join(f\"{k}={str(v)}\" for k, v in extra_args.items())            if engine == self.__ENGINE_MSSQL:              return f\"mssql+pyodbc://{username}:{password}@{host}:{port}/{db_name}?{extra_args_str}\"          elif engine == self.__ENGINE_MYSQL:              return f\"mysql+pymysql://{username}:{password}@{host}:{port}/{db_name}?{extra_args_str}\"          elif engine == self.__ENGINE_POSTGRESQL:              return f\"postgresql+psycopg2://{username}:{password}@{host}:{port}/{db_name}?{extra_args_str}\"          elif engine == self.__ENGINE_SQLITE:              folder_path = self.properties.get(self.__SQLITE_FOLDER_PATH, self.__SQLITE_FOLDER_PATH_DEFAULT)              file_extension = self.properties.get(self.__SQLITE_FILE_EXTENSION, self.__SQLITE_FILE_EXTENSION_DEFAULT)              return \"sqlite:///\" + os.path.join(folder_path, f\"{db_name}{file_extension}\")            raise UnknownDatabaseEngine(f\"Unknown engine: {engine}\")        def filter(self, operators: Optional[Union[List, Tuple]] = None, join_operator=JoinOperator.AND):          if self.properties[self.__EXPOSED_TYPE_PROPERTY] == self.__EXPOSED_TYPE_PANDAS:              return self._read_as_pandas_dataframe(operators=operators, join_operator=join_operator)          if self.properties[self.__EXPOSED_TYPE_PROPERTY] == self.__EXPOSED_TYPE_MODIN:              return self._read_as_modin_dataframe(operators=operators, join_operator=join_operator)          if self.properties[self.__EXPOSED_TYPE_PROPERTY] == self.__EXPOSED_TYPE_NUMPY:              return self._read_as_numpy(operators=operators, join_operator=join_operator)          return self._read_as(operators=operators, join_operator=join_operator)        def _read(self):          if self.properties[self.__EXPOSED_TYPE_PROPERTY] == self.__EXPOSED_TYPE_PANDAS:              return self._read_as_pandas_dataframe()          if self.properties[self.__EXPOSED_TYPE_PROPERTY] == self.__EXPOSED_TYPE_MODIN:              return self._read_as_modin_dataframe()          if self.properties[self.__EXPOSED_TYPE_PROPERTY] == self.__EXPOSED_TYPE_NUMPY:              return self._read_as_numpy()          return self._read_as()        def _read_as(self, operators: Optional[Union[List, Tuple]] = None, join_operator=JoinOperator.AND):          custom_class = self.properties[self.__EXPOSED_TYPE_PROPERTY]          with self._get_engine().connect() as connection:              query_result = connection.execute(text(self._get_read_query(operators, join_operator)))          return list(map(lambda row: custom_class(**row), query_result))        def _read_as_numpy(          self, operators: Optional[Union[List, Tuple]] = None, join_operator=JoinOperator.AND      ) -> np.ndarray:          return self._read_as_pandas_dataframe(operators=operators, join_operator=join_operator).to_numpy()        def _read_as_pandas_dataframe(          self,          columns: Optional[List[str]] = None,          operators: Optional[Union[List, Tuple]] = None,          join_operator=JoinOperator.AND,      ):          with self._get_engine().connect() as conn:              if columns:                  return pd.DataFrame(conn.execute(text(self._get_read_query(operators, join_operator))))[columns]              return pd.DataFrame(conn.execute(text(self._get_read_query(operators, join_operator))))        def _read_as_modin_dataframe(          self,          columns: Optional[List[str]] = None,          operators: Optional[Union[List, Tuple]] = None,          join_operator=JoinOperator.AND,      ):          if columns:              return modin_pd.read_sql_query(self._get_read_query(operators, join_operator), con=self._get_engine())[                  columns              ]          return modin_pd.read_sql_query(self._get_read_query(operators, join_operator), con=self._get_engine())        @abstractmethod      def _get_read_query(self, operators: Optional[Union[List, Tuple]] = None, join_operator=JoinOperator.AND):          query = self._get_base_read_query()            if not operators:              return query            if not isinstance(operators, List):              operators = [operators]            conditions = []          for key, value, operator in operators:              if operator == Operator.EQUAL:                  conditions.append(f\"{key} = '{value}'\")              elif operator == Operator.NOT_EQUAL:                  conditions.append(f\"{key} <> '{value}'\")              elif operator == Operator.GREATER_THAN:                  conditions.append(f\"{key} > '{value}'\")              elif operator == Operator.GREATER_OR_EQUAL:                  conditions.append(f\"{key} >= '{value}'\")              elif operator == Operator.LESS_THAN:                  conditions.append(f\"{key} < '{value}'\")              elif operator == Operator.LESS_OR_EQUAL:                  conditions.append(f\"{key} <= '{value}'\")            if join_operator == JoinOperator.AND:              query += f\" WHERE {' AND '.join(conditions)}\"          elif join_operator == JoinOperator.OR:              query += f\" WHERE {' OR '.join(conditions)}\"          else:              raise NotImplementedError(f\"Join operator {join_operator} not implemented.\")            return query        @abstractmethod      def _get_base_read_query(self) -> str:          raise NotImplementedError        def _append(self, data) -> None:          engine = self._get_engine()          with engine.connect() as connection:              with connection.begin() as transaction:                  try:                      self._do_append(data, engine, connection)                  except Exception as e:                      transaction.rollback()                      raise e                  else:                      transaction.commit()        @abstractmethod      def _do_append(self, data, engine, connection) -> None:          raise NotImplementedError        def _write(self, data) -> None:          \"\"\"Check data against a collection of types to handle insertion on the database.\"\"\"          engine = self._get_engine()          with engine.connect() as connection:              with connection.begin() as transaction:                  try:                      self._do_write(data, engine, connection)                  except Exception as e:                      transaction.rollback()                      raise e                  else:                      transaction.commit()        @abstractmethod      def _do_write(self, data, engine, connection) -> None:          raise NotImplementedError        def __setattr__(self, key: str, value) -> None:          if key in self.__ENGINE_PROPERTIES:              self._engine = None          return super().__setattr__(key, value) "}
{"text": "import os  from datetime import datetime, timedelta  from os.path import isdir, isfile  from typing import Any, Dict, List, Optional, Set    import modin.pandas as modin_pd  import numpy as np  import pandas as pd    from taipy.config.common.scope import Scope    from .._backup._backup import _replace_in_backup_file  from .._entity._reload import _self_reload  from .._version._version_manager_factory import _VersionManagerFactory  from ..exceptions.exceptions import UnknownCompressionAlgorithm, UnknownParquetEngine  from ..job.job_id import JobId  from ._abstract_file import _AbstractFileDataNode  from ._abstract_tabular import _AbstractTabularDataNode  from .data_node import DataNode  from .data_node_id import DataNodeId, Edit      class ParquetDataNode(DataNode, _AbstractFileDataNode, _AbstractTabularDataNode):      \"\"\"Data Node stored as a Parquet file.        Attributes:          config_id (str): Identifier of the data node configuration. This string 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.          path (str): The path to the Parquet file.          properties (dict[str, Any]): A dictionary of additional properties. *properties*              must have a *\"default_path\"* or *\"path\"* entry with the path of the Parquet file:                - *\"default_path\"* (`str`): The default path of the Parquet file.              - *\"exposed_type\"*: The exposed type of the data read from Parquet file. The default                  value is `pandas`.              - *\"engine\"* (`Optional[str]`): Parquet library to use. Possible values are                  *\"fastparquet\"* or *\"pyarrow\"*.<br/>                  The default value is *\"pyarrow\"*.              - *\"compression\"* (`Optional[str]`): Name of the compression to use. Possible values                  are *\"snappy\"*, *\"gzip\"*, *\"brotli\"*, or *\"none\"* (no compression).<br/>                  The default value is *\"snappy\"*.              - *\"read_kwargs\"* (`Optional[dict]`): Additional parameters passed to the                  *pandas.read_parquet()* function.              - *\"write_kwargs\"* (`Optional[dict]`): Additional parameters passed to the                  *pandas.DataFrame.write_parquet()* fucntion.                  The parameters in *\"read_kwargs\"* and *\"write_kwargs\"* have a                  **higher precedence** than the top-level parameters which are also passed to                  Pandas.      \"\"\"        __STORAGE_TYPE = \"parquet\"      __EXPOSED_TYPE_PROPERTY = \"exposed_type\"      __EXPOSED_TYPE_NUMPY = \"numpy\"      __EXPOSED_TYPE_PANDAS = \"pandas\"      __EXPOSED_TYPE_MODIN = \"modin\"      __VALID_STRING_EXPOSED_TYPES = [__EXPOSED_TYPE_PANDAS, __EXPOSED_TYPE_MODIN, __EXPOSED_TYPE_NUMPY]      __PATH_KEY = \"path\"      __DEFAULT_DATA_KEY = \"default_data\"      __DEFAULT_PATH_KEY = \"default_path\"      __ENGINE_PROPERTY = \"engine\"      __VALID_PARQUET_ENGINES = [\"pyarrow\", \"fastparquet\"]      __COMPRESSION_PROPERTY = \"compression\"      __VALID_COMPRESSION_ALGORITHMS = [\"snappy\", \"gzip\", \"brotli\", \"none\"]      __READ_KWARGS_PROPERTY = \"read_kwargs\"      __WRITE_KWARGS_PROPERTY = \"write_kwargs\"      _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: Optional[List[Edit]] = None,          version: Optional[str] = None,          validity_period: Optional[timedelta] = None,          edit_in_progress: bool = False,          editor_id: Optional[str] = None,          editor_expiration_date: Optional[datetime] = None,          properties: Optional[Dict] = None,      ):          if properties is None:              properties = {}            default_value = properties.pop(self.__DEFAULT_DATA_KEY, None)            if self.__ENGINE_PROPERTY not in properties.keys():              properties[self.__ENGINE_PROPERTY] = \"pyarrow\"          if properties[self.__ENGINE_PROPERTY] not in self.__VALID_PARQUET_ENGINES:              raise UnknownParquetEngine(                  f\"Invalid parquet engine: {properties[self.__ENGINE_PROPERTY]}. \"                  f\"Supported engines are {', '.join(self.__VALID_PARQUET_ENGINES)}\"              )            if self.__COMPRESSION_PROPERTY not in properties.keys():              properties[self.__COMPRESSION_PROPERTY] = \"snappy\"          if properties[self.__COMPRESSION_PROPERTY] == \"none\":              properties[self.__COMPRESSION_PROPERTY] = None          if (              properties[self.__COMPRESSION_PROPERTY]              and properties[self.__COMPRESSION_PROPERTY] not in self.__VALID_COMPRESSION_ALGORITHMS          ):              raise UnknownCompressionAlgorithm(                  f\"Unsupported compression algorithm: {properties[self.__COMPRESSION_PROPERTY]}. \"                  f\"Supported algorithms are {', '.join(self.__VALID_COMPRESSION_ALGORITHMS)}\"              )            if self.__READ_KWARGS_PROPERTY not in properties.keys():              properties[self.__READ_KWARGS_PROPERTY] = {}            if self.__WRITE_KWARGS_PROPERTY not in properties.keys():              properties[self.__WRITE_KWARGS_PROPERTY] = {}            if self.__EXPOSED_TYPE_PROPERTY not in properties.keys():              properties[self.__EXPOSED_TYPE_PROPERTY] = self.__EXPOSED_TYPE_PANDAS          self._check_exposed_type(properties[self.__EXPOSED_TYPE_PROPERTY], self.__VALID_STRING_EXPOSED_TYPES)            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,          )          self._path = properties.get(self.__PATH_KEY, properties.get(self.__DEFAULT_PATH_KEY))          if not self._path:              self._path = self._build_path(self.storage_type())          properties[self.__PATH_KEY] = self._path            if default_value is not None and not os.path.exists(self._path):              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.\",                      }                  )              )            if not self._last_edit_date and (isfile(self._path) or isdir(self._path)):              self._last_edit_date = datetime.now()            self._TAIPY_PROPERTIES.update(              {                  self.__EXPOSED_TYPE_PROPERTY,                  self.__PATH_KEY,                  self.__DEFAULT_PATH_KEY,                  self.__DEFAULT_DATA_KEY,                  self.__ENGINE_PROPERTY,                  self.__COMPRESSION_PROPERTY,                  self.__READ_KWARGS_PROPERTY,                  self.__WRITE_KWARGS_PROPERTY,              }          )        @classmethod      def storage_type(cls) -> str:          return cls.__STORAGE_TYPE        @property  # type: ignore      @_self_reload(DataNode._MANAGER_NAME)      def path(self):          return self._path        @path.setter      def path(self, value):          tmp_old_path = self._path          self._path = value          self.properties[self.__PATH_KEY] = value          _replace_in_backup_file(old_file_path=tmp_old_path, new_file_path=self._path)        def _read(self):          return self.read_with_kwargs()        def _read_as(self, read_kwargs: Dict):          custom_class = self.properties[self.__EXPOSED_TYPE_PROPERTY]          list_of_dicts = self._read_as_pandas_dataframe(read_kwargs).to_dict(orient=\"records\")          return [custom_class(**dct) for dct in list_of_dicts]        def _read_as_numpy(self, read_kwargs: Dict) -> np.ndarray:          return self._read_as_pandas_dataframe(read_kwargs).to_numpy()        def _read_as_pandas_dataframe(self, read_kwargs: Dict) -> pd.DataFrame:          return pd.read_parquet(self._path, **read_kwargs)        def _read_as_modin_dataframe(self, read_kwargs: Dict) -> modin_pd.DataFrame:          return modin_pd.read_parquet(self._path, **read_kwargs)        def _append(self, data: Any):          self.write_with_kwargs(data, engine=\"fastparquet\", append=True)        def _write(self, data: Any):          self.write_with_kwargs(data)        def write_with_kwargs(self, data: Any, job_id: Optional[JobId] = None, **write_kwargs):          \"\"\"Write the data referenced by this data node.            Keyword arguments here which are also present in the Data Node config will overwrite them.            Parameters:              data (Any): The data to write.              job_id (JobId^): An optional identifier of the writer.              **write_kwargs (dict[str, any]): The keyword arguments passed to the function                  `pandas.DataFrame.to_parquet()`.          \"\"\"          kwargs = {              self.__ENGINE_PROPERTY: self.properties[self.__ENGINE_PROPERTY],              self.__COMPRESSION_PROPERTY: self.properties[self.__COMPRESSION_PROPERTY],          }          kwargs.update(self.properties[self.__WRITE_KWARGS_PROPERTY])          kwargs.update(write_kwargs)          if isinstance(data, (pd.DataFrame, modin_pd.DataFrame)):              data.to_parquet(self._path, **kwargs)          else:              pd.DataFrame(data).to_parquet(self._path, **kwargs)          self.track_edit(timestamp=datetime.now(), job_id=job_id)        def read_with_kwargs(self, **read_kwargs):          \"\"\"Read data from this data node.            Keyword arguments here which are also present in the Data Node config will overwrite them.            Parameters:              **read_kwargs (dict[str, any]): The keyword arguments passed to the function                  `pandas.read_parquet()`.          \"\"\"          # return None if data was never written          if not self.last_edit_date:              self._DataNode__logger.warning(                  f\"Data node {self.id} from config {self.config_id} is being read but has never been written.\"              )              return None            kwargs = self.properties[self.__READ_KWARGS_PROPERTY]          kwargs.update(              {                  self.__ENGINE_PROPERTY: self.properties[self.__ENGINE_PROPERTY],              }          )          kwargs.update(read_kwargs)            if self.properties[self.__EXPOSED_TYPE_PROPERTY] == self.__EXPOSED_TYPE_PANDAS:              return self._read_as_pandas_dataframe(kwargs)          if self.properties[self.__EXPOSED_TYPE_PROPERTY] == self.__EXPOSED_TYPE_MODIN:              return self._read_as_modin_dataframe(kwargs)          if self.properties[self.__EXPOSED_TYPE_PROPERTY] == self.__EXPOSED_TYPE_NUMPY:              return self._read_as_numpy(kwargs)          return self._read_as(kwargs) "}
{"text": "from datetime import datetime, timedelta  from inspect import isclass  from typing import Any, Dict, List, Optional, Set, Tuple, Union    from taipy.config.common.scope import Scope    from .._version._version_manager_factory import _VersionManagerFactory  from ..common._mongo_connector import _connect_mongodb  from ..data.operator import JoinOperator, Operator  from ..exceptions.exceptions import InvalidCustomDocument, MissingRequiredProperty  from .data_node import DataNode  from .data_node_id import DataNodeId, Edit      class MongoCollectionDataNode(DataNode):      \"\"\"Data Node stored in a Mongo collection.        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. Note that the              _properties_ parameter must at least contain an entry for _\"db_name\"_ and _\"collection_name\"_:                - _\"db_name\"_ `(str)`: The database name.\\n              - _\"collection_name\"_ `(str)`: The collection in the database to read from and to write the data to.\\n              - _\"custom_document\"_ `(Any)`: The custom document class to store, encode, and decode data when reading and                  writing to a Mongo collection.\\n              - _\"db_username\"_ `(str)`: The database username.\\n              - _\"db_password\"_ `(str)`: The database password.\\n              - _\"db_host\"_ `(str)`: The database host. The default value is _\"localhost\"_.\\n              - _\"db_port\"_ `(int)`: The database port. The default value is 27017.\\n              - _\"db_driver\"_ `(str)`: The database driver.\\n              - _\"db_extra_args\"_ `(Dict[str, Any])`: A dictionary of additional arguments to be passed into database                  connection string.\\n      \"\"\"        __STORAGE_TYPE = \"mongo_collection\"        __DB_NAME_KEY = \"db_name\"      __COLLECTION_KEY = \"collection_name\"      __DB_USERNAME_KEY = \"db_username\"      __DB_PASSWORD_KEY = \"db_password\"      __DB_HOST_KEY = \"db_host\"      __DB_PORT_KEY = \"db_port\"      __DB_EXTRA_ARGS_KEY = \"db_extra_args\"      __DB_DRIVER_KEY = \"db_driver\"        __DB_HOST_DEFAULT = \"localhost\"      __DB_PORT_DEFAULT = 27017        _CUSTOM_DOCUMENT_PROPERTY = \"custom_document\"      _REQUIRED_PROPERTIES: List[str] = [          __DB_NAME_KEY,          __COLLECTION_KEY,      ]        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: Dict = None,      ):          if properties is None:              properties = {}          required = self._REQUIRED_PROPERTIES          if missing := set(required) - set(properties.keys()):              raise MissingRequiredProperty(                  f\"The following properties \" f\"{', '.join(x for x in missing)} were not informed and are required.\"              )            self._check_custom_document(properties[self._CUSTOM_DOCUMENT_PROPERTY])            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,          )            mongo_client = _connect_mongodb(              db_host=properties.get(self.__DB_HOST_KEY, self.__DB_HOST_DEFAULT),              db_port=properties.get(self.__DB_PORT_KEY, self.__DB_PORT_DEFAULT),              db_username=properties.get(self.__DB_USERNAME_KEY, \"\"),              db_password=properties.get(self.__DB_PASSWORD_KEY, \"\"),              db_driver=properties.get(self.__DB_DRIVER_KEY, \"\"),              db_extra_args=frozenset(properties.get(self.__DB_EXTRA_ARGS_KEY, {}).items()),          )          self.collection = mongo_client[properties.get(self.__DB_NAME_KEY, \"\")][              properties.get(self.__COLLECTION_KEY, \"\")          ]            self.custom_document = properties[self._CUSTOM_DOCUMENT_PROPERTY]            self._decoder = self._default_decoder          custom_decoder = getattr(self.custom_document, \"decode\", None)          if callable(custom_decoder):              self._decoder = custom_decoder            self._encoder = self._default_encoder          custom_encoder = getattr(self.custom_document, \"encode\", None)          if callable(custom_encoder):              self._encoder = custom_encoder            if not self._last_edit_date:              self._last_edit_date = datetime.now()            self._TAIPY_PROPERTIES.update(              {                  self.__COLLECTION_KEY,                  self.__DB_NAME_KEY,                  self._CUSTOM_DOCUMENT_PROPERTY,                  self.__DB_USERNAME_KEY,                  self.__DB_PASSWORD_KEY,                  self.__DB_HOST_KEY,                  self.__DB_PORT_KEY,                  self.__DB_DRIVER_KEY,                  self.__DB_EXTRA_ARGS_KEY,              }          )        def _check_custom_document(self, custom_document):          if not isclass(custom_document):              raise InvalidCustomDocument(                  f\"Invalid custom document of {custom_document}. Only custom class are supported.\"              )        @classmethod      def storage_type(cls) -> str:          return cls.__STORAGE_TYPE        def filter(self, operators: Optional[Union[List, Tuple]] = None, join_operator=JoinOperator.AND):          cursor = self._read_by_query(operators, join_operator)          return list(map(lambda row: self._decoder(row), cursor))        def _read(self):          cursor = self._read_by_query()          return list(map(lambda row: self._decoder(row), cursor))        def _read_by_query(self, operators: Optional[Union[List, Tuple]] = None, join_operator=JoinOperator.AND):          \"\"\"Query from a Mongo collection, exclude the _id field\"\"\"          if not operators:              return self.collection.find()            if not isinstance(operators, List):              operators = [operators]            conditions = []          for key, value, operator in operators:              if operator == Operator.EQUAL:                  conditions.append({key: value})              elif operator == Operator.NOT_EQUAL:                  conditions.append({key: {\"$ne\": value}})              elif operator == Operator.GREATER_THAN:                  conditions.append({key: {\"$gt\": value}})              elif operator == Operator.GREATER_OR_EQUAL:                  conditions.append({key: {\"$gte\": value}})              elif operator == Operator.LESS_THAN:                  conditions.append({key: {\"$lt\": value}})              elif operator == Operator.LESS_OR_EQUAL:                  conditions.append({key: {\"$lte\": value}})            query = {}          if join_operator == JoinOperator.AND:              query = {\"$and\": conditions}          elif join_operator == JoinOperator.OR:              query = {\"$or\": conditions}          else:              raise NotImplementedError(f\"Join operator {join_operator} is not supported.\")            return self.collection.find(query)        def _append(self, data) -> None:          \"\"\"Append data to a Mongo collection.\"\"\"          if not isinstance(data, list):              data = [data]            if len(data) == 0:              return            if isinstance(data[0], dict):              self._insert_dicts(data)          else:              self._insert_dicts([self._encoder(row) for row in data])        def _write(self, data) -> None:          \"\"\"Check data against a collection of types to handle insertion on the database.            Parameters:              data (Any): the data to write to the database.          \"\"\"          if not isinstance(data, list):              data = [data]            if len(data) == 0:              self.collection.drop()              return            if isinstance(data[0], dict):              self._insert_dicts(data, drop=True)          else:              self._insert_dicts([self._encoder(row) for row in data], drop=True)        def _insert_dicts(self, data: List[Dict], drop=False) -> None:          \"\"\"          This method will insert data contained in a list of dictionaries into a collection.            Parameters:              data (List[Dict]): a list of dictionaries              drop (bool): drop the collection before inserting the data to overwrite the data in the collection.          \"\"\"          if drop:              self.collection.drop()            self.collection.insert_many(data)        def _default_decoder(self, document: Dict) -> Any:          \"\"\"Decode a Mongo dictionary to a custom document object for reading.            Parameters:              document (Dict): the document dictionary return by Mongo query.          Returns:              A custom document object.          \"\"\"          return self.custom_document(**document)        def _default_encoder(self, document_object: Any) -> Dict:          \"\"\"Encode a custom document object to a dictionary for writing to MongoDB.            Args:              document_object: the custom document class.            Returns:              The document dictionary.          \"\"\"          return document_object.__dict__ "}
{"text": "from collections.abc import Hashable  from functools import reduce  from itertools import chain  from operator import and_, or_  from typing import Dict, Iterable, List, Tuple, Union    import modin.pandas as modin_pd  import numpy as np  import pandas as pd  from pandas.core.common import is_bool_indexer    from .operator import JoinOperator, Operator      class _FilterDataNode:      @staticmethod      def __is_pandas_object(data) -> bool:          return isinstance(data, (pd.DataFrame, modin_pd.DataFrame)) or isinstance(data, (pd.Series, modin_pd.DataFrame))        @staticmethod      def __is_multi_sheet_excel(data) -> bool:          if isinstance(data, Dict):              has_df_children = all([isinstance(e, (pd.DataFrame, modin_pd.DataFrame)) for e in data.values()])              has_list_children = all([isinstance(e, List) for e in data.values()])              has_np_array_children = all([isinstance(e, np.ndarray) for e in data.values()])              return has_df_children or has_list_children or has_np_array_children          return False        @staticmethod      def __is_list_of_dict(data) -> bool:          return all(isinstance(x, Dict) for x in data)        @staticmethod      def _filter_by_key(data, key):          if isinstance(key, int):              return _FilterDataNode.__getitem_int(data, key)            if isinstance(key, slice) or (isinstance(key, tuple) and any(isinstance(e, slice) for e in key)):              return _FilterDataNode.__getitem_slice(data, key)            if isinstance(key, Hashable):              return _FilterDataNode.__getitem_hashable(data, key)            if isinstance(key, (pd.DataFrame, modin_pd.DataFrame)):              return _FilterDataNode.__getitem_dataframe(data, key)            if is_bool_indexer(key):              return _FilterDataNode.__getitem_bool_indexer(data, key)            if isinstance(key, Iterable):              return _FilterDataNode.__getitem_iterable(data, key)            return None        @staticmethod      def __getitem_int(data, key):          return data[key]        @staticmethod      def __getitem_hashable(data, key):          if _FilterDataNode.__is_pandas_object(data) or _FilterDataNode.__is_multi_sheet_excel(data):              return data.get(key)          return [getattr(entry, key, None) for entry in data]        @staticmethod      def __getitem_slice(data, key):          return data[key]        @staticmethod      def __getitem_dataframe(data, key: Union[pd.DataFrame, modin_pd.DataFrame]):          if _FilterDataNode.__is_pandas_object(data):              return data[key]          if _FilterDataNode.__is_list_of_dict(data):              filtered_data = list()              for i, row in key.iterrows():                  filtered_row = dict()                  for col in row.index:                      filtered_row[col] = data[i][col] if row[col] else None                  filtered_data.append(filtered_row)              return filtered_data          return None        @staticmethod      def __getitem_bool_indexer(data, key):          if _FilterDataNode.__is_pandas_object(data):              return data[key]          return [e for i, e in enumerate(data) if key[i]]        @staticmethod      def __getitem_iterable(data, keys):          if _FilterDataNode.__is_pandas_object(data):              return data[keys]          filtered_data = []          for entry in data:              filtered_data.append({k: getattr(entry, k) for k in keys if hasattr(entry, k)})          return filtered_data        @staticmethod      def _filter(data, operators: Union[List, Tuple], join_operator=JoinOperator.AND):          if len(operators) == 0:              return data            if isinstance(data, Dict):              return {k: _FilterDataNode._filter(v, operators, join_operator) for k, v in data.items()}            if not ((isinstance(operators[0], list)) or (isinstance(operators[0], tuple))):              if isinstance(data, (pd.DataFrame, modin_pd.DataFrame)):                  return _FilterDataNode.__filter_dataframe_per_key_value(data, operators[0], operators[1], operators[2])              if isinstance(data, np.ndarray):                  list_operators = [operators]                  return _FilterDataNode.__filter_numpy_array(data, list_operators)              if isinstance(data, List):                  return _FilterDataNode.__filter_list_per_key_value(data, operators[0], operators[1], operators[2])          else:              if isinstance(data, (pd.DataFrame, modin_pd.DataFrame)):                  return _FilterDataNode.__filter_dataframe(data, operators, join_operator=join_operator)              if isinstance(data, np.ndarray):                  return _FilterDataNode.__filter_numpy_array(data, operators, join_operator=join_operator)              if isinstance(data, List):                  return _FilterDataNode.__filter_list(data, operators, join_operator=join_operator)          raise NotImplementedError        @staticmethod      def __filter_dataframe(          df_data: Union[pd.DataFrame, modin_pd.DataFrame], operators: Union[List, Tuple], join_operator=JoinOperator.AND      ):          filtered_df_data = []          if join_operator == JoinOperator.AND:              how = \"inner\"          elif join_operator == JoinOperator.OR:              how = \"outer\"          else:              return NotImplementedError          for key, value, operator in operators:              filtered_df_data.append(_FilterDataNode.__filter_dataframe_per_key_value(df_data, key, value, operator))            if isinstance(df_data, modin_pd.DataFrame):              if filtered_df_data:                  return _FilterDataNode.__modin_dataframe_merge(filtered_df_data, how)              return modin_pd.DataFrame()            return _FilterDataNode.__dataframe_merge(filtered_df_data, how) if filtered_df_data else pd.DataFrame()        @staticmethod      def __filter_dataframe_per_key_value(          df_data: Union[pd.DataFrame, modin_pd.DataFrame], key: str, value, operator: Operator      ):          df_by_col = df_data[key]          if operator == Operator.EQUAL:              df_by_col = df_by_col == value          if operator == Operator.NOT_EQUAL:              df_by_col = df_by_col != value          if operator == Operator.LESS_THAN:              df_by_col = df_by_col < value          if operator == Operator.LESS_OR_EQUAL:              df_by_col = df_by_col <= value          if operator == Operator.GREATER_THAN:              df_by_col = df_by_col > value          if operator == Operator.GREATER_OR_EQUAL:              df_by_col = df_by_col >= value          return df_data[df_by_col]        @staticmethod      def __dataframe_merge(df_list: List, how=\"inner\"):          return reduce(lambda df1, df2: pd.merge(df1, df2, how=how), df_list)        @staticmethod      def __modin_dataframe_merge(df_list: List, how=\"inner\"):          return reduce(lambda df1, df2: modin_pd.merge(df1, df2, how=how), df_list)        @staticmethod      def __filter_numpy_array(data: np.ndarray, operators: Union[List, Tuple], join_operator=JoinOperator.AND):          conditions = []          for key, value, operator in operators:              conditions.append(_FilterDataNode.__get_filter_condition_per_key_value(data, key, value, operator))            if join_operator == JoinOperator.AND:              join_conditions = reduce(and_, conditions)          elif join_operator == JoinOperator.OR:              join_conditions = reduce(or_, conditions)          else:              return NotImplementedError            return data[join_conditions]        @staticmethod      def __get_filter_condition_per_key_value(array_data: np.ndarray, key, value, operator: Operator):          if not isinstance(key, int):              key = int(key)            if operator == Operator.EQUAL:              return array_data[:, key] == value          if operator == Operator.NOT_EQUAL:              return array_data[:, key] != value          if operator == Operator.LESS_THAN:              return array_data[:, key] < value          if operator == Operator.LESS_OR_EQUAL:              return array_data[:, key] <= value          if operator == Operator.GREATER_THAN:              return array_data[:, key] > value          if operator == Operator.GREATER_OR_EQUAL:              return array_data[:, key] >= value            return NotImplementedError        @staticmethod      def __filter_list(list_data: List, operators: Union[List, Tuple], join_operator=JoinOperator.AND):          filtered_list_data = []          for key, value, operator in operators:              filtered_list_data.append(_FilterDataNode.__filter_list_per_key_value(list_data, key, value, operator))          if len(filtered_list_data) == 0:              return filtered_list_data          if join_operator == JoinOperator.AND:              return _FilterDataNode.__list_intersect(filtered_list_data)          elif join_operator == JoinOperator.OR:              merged_list = list(chain.from_iterable(filtered_list_data))              if all(isinstance(e, Dict) for e in merged_list):                  return list({frozenset(item.items()) for item in merged_list})              return list(set(merged_list))          else:              return NotImplementedError        @staticmethod      def __filter_list_per_key_value(list_data: List, key: str, value, operator: Operator):          filtered_list = []          for row in list_data:              if isinstance(row, Dict):                  row_value = row.get(key, None)              else:                  row_value = getattr(row, key, None)                if operator == Operator.EQUAL and row_value == value:                  filtered_list.append(row)              if operator == Operator.NOT_EQUAL and row_value != value:                  filtered_list.append(row)              if operator == Operator.LESS_THAN and row_value < value:                  filtered_list.append(row)              if operator == Operator.LESS_OR_EQUAL and row_value <= value:                  filtered_list.append(row)              if operator == Operator.GREATER_THAN and row_value > value:                  filtered_list.append(row)              if operator == Operator.GREATER_OR_EQUAL and row_value >= value:                  filtered_list.append(row)          return filtered_list        @staticmethod      def __list_intersect(list_data):          return list(set(list_data.pop()).intersection(*map(set, list_data))) "}
{"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 ..exceptions.exceptions import MissingReadFunction, MissingRequiredProperty, MissingWriteFunction  from .data_node import DataNode  from .data_node_id import DataNodeId, Edit      class GenericDataNode(DataNode):      \"\"\"Generic Data Node that uses custom read and write functions.        The read and write function for this data node type can be implemented is Python.        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 the 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. Note that the              _properties_ parameter must at least contain an entry for either _\"read_fct\"_ or              _\"write_fct\"_ representing the read and write functions.              Entries for _\"read_fct_args\"_ and _\"write_fct_args\"_ respectively represent              potential parameters for the _\"read_fct\"_ and _\"write_fct\"_ functions.      \"\"\"        __STORAGE_TYPE = \"generic\"      _OPTIONAL_READ_FUNCTION_PROPERTY = \"read_fct\"      __READ_FUNCTION_ARGS_PROPERTY = \"read_fct_args\"      _OPTIONAL_WRITE_FUNCTION_PROPERTY = \"write_fct\"      __WRITE_FUNCTION_ARGS_PROPERTY = \"write_fct_args\"      _REQUIRED_PROPERTIES: List[str] = []      _REQUIRED_AT_LEAST_ONE_PROPERTY: List[str] = [_OPTIONAL_READ_FUNCTION_PROPERTY, _OPTIONAL_WRITE_FUNCTION_PROPERTY]        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: Dict = None,      ):          if properties is None:              properties = {}          if missing := set(self._REQUIRED_PROPERTIES) - set(properties.keys()):              raise MissingRequiredProperty(                  f\"The following properties \" f\"{', '.join(x for x in missing)} were not informed and are required.\"              )            missing_optional_fcts = set(self._REQUIRED_AT_LEAST_ONE_PROPERTY) - set(properties.keys())          if len(missing_optional_fcts) == len(self._REQUIRED_AT_LEAST_ONE_PROPERTY):              raise MissingRequiredProperty(                  f\"None of the following properties \"                  f\"{', '.join(x for x in missing)} were informed and at least one must be populated.\"              )          for missing_optional_fct in missing_optional_fcts:              properties[missing_optional_fct] = 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 not self._last_edit_date:              self._last_edit_date = datetime.now()            self._TAIPY_PROPERTIES.update(              {                  self.__READ_FUNCTION_ARGS_PROPERTY,                  self.__WRITE_FUNCTION_ARGS_PROPERTY,                  self._OPTIONAL_READ_FUNCTION_PROPERTY,                  self._OPTIONAL_WRITE_FUNCTION_PROPERTY,              }          )        @classmethod      def storage_type(cls) -> str:          return cls.__STORAGE_TYPE        def _read(self):          if read_fct := self.properties[self._OPTIONAL_READ_FUNCTION_PROPERTY]:              if read_fct_args := self.properties.get(self.__READ_FUNCTION_ARGS_PROPERTY, None):                  if not isinstance(read_fct_args, list):                      return read_fct(*[read_fct_args])                  return read_fct(*read_fct_args)              return read_fct()          raise MissingReadFunction(f\"The read function is not defined in data node config {self.config_id}.\")        def _write(self, data: Any):          if write_fct := self.properties[self._OPTIONAL_WRITE_FUNCTION_PROPERTY]:              if write_fct_args := self.properties.get(self.__WRITE_FUNCTION_ARGS_PROPERTY, None):                  if not isinstance(write_fct_args, list):                      return write_fct(data, *[write_fct_args])                  return write_fct(data, *write_fct_args)              return write_fct(data)          raise MissingWriteFunction(f\"The write function is not defined in data node config {self.config_id}.\") "}
{"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": "import os  from collections import defaultdict  from datetime import datetime, timedelta  from os.path import isfile  from typing import Any, Dict, List, Optional, Set, Tuple, Union    import modin.pandas as modin_pd  import numpy as np  import pandas as pd  from openpyxl import load_workbook    from taipy.config.common.scope import Scope    from .._backup._backup import _replace_in_backup_file  from .._entity._reload import _self_reload  from .._version._version_manager_factory import _VersionManagerFactory  from ..exceptions.exceptions import ExposedTypeLengthMismatch, NonExistingExcelSheet, SheetNameLengthMismatch  from ..job.job_id import JobId  from ._abstract_file import _AbstractFileDataNode  from ._abstract_tabular import _AbstractTabularDataNode  from .data_node import DataNode  from .data_node_id import DataNodeId, Edit      class ExcelDataNode(DataNode, _AbstractFileDataNode, _AbstractTabularDataNode):      \"\"\"Data Node stored as an Excel file.        The Excel file format is _xlsx_.        Attributes:          config_id (str): Identifier of this 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.          path (str): The path to the Excel file.          properties (dict[str, Any]): A dictionary of additional properties. The _properties_              must have a _\"default_path\"_ or _\"path\"_ entry with the path of the Excel file:                - _\"default_path\"_ `(str)`: The path of the Excel file.\\n              - _\"has_header\"_ `(bool)`: If True, indicates that the Excel file has a header.\\n              - _\"sheet_name\"_ `(Union[List[str], str])`: The list of sheet names to be used. This                  can be a unique name.\\n              - _\"exposed_type\"_: The exposed type of the data read from Excel file. The default value is `pandas`.\\n      \"\"\"        __STORAGE_TYPE = \"excel\"      __EXPOSED_TYPE_PROPERTY = \"exposed_type\"      __EXPOSED_TYPE_NUMPY = \"numpy\"      __EXPOSED_TYPE_PANDAS = \"pandas\"      __EXPOSED_TYPE_MODIN = \"modin\"      __VALID_STRING_EXPOSED_TYPES = [__EXPOSED_TYPE_PANDAS, __EXPOSED_TYPE_MODIN, __EXPOSED_TYPE_NUMPY]      __PATH_KEY = \"path\"      __DEFAULT_DATA_KEY = \"default_data\"      __DEFAULT_PATH_KEY = \"default_path\"      __HAS_HEADER_PROPERTY = \"has_header\"      __SHEET_NAME_PROPERTY = \"sheet_name\"      _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: Dict = None,      ):          if properties is None:              properties = {}            default_value = properties.pop(self.__DEFAULT_DATA_KEY, None)          self._path = properties.get(self.__PATH_KEY, properties.get(self.__DEFAULT_PATH_KEY))          properties[self.__PATH_KEY] = self._path            if self.__SHEET_NAME_PROPERTY not in properties.keys():              properties[self.__SHEET_NAME_PROPERTY] = None          if self.__HAS_HEADER_PROPERTY not in properties.keys():              properties[self.__HAS_HEADER_PROPERTY] = True          if self.__EXPOSED_TYPE_PROPERTY not in properties.keys():              properties[self.__EXPOSED_TYPE_PROPERTY] = self.__EXPOSED_TYPE_PANDAS          self._check_exposed_type(properties[self.__EXPOSED_TYPE_PROPERTY], self.__VALID_STRING_EXPOSED_TYPES)            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 not self._path:              self._path = self._build_path(self.storage_type())              properties[self.__PATH_KEY] = self._path            if default_value is not None and not os.path.exists(self._path):              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.\",                      }                  )              )            if not self._last_edit_date and isfile(self._path):              self._last_edit_date = datetime.now()            self._TAIPY_PROPERTIES.update(              {                  self.__EXPOSED_TYPE_PROPERTY,                  self.__PATH_KEY,                  self.__DEFAULT_PATH_KEY,                  self.__DEFAULT_DATA_KEY,                  self.__HAS_HEADER_PROPERTY,                  self.__SHEET_NAME_PROPERTY,              }          )        @property  # type: ignore      @_self_reload(DataNode._MANAGER_NAME)      def path(self):          return self._path        @path.setter      def path(self, value):          tmp_old_path = self._path          self._path = value          self.properties[self.__PATH_KEY] = value          _replace_in_backup_file(old_file_path=tmp_old_path, new_file_path=self._path)        @classmethod      def storage_type(cls) -> str:          return cls.__STORAGE_TYPE        @staticmethod      def _check_exposed_type(exposed_type, valid_string_exposed_types):          if isinstance(exposed_type, str):              _AbstractTabularDataNode._check_exposed_type(exposed_type, valid_string_exposed_types)          elif isinstance(exposed_type, list):              for t in exposed_type:                  _AbstractTabularDataNode._check_exposed_type(t, valid_string_exposed_types)          elif isinstance(exposed_type, dict):              for t in exposed_type.values():                  _AbstractTabularDataNode._check_exposed_type(t, valid_string_exposed_types)        def _read(self):          if self.properties[self.__EXPOSED_TYPE_PROPERTY] == self.__EXPOSED_TYPE_PANDAS:              return self._read_as_pandas_dataframe()          if self.properties[self.__EXPOSED_TYPE_PROPERTY] == self.__EXPOSED_TYPE_MODIN:              return self._read_as_modin_dataframe()          if self.properties[self.__EXPOSED_TYPE_PROPERTY] == self.__EXPOSED_TYPE_NUMPY:              return self._read_as_numpy()          return self._read_as()        def __sheet_name_to_list(self, properties):          if properties[self.__SHEET_NAME_PROPERTY]:              sheet_names = properties[self.__SHEET_NAME_PROPERTY]          else:              excel_file = load_workbook(properties[self.__PATH_KEY])              sheet_names = excel_file.sheetnames              excel_file.close()          return sheet_names if isinstance(sheet_names, (List, Set, Tuple)) else [sheet_names]        def _read_as(self):          excel_file = load_workbook(self._path)          exposed_type = self.properties[self.__EXPOSED_TYPE_PROPERTY]          work_books = defaultdict()          sheet_names = excel_file.sheetnames          provided_sheet_names = self.__sheet_name_to_list(self.properties)            for sheet_name in provided_sheet_names:              if sheet_name not in sheet_names:                  raise NonExistingExcelSheet(sheet_name, self._path)            if isinstance(exposed_type, List):              if len(provided_sheet_names) != len(self.properties[self.__EXPOSED_TYPE_PROPERTY]):                  raise ExposedTypeLengthMismatch(                      f\"Expected {len(provided_sheet_names)} exposed types, got \"                      f\"{len(self.properties[self.__EXPOSED_TYPE_PROPERTY])}\"                  )            for i, sheet_name in enumerate(provided_sheet_names):              work_sheet = excel_file[sheet_name]              sheet_exposed_type = exposed_type                if not isinstance(sheet_exposed_type, str):                  if isinstance(exposed_type, dict):                      sheet_exposed_type = exposed_type.get(sheet_name, self.__EXPOSED_TYPE_PANDAS)                  elif isinstance(exposed_type, List):                      sheet_exposed_type = exposed_type[i]                    if isinstance(sheet_exposed_type, str):                      if sheet_exposed_type == self.__EXPOSED_TYPE_NUMPY:                          work_books[sheet_name] = self._read_as_pandas_dataframe(sheet_name).to_numpy()                      elif sheet_exposed_type == self.__EXPOSED_TYPE_PANDAS:                          work_books[sheet_name] = self._read_as_pandas_dataframe(sheet_name)                      continue                res = list()              for row in work_sheet.rows:                  res.append([col.value for col in row])              if self.properties[self.__HAS_HEADER_PROPERTY] and res:                  header = res.pop(0)                  for i, row in enumerate(res):                      res[i] = sheet_exposed_type(**dict([[h, r] for h, r in zip(header, row)]))              else:                  for i, row in enumerate(res):                      res[i] = sheet_exposed_type(*row)              work_books[sheet_name] = res            excel_file.close()            if len(provided_sheet_names) == 1:              return work_books[provided_sheet_names[0]]          return work_books        def _read_as_numpy(self):          sheets = self._read_as_pandas_dataframe()          if isinstance(sheets, dict):              return {sheet_name: df.to_numpy() for sheet_name, df in sheets.items()}          return sheets.to_numpy()        def _do_read_excel(self, engine, sheet_names, kwargs) -> pd.DataFrame:          df = pd.read_excel(              self._path,              sheet_name=sheet_names,              **kwargs,          )          # We are using pandas to load modin dataframes because of a modin issue          # https://github.com/modin-project/modin/issues/4924          if engine == \"modin\":              if isinstance(df, dict):  # Check if it s a multiple sheet Excel file                  for key, value in df.items():                      df[key] = modin_pd.DataFrame(value)                  return df              return modin_pd.DataFrame(df)          return df        def __get_sheet_names_and_header(self, sheet_names):          kwargs: Dict[str, Any] = {}          if sheet_names is None:              sheet_names = self.properties[self.__SHEET_NAME_PROPERTY]          if not self.properties[self.__HAS_HEADER_PROPERTY]:              kwargs[\"header\"] = None          return sheet_names, kwargs        def _read_as_pandas_dataframe(self, sheet_names=None) -> Union[Dict[Union[int, str], pd.DataFrame], pd.DataFrame]:          sheet_names, kwargs = self.__get_sheet_names_and_header(sheet_names)          try:              return self._do_read_excel(\"pandas\", sheet_names, kwargs)          except pd.errors.EmptyDataError:              return pd.DataFrame()        def _read_as_modin_dataframe(          self, sheet_names=None      ) -> Union[Dict[Union[int, str], modin_pd.DataFrame], modin_pd.DataFrame]:          sheet_names, kwargs = self.__get_sheet_names_and_header(sheet_names)          try:              if kwargs.get(\"header\", None):                  return modin_pd.read_excel(                      self._path,                      sheet_name=sheet_names,                      **kwargs,                  )              else:                  return self._do_read_excel(\"modin\", sheet_names, kwargs)          except pd.errors.EmptyDataError:              return modin_pd.DataFrame()        def __append_excel_with_single_sheet(self, append_excel_fct, *args, **kwargs):          sheet_name = self.properties.get(self.__SHEET_NAME_PROPERTY)            with pd.ExcelWriter(self._path, mode=\"a\", engine=\"openpyxl\", if_sheet_exists=\"overlay\") as writer:              if sheet_name:                  if not isinstance(sheet_name, str):                      sheet_name = sheet_name[0]                  append_excel_fct(                      writer, *args, **kwargs, sheet_name=sheet_name, startrow=writer.sheets[sheet_name].max_row                  )              else:                  sheet_name = list(writer.sheets.keys())[0]                  append_excel_fct(writer, *args, **kwargs, startrow=writer.sheets[sheet_name].max_row)        def __append_excel_with_multiple_sheets(self, data: Any, columns: List[str] = None):          with pd.ExcelWriter(self._path, mode=\"a\", engine=\"openpyxl\", if_sheet_exists=\"overlay\") as writer:              # Each key stands for a sheet name              for sheet_name in data.keys():                  if isinstance(data[sheet_name], np.ndarray):                      df = pd.DataFrame(data[sheet_name])                  else:                      df = data[sheet_name]                    if columns:                      data[sheet_name].columns = columns                    df.to_excel(                      writer, sheet_name=sheet_name, index=False, header=False, startrow=writer.sheets[sheet_name].max_row                  )        def _append(self, data: Any):          if isinstance(data, Dict) and all(              [isinstance(x, (pd.DataFrame, modin_pd.DataFrame, np.ndarray)) for x in data.values()]          ):              self.__append_excel_with_multiple_sheets(data)          elif isinstance(data, (pd.DataFrame, modin_pd.DataFrame)):              self.__append_excel_with_single_sheet(data.to_excel, index=False, header=False)          else:              self.__append_excel_with_single_sheet(pd.DataFrame(data).to_excel, index=False, header=False)        def __write_excel_with_single_sheet(self, write_excel_fct, *args, **kwargs):          sheet_name = self.properties.get(self.__SHEET_NAME_PROPERTY)          if sheet_name:              if not isinstance(sheet_name, str):                  if len(sheet_name) > 1:                      raise SheetNameLengthMismatch                  else:                      sheet_name = sheet_name[0]              write_excel_fct(*args, **kwargs, sheet_name=sheet_name)          else:              write_excel_fct(*args, **kwargs)        def __write_excel_with_multiple_sheets(self, data: Any, columns: List[str] = None):          with pd.ExcelWriter(self._path) as writer:              # Each key stands for a sheet name              for key in data.keys():                  if isinstance(data[key], np.ndarray):                      df = pd.DataFrame(data[key])                  else:                      df = data[key]                    if columns:                      data[key].columns = columns                    df.to_excel(writer, key, index=False)        def _write(self, data: Any):          if isinstance(data, Dict) and all(              [isinstance(x, (pd.DataFrame, modin_pd.DataFrame, np.ndarray)) for x in data.values()]          ):              self.__write_excel_with_multiple_sheets(data)          elif isinstance(data, (pd.DataFrame, modin_pd.DataFrame)):              self.__write_excel_with_single_sheet(data.to_excel, self._path, index=False)          else:              self.__write_excel_with_single_sheet(pd.DataFrame(data).to_excel, self._path, index=False)        def write_with_column_names(self, data: Any, columns: List[str] = None, job_id: Optional[JobId] = None):          \"\"\"Write a set of columns.            Parameters:              data (Any): The data to write.              columns (List[str]): The list of column names to write.              job_id (JobId^): An optional identifier of the writer.          \"\"\"          if isinstance(data, Dict) and all(              [isinstance(x, (pd.DataFrame, modin_pd.DataFrame, np.ndarray)) for x in data.values()]          ):              self.__write_excel_with_multiple_sheets(data, columns=columns)          else:              df = pd.DataFrame(data)              if columns:                  df.columns = columns              self.__write_excel_with_single_sheet(df.to_excel, self.path, index=False)          self.track_edit(timestamp=datetime.now(), job_id=job_id) "}
{"text": "import os  from typing import Dict, Iterable, List, Optional, Set, Union    from taipy.config._config import _Config  from taipy.config.common.scope import Scope  from taipy.config.config import Config    from .._backup._backup import _append_to_backup_file, _remove_from_backup_file  from .._manager._manager import _Manager  from .._version._version_mixin import _VersionMixin  from ..config.data_node_config import DataNodeConfig  from ..cycle.cycle_id import CycleId  from ..exceptions.exceptions import InvalidDataNodeType  from ..notification import Event, EventEntityType, EventOperation, Notifier, _make_event  from ..scenario.scenario_id import ScenarioId  from ..sequence.sequence_id import SequenceId  from ._abstract_file import _AbstractFileDataNode  from ._data_fs_repository import _DataFSRepository  from .data_node import DataNode  from .data_node_id import DataNodeId  from .pickle import PickleDataNode      class _DataManager(_Manager[DataNode], _VersionMixin):      __DATA_NODE_CLASS_MAP = DataNode._class_map()  # type: ignore      _ENTITY_NAME = DataNode.__name__      _EVENT_ENTITY_TYPE = EventEntityType.DATA_NODE      _repository: _DataFSRepository      __NAME_KEY = \"name\"        @classmethod      def _bulk_get_or_create(          cls,          data_node_configs: List[DataNodeConfig],          cycle_id: Optional[CycleId] = None,          scenario_id: Optional[ScenarioId] = None,      ) -> Dict[DataNodeConfig, DataNode]:          data_node_configs = [Config.data_nodes[dnc.id] for dnc in data_node_configs]          dn_configs_and_owner_id = []          for dn_config in data_node_configs:              scope = dn_config.scope              owner_id: Union[Optional[SequenceId], Optional[ScenarioId], Optional[CycleId]]              if scope == Scope.SCENARIO:                  owner_id = scenario_id              elif scope == Scope.CYCLE:                  owner_id = cycle_id              else:                  owner_id = None              dn_configs_and_owner_id.append((dn_config, owner_id))            data_nodes = cls._repository._get_by_configs_and_owner_ids(              dn_configs_and_owner_id, cls._build_filters_with_version(None)          )            return {              dn_config: data_nodes.get((dn_config, owner_id)) or cls._create_and_set(dn_config, owner_id, None)              for dn_config, owner_id in dn_configs_and_owner_id          }        @classmethod      def _create_and_set(          cls, data_node_config: DataNodeConfig, owner_id: Optional[str], parent_ids: Optional[Set[str]]      ) -> DataNode:          data_node = cls.__create(data_node_config, owner_id, parent_ids)          cls._set(data_node)          if isinstance(data_node, _AbstractFileDataNode):              _append_to_backup_file(new_file_path=data_node._path)          Notifier.publish(_make_event(data_node, EventOperation.CREATION))          return data_node        @classmethod      def __create(          cls, data_node_config: DataNodeConfig, owner_id: Optional[str], parent_ids: Optional[Set[str]]      ) -> DataNode:          try:              version = cls._get_latest_version()              props = data_node_config._properties.copy()                if data_node_config.storage_type:                  storage_type = data_node_config.storage_type              else:                  storage_type = Config.sections[DataNodeConfig.name][_Config.DEFAULT_KEY].storage_type                return cls.__DATA_NODE_CLASS_MAP[storage_type](                  config_id=data_node_config.id,                  scope=data_node_config.scope or DataNodeConfig._DEFAULT_SCOPE,                  validity_period=data_node_config.validity_period,                  owner_id=owner_id,                  parent_ids=parent_ids,                  version=version,                  properties=props,              )          except KeyError:              raise InvalidDataNodeType(data_node_config.storage_type)        @classmethod      def _get_all(cls, version_number: Optional[str] = None) -> List[DataNode]:          \"\"\"          Returns all entities.          \"\"\"          filters = cls._build_filters_with_version(version_number)          return cls._repository._load_all(filters)        @classmethod      def _clean_pickle_file(cls, data_node: DataNode):          if not isinstance(data_node, PickleDataNode):              return          if data_node.is_generated and os.path.exists(data_node.path):              os.remove(data_node.path)        @classmethod      def _clean_pickle_files(cls, data_nodes: Iterable[DataNode]):          for data_node in data_nodes:              cls._clean_pickle_file(data_node)        @classmethod      def _remove_dn_file_path_in_backup_file(cls, data_node: DataNode):          if isinstance(data_node, _AbstractFileDataNode):              _remove_from_backup_file(to_remove_file_path=data_node.path)        @classmethod      def _remove_dn_file_paths_in_backup_file(cls, data_nodes: Iterable[DataNode]):          for data_node in data_nodes:              cls._remove_dn_file_path_in_backup_file(data_node)        @classmethod      def _delete(cls, data_node_id: DataNodeId):          data_node = cls._get(data_node_id, None)          if data_node:              cls._clean_pickle_file(data_node)              cls._remove_dn_file_path_in_backup_file(data_node)          super()._delete(data_node_id)        @classmethod      def _delete_many(cls, data_node_ids: Iterable[DataNodeId]):          data_nodes = []          for data_node_id in data_node_ids:              if data_node := cls._get(data_node_id):                  data_nodes.append(data_node)          cls._clean_pickle_files(data_nodes)          cls._remove_dn_file_paths_in_backup_file(data_nodes)          super()._delete_many(data_node_ids)        @classmethod      def _delete_all(cls):          data_nodes = cls._get_all()          cls._clean_pickle_files(data_nodes)          cls._remove_dn_file_paths_in_backup_file(data_nodes)          super()._delete_all()        @classmethod      def _delete_by_version(cls, version_number: str):          data_nodes = cls._get_all(version_number)          cls._clean_pickle_files(data_nodes)          cls._remove_dn_file_paths_in_backup_file(data_nodes)          cls._repository._delete_by(attribute=\"version\", value=version_number)          Notifier.publish(              Event(EventEntityType.DATA_NODE, EventOperation.DELETION, metadata={\"delete_by_version\": version_number})          )        @classmethod      def _get_by_config_id(cls, config_id: str, version_number: Optional[str] = None) -> List[DataNode]:          \"\"\"          Get all datanodes by its config id.          \"\"\"          filters = cls._build_filters_with_version(version_number)          if not filters:              filters = [{}]          for fil in filters:              fil.update({\"config_id\": config_id})          return cls._repository._load_all(filters) "}
{"text": "from datetime import datetime, timedelta  from typing import Any, Dict, List, Optional, Set, Tuple, Union    import modin.pandas as modin_pd  import numpy as np  import pandas as pd  from sqlalchemy import MetaData, Table    from taipy.config.common.scope import Scope    from .._version._version_manager_factory import _VersionManagerFactory  from ..exceptions.exceptions import MissingRequiredProperty  from ._abstract_sql import _AbstractSQLDataNode  from .data_node_id import DataNodeId, Edit      class SQLTableDataNode(_AbstractSQLDataNode):      \"\"\"Data Node stored in a SQL table.        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. Note that the              _properties_ parameter must at least contain an entry for _\"db_name\"_, _\"db_engine\"_, _\"table_name\"_:                - _\"db_name\"_ `(str)`: The database name, or the name of the SQLite database file.              - _\"db_engine\"_ `(str)`: The database engine. For now, the accepted values are _\"sqlite\"_, _\"mssql\"_,                  _\"mysql\"_, or _\"postgresql\"_.              - _\"table_name\"_ `(str)`: The name of the SQL table.              - _\"db_username\"_ `(str)`: The database username.              - _\"db_password\"_ `(str)`: The database password.              - _\"db_host\"_ `(str)`: The database host. The default value is _\"localhost\"_.              - _\"db_port\"_ `(int)`: The database port. The default value is 1433.              - _\"db_driver\"_ `(str)`: The database driver.              - _\"sqlite_folder_path\"_ (str): The path to the folder that contains SQLite file. The default value                  is the current working folder.              - _\"sqlite_file_extension\"_ (str): The filename extension of the SQLite file. The default value is \".db\".              - _\"db_extra_args\"_ `(Dict[str, Any])`: A dictionary of additional arguments to be passed into database                  connection string.              - _\"exposed_type\"_: The exposed type of the data read from SQL query. The default value is `pandas`.      \"\"\"        __STORAGE_TYPE = \"sql_table\"      __TABLE_KEY = \"table_name\"        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: Optional[List[Edit]] = None,          version: Optional[str] = None,          validity_period: Optional[timedelta] = None,          edit_in_progress: bool = False,          editor_id: Optional[str] = None,          editor_expiration_date: Optional[datetime] = None,          properties: Optional[Dict] = None,      ):          if properties is None:              properties = {}          if properties.get(self.__TABLE_KEY) is None:              raise MissingRequiredProperty(f\"Property {self.__TABLE_KEY} is not informed and is required.\")          super().__init__(              config_id,              scope,              id=id,              owner_id=owner_id,              parent_ids=parent_ids,              last_edit_date=last_edit_date,              edits=edits,              version=version or _VersionManagerFactory._build_manager()._get_latest_version(),              validity_period=validity_period,              edit_in_progress=edit_in_progress,              editor_id=editor_id,              editor_expiration_date=editor_expiration_date,              properties=properties,          )          self._TAIPY_PROPERTIES.update({self.__TABLE_KEY})        @classmethod      def storage_type(cls) -> str:          return cls.__STORAGE_TYPE        def _get_base_read_query(self) -> str:          return f\"SELECT * FROM {self.properties[self.__TABLE_KEY]}\"        def _do_append(self, data, engine, connection) -> None:          self.__insert_data(data, engine, connection)        def _do_write(self, data, engine, connection) -> None:          self.__insert_data(data, engine, connection, delete_table=True)        def __insert_data(self, data, engine, connection, delete_table: bool = False) -> None:          \"\"\"          Insert data into a SQL table.            Parameters:              data (List[Dict]): a list of dictionaries, where each dictionary represents a row of the table.              table: a SQLAlchemy object that represents a table.              connection: a SQLAlchemy connection to write the data.              delete_table (bool): indicates if the table should be deleted before inserting the data.          \"\"\"          table = self._create_table(engine)          if isinstance(data, (modin_pd.DataFrame, pd.DataFrame)):              self.__insert_dataframe(data, table, connection, delete_table)              return            if isinstance(data, np.ndarray):              data = data.tolist()          if not isinstance(data, list):              data = [data]            if len(data) == 0:              self.__delete_all_rows(table, connection, delete_table)              return            if isinstance(data[0], (tuple, list)):              self.__insert_tuples(data, table, connection, delete_table)          elif isinstance(data[0], dict):              self.__insert_dicts(data, table, connection, delete_table)          # If data is a primitive type, it will be inserted as a tuple of one element.          else:              self.__insert_tuples([(x,) for x in data], table, connection, delete_table)        def _create_table(self, engine) -> Table:          return Table(              self.properties[self.__TABLE_KEY],              MetaData(),              autoload_with=engine,          )        @classmethod      def __insert_dicts(cls, data: List[Dict], table: Any, connection: Any, delete_table: bool) -> None:          \"\"\"          This method will insert the data contained in a list of dictionaries into a table. The query itself is handled          by SQLAlchemy, so it's only needed to pass the correct data type.          \"\"\"          cls.__delete_all_rows(table, connection, delete_table)          connection.execute(table.insert(), data)        @classmethod      def __insert_dataframe(          cls, df: Union[modin_pd.DataFrame, pd.DataFrame], table: Any, connection: Any, delete_table: bool      ) -> None:          cls.__insert_dicts(df.to_dict(orient=\"records\"), table, connection, delete_table)        @classmethod      def __insert_tuples(cls, data: List[Union[Tuple, List]], table: Any, connection: Any, delete_table: bool) -> None:          \"\"\"          This method will look up the length of the first object of the list and build the insert through          creation of a string of '?' equivalent to the length of the element. The '?' character is used as          placeholder for a tuple of same size.          \"\"\"          cls.__delete_all_rows(table, connection, delete_table)          markers = \",\".join(\"?\" * len(data[0]))          ins = \"INSERT INTO {tablename} VALUES ({markers})\"          ins = ins.format(tablename=table.name, markers=markers)          connection.execute(ins, data)        @classmethod      def __delete_all_rows(cls, table: Any, connection: Any, delete_table: bool) -> None:          if delete_table:              connection.execute(table.delete()) "}
{"text": "import csv  import os  from datetime import datetime, timedelta  from os.path import isfile  from typing import Any, Dict, List, Optional, Set    import modin.pandas as modin_pd  import numpy as np  import pandas as pd    from taipy.config.common.scope import Scope    from .._backup._backup import _replace_in_backup_file  from .._entity._reload import _self_reload  from .._version._version_manager_factory import _VersionManagerFactory  from ..job.job_id import JobId  from ._abstract_file import _AbstractFileDataNode  from ._abstract_tabular import _AbstractTabularDataNode  from .data_node import DataNode  from .data_node_id import DataNodeId, Edit      class CSVDataNode(DataNode, _AbstractFileDataNode, _AbstractTabularDataNode):      \"\"\"Data Node stored as a CSV file.        Attributes:          config_id (str): Identifier of the data node configuration. This string 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.          path (str): The path to the CSV file.          properties (dict[str, Any]): A dictionary of additional properties. The _properties_              must have a _\"default_path\"_ or _\"path\"_ entry with the path of the CSV file:                - _\"default_path\"_ `(str)`: The default path of the CSV file.\\n              - _\"encoding\"_ `(str)`: The encoding of the CSV file. The default value is `utf-8`.\\n              - _\"default_data\"_: The default data of the data nodes instantiated from this csv data node.\\n              - _\"has_header\"_ `(bool)`: If True, indicates that the CSV file has a header.\\n              - _\"exposed_type\"_: The exposed type of the data read from CSV file. The default value is `pandas`.\\n      \"\"\"        __STORAGE_TYPE = \"csv\"      __EXPOSED_TYPE_PROPERTY = \"exposed_type\"      __EXPOSED_TYPE_NUMPY = \"numpy\"      __EXPOSED_TYPE_PANDAS = \"pandas\"      __EXPOSED_TYPE_MODIN = \"modin\"      __VALID_STRING_EXPOSED_TYPES = [__EXPOSED_TYPE_PANDAS, __EXPOSED_TYPE_MODIN, __EXPOSED_TYPE_NUMPY]      __PATH_KEY = \"path\"      __DEFAULT_PATH_KEY = \"default_path\"      __ENCODING_KEY = \"encoding\"      __DEFAULT_DATA_KEY = \"default_data\"      __HAS_HEADER_PROPERTY = \"has_header\"      _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: Optional[List[Edit]] = None,          version: Optional[str] = None,          validity_period: Optional[timedelta] = None,          edit_in_progress: bool = False,          editor_id: Optional[str] = None,          editor_expiration_date: Optional[datetime] = None,          properties: Optional[Dict] = None,      ):          if properties is None:              properties = {}            default_value = properties.pop(self.__DEFAULT_DATA_KEY, None)            if self.__ENCODING_KEY not in properties.keys():              properties[self.__ENCODING_KEY] = \"utf-8\"            if self.__HAS_HEADER_PROPERTY not in properties.keys():              properties[self.__HAS_HEADER_PROPERTY] = True            if self.__EXPOSED_TYPE_PROPERTY not in properties.keys():              properties[self.__EXPOSED_TYPE_PROPERTY] = self.__EXPOSED_TYPE_PANDAS          self._check_exposed_type(properties[self.__EXPOSED_TYPE_PROPERTY], self.__VALID_STRING_EXPOSED_TYPES)            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,          )          self._path = properties.get(self.__PATH_KEY, properties.get(self.__DEFAULT_PATH_KEY))          if not self._path:              self._path = self._build_path(self.storage_type())          properties[self.__PATH_KEY] = self._path            if not self._last_edit_date and isfile(self._path):              self._last_edit_date = datetime.now()          if default_value is not None and not os.path.exists(self._path):              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.__EXPOSED_TYPE_PROPERTY,                  self.__PATH_KEY,                  self.__DEFAULT_PATH_KEY,                  self.__ENCODING_KEY,                  self.__DEFAULT_DATA_KEY,                  self.__HAS_HEADER_PROPERTY,              }          )        @classmethod      def storage_type(cls) -> str:          return cls.__STORAGE_TYPE        @property  # type: ignore      @_self_reload(DataNode._MANAGER_NAME)      def path(self):          return self._path        @path.setter      def path(self, value):          tmp_old_path = self._path          self._path = value          self.properties[self.__PATH_KEY] = value          _replace_in_backup_file(old_file_path=tmp_old_path, new_file_path=self._path)        def _read(self):          if self.properties[self.__EXPOSED_TYPE_PROPERTY] == self.__EXPOSED_TYPE_PANDAS:              return self._read_as_pandas_dataframe()          if self.properties[self.__EXPOSED_TYPE_PROPERTY] == self.__EXPOSED_TYPE_MODIN:              return self._read_as_modin_dataframe()          if self.properties[self.__EXPOSED_TYPE_PROPERTY] == self.__EXPOSED_TYPE_NUMPY:              return self._read_as_numpy()          return self._read_as()        def _read_as(self):          custom_class = self.properties[self.__EXPOSED_TYPE_PROPERTY]          with open(self._path, encoding=self.properties[self.__ENCODING_KEY]) as csvFile:              res = list()              if self.properties[self.__HAS_HEADER_PROPERTY]:                  reader = csv.DictReader(csvFile)                  for line in reader:                      res.append(custom_class(**line))              else:                  reader = csv.reader(                      csvFile,                  )                  for line in reader:                      res.append(custom_class(*line))              return res        def _read_as_numpy(self) -> np.ndarray:          return self._read_as_pandas_dataframe().to_numpy()        def _read_as_pandas_dataframe(          self, usecols: Optional[List[int]] = None, column_names: Optional[List[str]] = None      ) -> pd.DataFrame:          try:              if self.properties[self.__HAS_HEADER_PROPERTY]:                  if column_names:                      return pd.read_csv(self._path, encoding=self.properties[self.__ENCODING_KEY])[column_names]                  return pd.read_csv(self._path, encoding=self.properties[self.__ENCODING_KEY])              else:                  if usecols:                      return pd.read_csv(                          self._path, encoding=self.properties[self.__ENCODING_KEY], header=None, usecols=usecols                      )                  return pd.read_csv(self._path, encoding=self.properties[self.__ENCODING_KEY], header=None)          except pd.errors.EmptyDataError:              return pd.DataFrame()        def _read_as_modin_dataframe(          self, usecols: Optional[List[int]] = None, column_names: Optional[List[str]] = None      ) -> modin_pd.DataFrame:          try:              if self.properties[self.__HAS_HEADER_PROPERTY]:                  if column_names:                      return modin_pd.read_csv(self._path, encoding=self.properties[self.__ENCODING_KEY])[column_names]                  return modin_pd.read_csv(self._path, encoding=self.properties[self.__ENCODING_KEY])              else:                  if usecols:                      return modin_pd.read_csv(                          self._path, header=None, usecols=usecols, encoding=self.properties[self.__ENCODING_KEY]                      )                  return modin_pd.read_csv(self._path, header=None, encoding=self.properties[self.__ENCODING_KEY])          except pd.errors.EmptyDataError:              return modin_pd.DataFrame()        def _append(self, data: Any):          if isinstance(data, (pd.DataFrame, modin_pd.DataFrame)):              data.to_csv(self._path, mode=\"a\", index=False, encoding=self.properties[self.__ENCODING_KEY], header=False)          else:              pd.DataFrame(data).to_csv(                  self._path, mode=\"a\", index=False, encoding=self.properties[self.__ENCODING_KEY], header=False              )        def _write(self, data: Any):          if isinstance(data, (pd.DataFrame, modin_pd.DataFrame)):              data.to_csv(self._path, index=False, encoding=self.properties[self.__ENCODING_KEY])          else:              pd.DataFrame(data).to_csv(self._path, index=False, encoding=self.properties[self.__ENCODING_KEY])        def write_with_column_names(self, data: Any, columns: Optional[List[str]] = None, job_id: Optional[JobId] = None):          \"\"\"Write a selection of columns.            Parameters:              data (Any): The data to write.              columns (Optional[List[str]]): The list of column names to write.              job_id (JobId^): An optional identifier of the writer.          \"\"\"          if not columns:              df = pd.DataFrame(data)          else:              df = pd.DataFrame(data, columns=columns)          df.to_csv(self._path, index=False, encoding=self.properties[self.__ENCODING_KEY])          self.track_edit(timestamp=datetime.now(), job_id=job_id) "}
{"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": "import os  import pickle  from datetime import datetime, timedelta  from typing import Any, List, Optional, Set    import modin.pandas as pd    from taipy.config.common.scope import Scope    from .._backup._backup import _replace_in_backup_file  from .._entity._reload import _self_reload  from .._version._version_manager_factory import _VersionManagerFactory  from ._abstract_file import _AbstractFileDataNode  from .data_node import DataNode  from .data_node_id import DataNodeId, Edit      class PickleDataNode(DataNode, _AbstractFileDataNode):      \"\"\"Data Node stored as a pickle file.        Attributes:          config_id (str): Identifier of the data node configuration. It must be a valid Python              identifer.          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 a pickle data node, if the _properties_ dictionary contains a              _\"default_data\"_ entry, the data node is automatically written with the corresponding              _\"default_data\"_ value.              If the _properties_ dictionary contains a _\"default_path\"_ or _\"path\"_ entry, the data will be stored              using the corresponding value as the name of the pickle file.      \"\"\"        __STORAGE_TYPE = \"pickle\"      __PATH_KEY = \"path\"      __DEFAULT_PATH_KEY = \"default_path\"      __DEFAULT_DATA_KEY = \"default_data\"      __IS_GENERATED_KEY = \"is_generated\"      _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: Optional[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_KEY, None)          self._path = properties.get(self.__PATH_KEY, properties.get(self.__DEFAULT_PATH_KEY))          if self._path is not None:              properties[self.__PATH_KEY] = self._path          self._is_generated = properties.get(self.__IS_GENERATED_KEY, self._path is None)          properties[self.__IS_GENERATED_KEY] = self._is_generated          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 self._path is None:              self._path = self._build_path(self.storage_type())          if not self._last_edit_date and os.path.exists(self._path):              self._last_edit_date = datetime.now()          if default_value is not None and not os.path.exists(self._path):              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.__PATH_KEY,                  self.__DEFAULT_PATH_KEY,                  self.__DEFAULT_DATA_KEY,                  self.__IS_GENERATED_KEY,              }          )        @classmethod      def storage_type(cls) -> str:          return cls.__STORAGE_TYPE        @property  # type: ignore      @_self_reload(DataNode._MANAGER_NAME)      def path(self) -> Any:          return self._path        @path.setter      def path(self, value):          tmp_old_path = self._path          self._path = value          self.properties[self.__PATH_KEY] = value          self.properties[self.__IS_GENERATED_KEY] = False          _replace_in_backup_file(old_file_path=tmp_old_path, new_file_path=self._path)        @property  # type: ignore      @_self_reload(DataNode._MANAGER_NAME)      def is_generated(self) -> bool:          return self._is_generated        def _read(self):          os.environ[\"MODIN_PERSISTENT_PICKLE\"] = \"True\"          with open(self._path, \"rb\") as pf:              return pickle.load(pf)        def _write(self, data):          if isinstance(data, (pd.DataFrame, pd.Series)):              os.environ[\"MODIN_PERSISTENT_PICKLE\"] = \"True\"          with open(self._path, \"wb\") as pf:              pickle.dump(data, pf) "}
{"text": "from datetime import datetime, timedelta  from typing import Dict, List, Optional, Set    from sqlalchemy import text    from taipy.config.common.scope import Scope    from .._version._version_manager_factory import _VersionManagerFactory  from ..exceptions.exceptions import MissingAppendQueryBuilder, MissingRequiredProperty  from ._abstract_sql import _AbstractSQLDataNode  from .data_node_id import DataNodeId, Edit      class SQLDataNode(_AbstractSQLDataNode):      \"\"\"Data Node stored in a SQL database.        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. Note that the              _properties_ parameter must at least contain an entry for _\"db_name\"_, _\"db_engine\"_, _\"read_query\"_,              and _\"write_query_builder\"_:                - _\"db_name\"_ `(str)`: The database name, or the name of the SQLite database file.              - _\"db_engine\"_ `(str)`: The database engine. Possible values are _\"sqlite\"_, _\"mssql\"_, _\"mysql\"_, or                  _\"postgresql\"_.              - _\"read_query\"_ `(str)`: The SQL query string used to read the data from the database.              - _\"write_query_builder\"_ `(Callable)`: A callback function that takes the data as an input parameter and                  returns a list of SQL queries to be executed when writing data to the data node.              - _\"append_query_builder\"_ `(Callable)`: A callback function that takes the data as an input parameter and                  returns a list of SQL queries to be executed when appending data to the data node.              - _\"db_username\"_ `(str)`: The database username.              - _\"db_password\"_ `(str)`: The database password.              - _\"db_host\"_ `(str)`: The database host. The default value is _\"localhost\"_.              - _\"db_port\"_ `(int)`: The database port. The default value is 1433.              - _\"db_driver\"_ `(str)`: The database driver.              - _\"sqlite_folder_path\"_ (str): The path to the folder that contains SQLite file. The default value                  is the current working folder.              - _\"sqlite_file_extension\"_ (str): The filename extension of the SQLite file. The default value is \".db\".              - _\"db_extra_args\"_ `(Dict[str, Any])`: A dictionary of additional arguments to be passed into database                  connection string.              - _\"exposed_type\"_: The exposed type of the data read from SQL query. The default value is `pandas`.      \"\"\"        __STORAGE_TYPE = \"sql\"      __READ_QUERY_KEY = \"read_query\"      _WRITE_QUERY_BUILDER_KEY = \"write_query_builder\"      _APPEND_QUERY_BUILDER_KEY = \"append_query_builder\"        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: Optional[List[Edit]] = None,          version: Optional[str] = None,          validity_period: Optional[timedelta] = None,          edit_in_progress: bool = False,          editor_id: Optional[str] = None,          editor_expiration_date: Optional[datetime] = None,          properties: Optional[Dict] = None,      ):          if properties is None:              properties = {}          if properties.get(self.__READ_QUERY_KEY) is None:              raise MissingRequiredProperty(f\"Property {self.__READ_QUERY_KEY} is not informed and is required.\")          if properties.get(self._WRITE_QUERY_BUILDER_KEY) is None:              raise MissingRequiredProperty(f\"Property {self._WRITE_QUERY_BUILDER_KEY} is not informed and is required.\")            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=properties,          )            self._TAIPY_PROPERTIES.update(              {                  self.__READ_QUERY_KEY,                  self._WRITE_QUERY_BUILDER_KEY,                  self._APPEND_QUERY_BUILDER_KEY,              }          )        @classmethod      def storage_type(cls) -> str:          return cls.__STORAGE_TYPE        def _get_base_read_query(self) -> str:          return self.properties.get(self.__READ_QUERY_KEY)        def _do_append(self, data, engine, connection) -> None:          if not self.properties.get(self._APPEND_QUERY_BUILDER_KEY):              raise MissingAppendQueryBuilder            queries = self.properties.get(self._APPEND_QUERY_BUILDER_KEY)(data)          self.__execute_queries(queries, connection)        def _do_write(self, data, engine, connection) -> None:          queries = self.properties.get(self._WRITE_QUERY_BUILDER_KEY)(data)          self.__execute_queries(queries, connection)        def __execute_queries(self, queries, connection) -> None:          if not isinstance(queries, List):              queries = [queries]          for query in queries:              if isinstance(query, str):                  connection.execute(text(query))              else:                  statement = query[0]                  parameters = query[1]                  connection.execute(text(statement), parameters) "}
{"text": "#  # Licensed under the Apache License, Version 2.0 (the \"License\"); you may not use this file except in compliance with  # the License. You may obtain a copy of the License at  #  #        http://www.apache.org/licenses/LICENSE-2.0  #  # Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on  # an \"AS IS\" BASIS, WITHOUT 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": "import os  import uuid  from abc import abstractmethod  from datetime import datetime, timedelta  from typing import Any, Dict, List, Optional, Set, Tuple, Union    import networkx as nx    from taipy.config.common._validate_id import _validate_id  from taipy.config.common.scope import Scope  from taipy.logger._taipy_logger import _TaipyLogger    from .._entity._entity import _Entity  from .._entity._labeled import _Labeled  from .._entity._properties import _Properties  from .._entity._reload import _Reloader, _self_reload, _self_setter  from .._version._version_manager_factory import _VersionManagerFactory  from ..common._warnings import _warn_deprecated  from ..exceptions.exceptions import DataNodeIsBeingEdited, NoData  from ..job.job_id import JobId  from ..notification.event import Event, EventEntityType, EventOperation, _make_event  from ._filter import _FilterDataNode  from .data_node_id import DataNodeId, Edit  from .operator import JoinOperator      class DataNode(_Entity, _Labeled):      \"\"\"Reference to a dataset.        A Data Node is an abstract class that holds metadata related to the dataset it refers to.      In particular, a data node holds the name, the scope, the owner identifier, the last      edit date, and some additional properties of the data.<br/>      A Data Node also contains information and methods needed to access the dataset. This      information depends on the type of storage, and it is held by subclasses (such as      SQL Data Node, CSV Data Node, ...).        !!! note          It is recommended not to instantiate subclasses of `DataNode` directly.        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.          name (str): A user-readable name 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 set of identifiers of the parent tasks.          last_edit_date (datetime): The date and time of the last modification.          edits (List[Edit^]): The list of Edits (an alias for dict) containing metadata about each              data edition including but not limited to timestamp, comments, job_id:              timestamp: The time instant of the writing              comments: Representation of a free text to explain or comment on a data change              job_id: Only populated when the data node is written by a task execution and corresponds to the job's id.              Additional metadata related to the edition made to the data node can also be provided in Edits.          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 the data node is locked for modification. 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.          kwargs: A dictionary of additional properties.      \"\"\"        _ID_PREFIX = \"DATANODE\"      __ID_SEPARATOR = \"_\"      __logger = _TaipyLogger._get_logger()      _REQUIRED_PROPERTIES: List[str] = []      _MANAGER_NAME = \"data\"      __PATH_KEY = \"path\"      __EDIT_TIMEOUT = 30        _TAIPY_PROPERTIES: Set[str] = set()        def __init__(          self,          config_id,          scope: Scope = Scope(Scope.SCENARIO),          id: Optional[DataNodeId] = None,          owner_id: Optional[str] = None,          parent_ids: Optional[Set[str]] = None,          last_edit_date: Optional[datetime] = None,          edits: Optional[List[Edit]] = None,          version: Optional[str] = None,          validity_period: Optional[timedelta] = None,          edit_in_progress: bool = False,          editor_id: Optional[str] = None,          editor_expiration_date: Optional[datetime] = None,          **kwargs,      ):          self.config_id = _validate_id(config_id)          self.id = id or DataNodeId(self.__ID_SEPARATOR.join([self._ID_PREFIX, self.config_id, str(uuid.uuid4())]))          self.owner_id = owner_id          self._parent_ids = parent_ids or set()          self._scope = scope          self._last_edit_date = last_edit_date          self._edit_in_progress = edit_in_progress          self._version = version or _VersionManagerFactory._build_manager()._get_latest_version()          self._validity_period = validity_period          self._editor_id: Optional[str] = editor_id          self._editor_expiration_date: Optional[datetime] = editor_expiration_date            # Track edits          self._edits = edits or list()            self._properties = _Properties(self, **kwargs)        def get_parents(self):          \"\"\"Get all parents of this data node.\"\"\"          from ... import core as tp            return tp.get_parents(self)        @property  # type: ignore      @_self_reload(_MANAGER_NAME)      def parent_ids(self):          \"\"\"List of parent ids of this data node.\"\"\"          return self._parent_ids        @property  # type: ignore      @_self_reload(_MANAGER_NAME)      def edits(self):          \"\"\"Get all `Edit^`s of this data node.\"\"\"          return self._edits        def get_last_edit(self) -> Optional[Edit]:          \"\"\"Get last `Edit^` of this data node.            Returns:              None if there has been no `Edit^` on this data node.          \"\"\"          if self._edits:              return self._edits[-1]          return None        @property  # type: ignore      @_self_reload(_MANAGER_NAME)      def last_edit_date(self):          last_modified_datetime = self.__get_last_modified_datetime()          if last_modified_datetime and last_modified_datetime > self._last_edit_date:              return last_modified_datetime          else:              return self._last_edit_date        @last_edit_date.setter  # type: ignore      @_self_setter(_MANAGER_NAME)      def last_edit_date(self, val):          self._last_edit_date = val        @property  # type: ignore      @_self_reload(_MANAGER_NAME)      def scope(self):          return self._scope        @scope.setter  # type: ignore      @_self_setter(_MANAGER_NAME)      def scope(self, val):          self._scope = val        @property  # type: ignore      @_self_reload(_MANAGER_NAME)      def validity_period(self) -> Optional[timedelta]:          return self._validity_period if self._validity_period else None        @validity_period.setter  # type: ignore      @_self_setter(_MANAGER_NAME)      def validity_period(self, val):          self._validity_period = val        @property  # type: ignore      @_self_reload(_MANAGER_NAME)      def expiration_date(self) -> datetime:          \"\"\"Datetime instant of the expiration date of this data node.\"\"\"          last_edit_date = self.last_edit_date          validity_period = self._validity_period            if not last_edit_date:              raise NoData(f\"Data node {self.id} from config {self.config_id} has not been written yet.\")            return last_edit_date + validity_period if validity_period else last_edit_date        @property  # type: ignore      def name(self) -> Optional[str]:          return self.properties.get(\"name\")        @name.setter  # type: ignore      def name(self, val):          self.properties[\"name\"] = val        @property      def version(self):          return self._version        @property      def cacheable(self):          \"\"\"Deprecated. Use `skippable` attribute of a `Task^` instead.\"\"\"          _warn_deprecated(\"cacheable\", suggest=\"the skippable feature\")          return self.properties.get(\"cacheable\", False)        @cacheable.setter      def cacheable(self, val):          _warn_deprecated(\"cacheable\", suggest=\"the skippable feature\")        @property  # type: ignore      @_self_reload(_MANAGER_NAME)      def edit_in_progress(self):          return self._edit_in_progress        @edit_in_progress.setter  # type: ignore      @_self_setter(_MANAGER_NAME)      def edit_in_progress(self, val):          self._edit_in_progress = val        @property  # type: ignore      @_self_reload(_MANAGER_NAME)      def editor_id(self):          return self._editor_id        @editor_id.setter  # type: ignore      @_self_setter(_MANAGER_NAME)      def editor_id(self, val):          self._editor_id = val        @property  # type: ignore      @_self_reload(_MANAGER_NAME)      def editor_expiration_date(self):          return self._editor_expiration_date        @editor_expiration_date.setter  # type: ignore      @_self_setter(_MANAGER_NAME)      def editor_expiration_date(self, val):          self._editor_expiration_date = val        @property  # type: ignore      @_self_reload(_MANAGER_NAME)      def job_ids(self):          \"\"\"List of the jobs having edited this data node.\"\"\"          return [edit.get(\"job_id\") for edit in self.edits if edit.get(\"job_id\")]        @property      def properties(self):          \"\"\"Dictionary of custom properties.\"\"\"          self._properties = _Reloader()._reload(self._MANAGER_NAME, self)._properties          return self._properties        def _get_user_properties(self) -> Dict[str, Any]:          \"\"\"Get user properties.\"\"\"          return {key: value for key, value in self.properties.items() if key not in self._TAIPY_PROPERTIES}        def __eq__(self, other):          return self.id == other.id        def __ne__(self, other):          return not self == other        def __hash__(self):          return hash(self.id)        def __getstate__(self):          return vars(self)        def __setstate__(self, state):          vars(self).update(state)        def __getattr__(self, attribute_name):          protected_attribute_name = _validate_id(attribute_name)          if protected_attribute_name in self._properties:              return self._properties[protected_attribute_name]          raise AttributeError(f\"{attribute_name} is not an attribute of data node {self.id}\")        def __get_last_modified_datetime(self) -> Optional[datetime]:          path = self._properties.get(self.__PATH_KEY, None)          if path and os.path.isfile(path):              return datetime.fromtimestamp(os.path.getmtime(path))            last_modified_datetime = None          if path and os.path.isdir(path):              for filename in os.listdir(path):                  filepath = os.path.join(path, filename)                  if os.path.isfile(filepath):                      file_mtime = datetime.fromtimestamp(os.path.getmtime(filepath))                        if last_modified_datetime is None or file_mtime > last_modified_datetime:                          last_modified_datetime = file_mtime            return last_modified_datetime        @classmethod      @abstractmethod      def storage_type(cls) -> str:          raise NotImplementedError        def read_or_raise(self) -> Any:          \"\"\"Read the data referenced by this data node.            Returns:              The data referenced by this data node.            Raises:              NoData^: If the data has not been written yet.          \"\"\"          if not self.last_edit_date:              raise NoData(f\"Data node {self.id} from config {self.config_id} has not been written yet.\")          return self._read()        def read(self) -> Any:          \"\"\"Read the data referenced by this data node.            Returns:              The data referenced by this data node. None if the data has not been written yet.          \"\"\"          try:              return self.read_or_raise()          except NoData:              self.__logger.warning(                  f\"Data node {self.id} from config {self.config_id} is being read but has never been \" f\"written.\"              )              return None        def append(self, data, job_id: Optional[JobId] = None, **kwargs: Dict[str, Any]):          \"\"\"Append some data to this data node.            Parameters:              data (Any): The data to write to this data node.              job_id (JobId^): An optional identifier of the writer.              **kwargs (dict[str, any]): Extra information to attach to the edit document                  corresponding to this write.          \"\"\"          from ._data_manager_factory import _DataManagerFactory            self._append(data)          self.track_edit(job_id=job_id, **kwargs)          self.unlock_edit()          _DataManagerFactory._build_manager()._set(self)        def write(self, data, job_id: Optional[JobId] = None, **kwargs: Dict[str, Any]):          \"\"\"Write some data to this data node.            Parameters:              data (Any): The data to write to this data node.              job_id (JobId^): An optional identifier of the writer.              **kwargs (dict[str, any]): Extra information to attach to the edit document                  corresponding to this write.          \"\"\"          from ._data_manager_factory import _DataManagerFactory            self._write(data)          self.track_edit(job_id=job_id, **kwargs)          self.unlock_edit()          _DataManagerFactory._build_manager()._set(self)        def track_edit(self, **options):          \"\"\"Creates and adds a new entry in the edits attribute without writing the data.            Parameters:              options (dict[str, any)): track `timestamp`, `comments`, `job_id`. The others are user-custom, users can                  use options to attach any information to an external edit of a data node.          \"\"\"          edit = {}          for k, v in options.items():              if v is not None:                  edit[k] = v          if \"timestamp\" not in edit:              edit[\"timestamp\"] = datetime.now()          self.last_edit_date = edit.get(\"timestamp\")          self._edits.append(edit)        def lock_edit(self, editor_id: Optional[str] = None):          \"\"\"Lock the data node modification.            Note:              The data node can be unlocked with the method `(DataNode.)unlock_edit()^`.            Parameters:              editor_id (Optional[str]): The editor's identifier.          \"\"\"          if editor_id:              if (                  self.edit_in_progress                  and self.editor_id != editor_id                  and self.editor_expiration_date                  and self.editor_expiration_date > datetime.now()              ):                  raise DataNodeIsBeingEdited(self.id, self._editor_id)              self.editor_id = editor_id  # type: ignore              self.editor_expiration_date = datetime.now() + timedelta(minutes=self.__EDIT_TIMEOUT)  # type: ignore          else:              self.editor_id = None  # type: ignore              self.editor_expiration_date = None  # type: ignore          self.edit_in_progress = True  # type: ignore        def unlock_edit(self, editor_id: Optional[str] = None):          \"\"\"Unlocks the data node modification.            Note:              The data node can be locked with the method `(DataNode.)lock_edit()^`.            Parameters:              editor_id (Optional[str]): The editor's identifier.          \"\"\"          if (              editor_id              and self.editor_id != editor_id              and self.editor_expiration_date              and self.editor_expiration_date > datetime.now()          ):              raise DataNodeIsBeingEdited(self.id, self._editor_id)          else:              self.editor_id = None  # type: ignore              self.editor_expiration_date = None  # type: ignore              self.edit_in_progress = False  # type: ignore        def filter(self, operators: Union[List, Tuple], join_operator=JoinOperator.AND):          \"\"\"Read and filter the data referenced by this data node.            The data is filtered by the provided list of 3-tuples (key, value, `Operator^`).            If multiple filter operators are provided, filtered data will be joined based on the          join operator (*AND* or *OR*).            Parameters:              operators (Union[List[Tuple], Tuple]): A 3-element tuple or a list of 3-element tuples,                  each is in the form of (key, value, `Operator^`).              join_operator (JoinOperator^): The operator used to join the multiple filter                  3-tuples.          Returns:              The filtered data.          Raises:              NotImplementedError: If the data type is not supported.          \"\"\"          data = self._read()          return _FilterDataNode._filter(data, operators, join_operator)        def __getitem__(self, item):          data = self._read()          return _FilterDataNode._filter_by_key(data, item)        @abstractmethod      def _read(self):          raise NotImplementedError        @abstractmethod      def _append(self, data):          raise NotImplementedError        @abstractmethod      def _write(self, data):          raise NotImplementedError        @property  # type: ignore      @_self_reload(_MANAGER_NAME)      def is_ready_for_reading(self) -> bool:          \"\"\"Indicate if this data node is ready for reading.            Returns:              False if the data is locked for modification or if the data has never been written.                  True otherwise.          \"\"\"          if self._edit_in_progress:              return False          if not self._last_edit_date:              # Never been written so it is not up-to-date              return False          return True        @property  # type: ignore      @_self_reload(_MANAGER_NAME)      def is_valid(self) -> bool:          \"\"\"Indicate if this data node is valid.            Returns:              False if the data ever been written or the expiration date has passed.<br/>              True otherwise.          \"\"\"          if not self._last_edit_date:              # Never been written so it is not valid              return False          if not self._validity_period:              # No validity period and has already been written, so it is valid              return True          if datetime.now() > self.expiration_date:              # expiration_date has been passed              return False          return True        @property      def is_up_to_date(self) -> bool:          \"\"\"Indicate if this data node is up-to-date.            Returns:              False if a preceding data node has been updated before the selected data node              or the selected data is invalid.<br/>              True otherwise.          \"\"\"            from ..scenario.scenario import Scenario          from ..taipy import get_parents            parent_scenarios: Set[Scenario] = get_parents(self)[\"scenario\"]  # type: ignore          for parent_scenario in parent_scenarios:              for ancestor_node in nx.ancestors(parent_scenario._build_dag(), self):                  if (                      isinstance(ancestor_node, DataNode)                      and ancestor_node.last_edit_date                      and ancestor_node.last_edit_date > self.last_edit_date                  ):                      return False          return self.is_valid        @staticmethod      def _class_map():          def all_subclasses(cls):              subclasses = set(cls.__subclasses__())              for s in cls.__subclasses__():                  subclasses.update(all_subclasses(s))              return subclasses            class_map = {}          for c in all_subclasses(DataNode):              try:                  if c.storage_type() is not None:                      class_map[c.storage_type()] = c              except NotImplementedError:                  pass            return class_map        def get_label(self) -> str:          \"\"\"Returns the data node simple label prefixed by its owner label.            Returns:              The label of the data node as a string.          \"\"\"          return self._get_label()        def get_simple_label(self) -> str:          \"\"\"Returns the data node simple label.            Returns:              The simple label of the data node as a string.          \"\"\"          return self._get_simple_label()      @_make_event.register(DataNode)  def make_event_for_datanode(      data_node: DataNode,      operation: EventOperation,      /,      attribute_name: Optional[str] = None,      attribute_value: Optional[Any] = None,      **kwargs,  ) -> Event:      metadata = {\"config_id\": data_node.config_id, **kwargs}      return Event(          entity_type=EventEntityType.DATA_NODE,          entity_id=data_node.id,          operation=operation,          attribute_name=attribute_name,          attribute_value=attribute_value,          metadata=metadata,      ) "}
{"text": "import dataclasses  import json  import os  from datetime import date, datetime, timedelta  from enum import Enum  from os.path import isfile  from pydoc import locate  from typing import Any, Dict, List, Optional, Set    from taipy.config.common.scope import Scope    from .._backup._backup import _replace_in_backup_file  from .._entity._reload import _self_reload  from .._version._version_manager_factory import _VersionManagerFactory  from ._abstract_file import _AbstractFileDataNode  from .data_node import DataNode  from .data_node_id import DataNodeId, Edit      class JSONDataNode(DataNode, _AbstractFileDataNode):      \"\"\"Data Node stored as a JSON file.        Attributes:          config_id (str): Identifier of the data node configuration. This string 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.          path (str): The path to the JSON file.          encoder (json.JSONEncoder): The JSON encoder that is used to write into the JSON file.          decoder (json.JSONDecoder): The JSON decoder that is used to read from the JSON file.          properties (dict[str, Any]): A dictionary of additional properties. The _properties_              must have a _\"default_path\"_ or _\"path\"_ entry with the path of the JSON file:                - _\"default_path\"_ `(str)`: The default path of the CSV file.\\n              - _\"encoding\"_ `(str)`: The encoding of the CSV file. The default value is `utf-8`.\\n              - _\"default_data\"_: The default data of the data nodes instantiated from this json data node.\\n      \"\"\"        __STORAGE_TYPE = \"json\"      __DEFAULT_DATA_KEY = \"default_data\"      __DEFAULT_PATH_KEY = \"default_path\"      __PATH_KEY = \"path\"      __ENCODING_KEY = \"encoding\"      _ENCODER_KEY = \"encoder\"      _DECODER_KEY = \"decoder\"      _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: Optional[List[Edit]] = None,          version: Optional[str] = None,          validity_period: Optional[timedelta] = None,          edit_in_progress: bool = False,          editor_id: Optional[str] = None,          editor_expiration_date: Optional[datetime] = None,          properties: Optional[Dict] = None,      ):          if properties is None:              properties = {}            default_value = properties.pop(self.__DEFAULT_DATA_KEY, None)            if self.__ENCODING_KEY not in properties.keys():              properties[self.__ENCODING_KEY] = \"utf-8\"            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,          )          self._path = properties.get(self.__PATH_KEY, properties.get(self.__DEFAULT_PATH_KEY))          if not self._path:              self._path = self._build_path(self.storage_type())          properties[self.__PATH_KEY] = self._path            self._decoder = self._properties.get(self._DECODER_KEY, _DefaultJSONDecoder)          self._encoder = self._properties.get(self._ENCODER_KEY, _DefaultJSONEncoder)            if default_value is not None and not os.path.exists(self._path):              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.\",                      }                  )              )            if not self._last_edit_date and isfile(self._path):  # type: ignore              self._last_edit_date = datetime.now()            self._TAIPY_PROPERTIES.update(              {                  self.__PATH_KEY,                  self.__DEFAULT_PATH_KEY,                  self.__ENCODING_KEY,                  self.__DEFAULT_DATA_KEY,                  self._ENCODER_KEY,                  self._DECODER_KEY,              }          )        @classmethod      def storage_type(cls) -> str:          return cls.__STORAGE_TYPE        @property  # type: ignore      @_self_reload(DataNode._MANAGER_NAME)      def path(self):          return self._path        @path.setter      def path(self, value):          tmp_old_path = self._path          self._path = value          self.properties[self.__PATH_KEY] = value          _replace_in_backup_file(old_file_path=tmp_old_path, new_file_path=self._path)        @property  # type: ignore      @_self_reload(DataNode._MANAGER_NAME)      def encoder(self):          return self._encoder        @encoder.setter      def encoder(self, encoder: json.JSONEncoder):          self.properties[self._ENCODER_KEY] = encoder        @property  # type: ignore      @_self_reload(DataNode._MANAGER_NAME)      def decoder(self):          return self._decoder        @decoder.setter      def decoder(self, decoder: json.JSONDecoder):          self.properties[self._DECODER_KEY] = decoder        def _read(self):          with open(self._path, \"r\", encoding=self.properties[self.__ENCODING_KEY]) as f:              return json.load(f, cls=self._decoder)        def _append(self, data: Any):          with open(self._path, \"r+\", encoding=self.properties[self.__ENCODING_KEY]) as f:              file_data = json.load(f, cls=self._decoder)              if isinstance(file_data, List):                  if isinstance(data, List):                      file_data.extend(data)                  else:                      file_data.append(data)              elif isinstance(data, Dict):                  file_data.update(data)                f.seek(0)              json.dump(file_data, f, indent=4, cls=self._encoder)        def _write(self, data: Any):          with open(self._path, \"w\", encoding=self.properties[self.__ENCODING_KEY]) as f:  # type: ignore              json.dump(data, f, indent=4, cls=self._encoder)      class _DefaultJSONEncoder(json.JSONEncoder):      def default(self, o):          if isinstance(o, Enum):              return {                  \"__type__\": f\"Enum-{o.__class__.__module__}-{o.__class__.__qualname__}-{o.name}\",                  \"__value__\": o.value,              }            if isinstance(o, (datetime, date)):              return {\"__type__\": \"Datetime\", \"__value__\": o.isoformat()}            if dataclasses.is_dataclass(o):              return {                  \"__type__\": f\"dataclass-{o.__class__.__module__}-{o.__class__.__qualname__}\",                  \"__value__\": dataclasses.asdict(o),              }            return super().default(o)      class _DefaultJSONDecoder(json.JSONDecoder):      def __init__(self, *args, **kwargs):          json.JSONDecoder.__init__(self, object_hook=self.object_hook, *args, **kwargs)        def object_hook(self, source):          if _type := source.get(\"__type__\"):              if _type.startswith(\"Enum\"):                  _, module, classname, name = _type.split(\"-\")                  _enum_class = locate(f\"{module}.{classname}\")                  return _enum_class[name]                if _type == \"Datetime\":                  return datetime.fromisoformat(source.get(\"__value__\"))                if _type.startswith(\"dataclass\"):                  _, module, classname = _type.split(\"-\")                  _data_class = locate(f\"{module}.{classname}\")                  return _data_class(**source.get(\"__value__\"))            return source "}
{"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": "import uuid  from datetime import datetime  from typing import Any, List, Optional, Union    from .._entity._entity import _Entity  from .._entity._labeled import _Labeled  from .._entity._reload import _self_reload, _self_setter  from .._version._version_manager_factory import _VersionManagerFactory  from ..job._job_manager_factory import _JobManagerFactory  from ..job.job import Job, JobId  from ..notification.event import Event, EventEntityType, EventOperation, _make_event  from .submission_id import SubmissionId  from .submission_status import SubmissionStatus      class Submission(_Entity, _Labeled):      \"\"\"Hold the jobs and submission status when a Scenario^, Sequence^ or Task^ is submitted.        Attributes:          entity_id (str): The identifier of the entity that was submitted.          id (str): The identifier of the `Submission^` entity.          jobs (Optional[Union[List[Job], List[JobId]]]): A list of jobs.          creation_date (Optional[datetime]): The date of this submission's creation.          submission_status (Optional[SubmissionStatus]): The current status of this submission.          version (Optional[str]): The string indicates the application version of the submission to instantiate.              If not provided, the latest version is used.      \"\"\"        _ID_PREFIX = \"SUBMISSION\"      _MANAGER_NAME = \"submission\"      __SEPARATOR = \"_\"        def __init__(          self,          entity_id: str,          id: Optional[str] = None,          jobs: Optional[Union[List[Job], List[JobId]]] = None,          creation_date: Optional[datetime] = None,          submission_status: Optional[SubmissionStatus] = None,          version: Optional[str] = None,      ):          self._entity_id = entity_id          self.id = id or self.__new_id()          self._jobs: Union[List[Job], List[JobId], List] = jobs or []          self._creation_date = creation_date or datetime.now()          self._submission_status = submission_status or SubmissionStatus.SUBMITTED          self._version = version or _VersionManagerFactory._build_manager()._get_latest_version()        @staticmethod      def __new_id() -> str:          \"\"\"Generate a unique Submission identifier.\"\"\"          return SubmissionId(Submission.__SEPARATOR.join([Submission._ID_PREFIX, str(uuid.uuid4())]))        @property      def entity_id(self) -> str:          return self._entity_id        @property      def creation_date(self):          return self._creation_date        def get_label(self) -> str:          \"\"\"Returns the submission simple label prefixed by its owner label.            Returns:              The label of the submission as a string.          \"\"\"          return self._get_label()        def get_simple_label(self) -> str:          \"\"\"Returns the submission simple label.            Returns:              The simple label of the submission as a string.          \"\"\"          return self._get_simple_label()        @property  # type: ignore      @_self_reload(_MANAGER_NAME)      def jobs(self) -> List[Job]:          jobs = []          job_manager = _JobManagerFactory._build_manager()            for job in self._jobs:              jobs.append(job_manager._get(job))            return jobs        @jobs.setter  # type: ignore      @_self_setter(_MANAGER_NAME)      def jobs(self, jobs: Union[List[Job], List[JobId]]):          self._jobs = jobs        def __hash__(self):          return hash(self.id)        def __eq__(self, other):          return self.id == other.id        @property  # type: ignore      @_self_reload(_MANAGER_NAME)      def submission_status(self):          return self._submission_status        @submission_status.setter  # type: ignore      @_self_setter(_MANAGER_NAME)      def submission_status(self, submission_status):          self._submission_status = submission_status        def __lt__(self, other):          return self.creation_date.timestamp() < other.creation_date.timestamp()        def __le__(self, other):          return self.creation_date.timestamp() <= other.creation_date.timestamp()        def __gt__(self, other):          return self.creation_date.timestamp() > other.creation_date.timestamp()        def __ge__(self, other):          return self.creation_date.timestamp() >= other.creation_date.timestamp()        def _update_submission_status(self, _: Job):          abandoned = False          canceled = False          blocked = False          pending = False          running = False          completed = False            for job in self.jobs:              if not job:                  continue              if job.is_failed():                  self.submission_status = SubmissionStatus.FAILED  # type: ignore                  return              if job.is_canceled():                  canceled = True                  continue              if job.is_blocked():                  blocked = True                  continue              if job.is_pending() or job.is_submitted():                  pending = True                  continue              if job.is_running():                  running = True                  continue              if job.is_completed() or job.is_skipped():                  completed = True                  continue              if job.is_abandoned():                  abandoned = True          if canceled:              self.submission_status = SubmissionStatus.CANCELED  # type: ignore              return          if abandoned:              self.submission_status = SubmissionStatus.UNDEFINED  # type: ignore              return          if running:              self.submission_status = SubmissionStatus.RUNNING  # type: ignore              return          if pending:              self.submission_status = SubmissionStatus.PENDING  # type: ignore              return          if blocked:              self.submission_status = SubmissionStatus.BLOCKED  # type: ignore              return          if completed:              self.submission_status = SubmissionStatus.COMPLETED  # type: ignore              return          self.submission_status = SubmissionStatus.UNDEFINED  # type: ignore      @_make_event.register(Submission)  def _make_event_for_submission(      submission: Submission,      operation: EventOperation,      /,      attribute_name: Optional[str] = None,      attribute_value: Optional[Any] = None,      **kwargs,  ) -> Event:      metadata = {\"creation_date\": submission.creation_date, \"version\": submission._version}      return Event(          entity_type=EventEntityType.SUBMISSION,          entity_id=submission.id,          operation=operation,          attribute_name=attribute_name,          attribute_value=attribute_value,          metadata={**metadata, **kwargs},      ) "}
{"text": "#  # Licensed under the Apache License, Version 2.0 (the \"License\"); you may not use this file except in compliance with  # the License. You may obtain a copy of the License at  #  #        http://www.apache.org/licenses/LICENSE-2.0  #  # Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on  # an \"AS IS\" BASIS, WITHOUT 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._version._version_manager import _VersionManager  from src.taipy.core._version._version_manager_factory import _VersionManagerFactory  from src.taipy.core.common._utils import _load_fct  from src.taipy.core.cycle._cycle_manager import _CycleManager  from src.taipy.core.data._data_manager import _DataManager  from src.taipy.core.exceptions.exceptions import NonExistingVersion  from src.taipy.core.job._job_manager import _JobManager  from src.taipy.core.scenario._scenario_manager import _ScenarioManager  from src.taipy.core.sequence._sequence_manager import _SequenceManager  from src.taipy.core.task._task_manager import _TaskManager  from taipy.config.common.frequency import Frequency  from taipy.config.common.scope import Scope  from taipy.config.config import Config  from tests.core.conftest import init_config, init_managers  from tests.core.utils import assert_true_after_time      def test_core_cli_no_arguments(init_sql_repo):      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()      def test_core_cli_development_mode(init_sql_repo):      with patch(\"sys.argv\", [\"prog\", \"--development\"]):          core = Core()          core.run()          assert Config.core.mode == \"development\"          assert Config.core.version_number == _VersionManagerFactory._build_manager()._get_development_version()          core.stop()      def test_core_cli_dev_mode(init_sql_repo):      with patch(\"sys.argv\", [\"prog\", \"-dev\"]):          core = Core()          core.run()          assert Config.core.mode == \"development\"          assert Config.core.version_number == _VersionManagerFactory._build_manager()._get_development_version()          core.stop()      def test_core_cli_experiment_mode(init_sql_repo):      with patch(\"sys.argv\", [\"prog\", \"--experiment\"]):          core = Core()          core.run()          assert Config.core.mode == \"experiment\"          assert Config.core.version_number == _VersionManagerFactory._build_manager()._get_latest_version()          assert not Config.core.force          core.stop()      def test_core_cli_experiment_mode_with_version(init_sql_repo):      with patch(\"sys.argv\", [\"prog\", \"--experiment\", \"2.1\"]):          core = Core()          core.run()          assert Config.core.mode == \"experiment\"          assert Config.core.version_number == \"2.1\"          assert not Config.core.force          core.stop()      def test_core_cli_experiment_mode_with_force_version(init_sql_repo):      with patch(\"sys.argv\", [\"prog\", \"--experiment\", \"2.1\", \"--taipy-force\"]):          core = Core()          core.run()          assert Config.core.mode == \"experiment\"          assert Config.core.version_number == \"2.1\"          assert Config.core.force          core.stop()      def test_core_cli_production_mode(init_sql_repo):      with patch(\"sys.argv\", [\"prog\", \"--production\"]):          core = Core()          core.run()          assert Config.core.mode == \"production\"          assert Config.core.version_number == _VersionManagerFactory._build_manager()._get_latest_version()          assert not Config.core.force          core.stop()      def test_dev_mode_clean_all_entities_of_the_latest_version(init_sql_repo):      scenario_config = config_scenario()      init_managers()        # Create a scenario in development mode      with patch(\"sys.argv\", [\"prog\"]):          core = Core()          core.run()          scenario = _ScenarioManager._create(scenario_config)          _ScenarioManager._submit(scenario)          core.stop()            # Initial assertion          assert len(_DataManager._get_all(version_number=\"all\")) == 2          assert len(_TaskManager._get_all(version_number=\"all\")) == 1          assert len(_SequenceManager._get_all(version_number=\"all\")) == 1          assert len(_ScenarioManager._get_all(version_number=\"all\")) == 1          assert len(_CycleManager._get_all(version_number=\"all\")) == 1          assert len(_JobManager._get_all(version_number=\"all\")) == 1        # Create a new scenario in experiment mode      with patch(\"sys.argv\", [\"prog\", \"--experiment\"]):          core = Core()          core.run()          scenario = _ScenarioManager._create(scenario_config)          _ScenarioManager._submit(scenario)          core.stop()            # Assert number of entities in 2nd version          assert len(_DataManager._get_all(version_number=\"all\")) == 4          assert len(_TaskManager._get_all(version_number=\"all\")) == 2          assert len(_SequenceManager._get_all(version_number=\"all\")) == 2          assert len(_ScenarioManager._get_all(version_number=\"all\")) == 2          assert (              len(_CycleManager._get_all(version_number=\"all\")) == 1          )  # No new cycle is created since old dev version use the same cycle          assert len(_JobManager._get_all(version_number=\"all\")) == 2        # Run development mode again      with patch(\"sys.argv\", [\"prog\", \"--development\"]):          core = Core()          core.run()            # The 1st dev version should be deleted run with development mode          assert len(_DataManager._get_all(version_number=\"all\")) == 2          assert len(_TaskManager._get_all(version_number=\"all\")) == 1          assert len(_SequenceManager._get_all(version_number=\"all\")) == 1          assert len(_ScenarioManager._get_all(version_number=\"all\")) == 1          assert len(_CycleManager._get_all(version_number=\"all\")) == 1          assert len(_JobManager._get_all(version_number=\"all\")) == 1            # Submit new dev version          scenario = _ScenarioManager._create(scenario_config)          _ScenarioManager._submit(scenario)            # Assert number of entities with 1 dev version and 1 exp version          assert len(_DataManager._get_all(version_number=\"all\")) == 4          assert len(_TaskManager._get_all(version_number=\"all\")) == 2          assert len(_SequenceManager._get_all(version_number=\"all\")) == 2          assert len(_ScenarioManager._get_all(version_number=\"all\")) == 2          assert len(_CycleManager._get_all(version_number=\"all\")) == 1          assert len(_JobManager._get_all(version_number=\"all\")) == 2            # Assert number of entities of the latest version only          assert len(_DataManager._get_all(version_number=\"latest\")) == 2          assert len(_TaskManager._get_all(version_number=\"latest\")) == 1          assert len(_SequenceManager._get_all(version_number=\"latest\")) == 1          assert len(_ScenarioManager._get_all(version_number=\"latest\")) == 1          assert len(_JobManager._get_all(version_number=\"latest\")) == 1            # Assert number of entities of the development version only          assert len(_DataManager._get_all(version_number=\"development\")) == 2          assert len(_TaskManager._get_all(version_number=\"development\")) == 1          assert len(_SequenceManager._get_all(version_number=\"development\")) == 1          assert len(_ScenarioManager._get_all(version_number=\"development\")) == 1          assert len(_JobManager._get_all(version_number=\"development\")) == 1            # Assert number of entities of an unknown version          with pytest.raises(NonExistingVersion):              assert _DataManager._get_all(version_number=\"foo\")          with pytest.raises(NonExistingVersion):              assert _TaskManager._get_all(version_number=\"foo\")          with pytest.raises(NonExistingVersion):              assert _SequenceManager._get_all(version_number=\"foo\")          with pytest.raises(NonExistingVersion):              assert _ScenarioManager._get_all(version_number=\"foo\")          with pytest.raises(NonExistingVersion):              assert _JobManager._get_all(version_number=\"foo\")          core.stop()      def twice_doppelganger(a):      return a * 2      def test_dev_mode_clean_all_entities_when_config_is_alternated(init_sql_repo):      data_node_1_config = Config.configure_data_node(          id=\"d1\", storage_type=\"pickle\", default_data=\"abc\", scope=Scope.SCENARIO      )      data_node_2_config = Config.configure_data_node(id=\"d2\", storage_type=\"csv\", default_path=\"foo.csv\")      task_config = Config.configure_task(\"my_task\", twice_doppelganger, data_node_1_config, data_node_2_config)      scenario_config = Config.configure_scenario(\"my_scenario\", [task_config], frequency=Frequency.DAILY)        # Create a scenario in development mode with the doppelganger function      with patch(\"sys.argv\", [\"prog\"]):          core = Core()          core.run()          scenario = _ScenarioManager._create(scenario_config)          _ScenarioManager._submit(scenario)          core.stop()        # Delete the twice_doppelganger function      # and clear cache of _load_fct() to simulate a new run      del globals()[\"twice_doppelganger\"]      _load_fct.cache_clear()        # Create a scenario in development mode with another function      scenario_config = config_scenario()      with patch(\"sys.argv\", [\"prog\"]):          core = Core()          core.run()          scenario = _ScenarioManager._create(scenario_config)          _ScenarioManager._submit(scenario)          core.stop()      def test_version_number_when_switching_mode(init_sql_repo):      with patch(\"sys.argv\", [\"prog\", \"--development\"]):          core = Core()          core.run()          ver_1 = _VersionManager._get_latest_version()          ver_dev = _VersionManager._get_development_version()          assert ver_1 == ver_dev          assert len(_VersionManager._get_all()) == 1          core.stop()        # Run with dev mode, the version number is the same      with patch(\"sys.argv\", [\"prog\", \"--development\"]):          core = Core()          core.run()          ver_2 = _VersionManager._get_latest_version()          assert ver_2 == ver_dev          assert len(_VersionManager._get_all()) == 1          core.stop()        # When run with experiment mode, a new version is created      with patch(\"sys.argv\", [\"prog\", \"--experiment\"]):          core = Core()          core.run()          ver_3 = _VersionManager._get_latest_version()          assert ver_3 != ver_dev          assert len(_VersionManager._get_all()) == 2          core.stop()        with patch(\"sys.argv\", [\"prog\", \"--experiment\", \"2.1\"]):          core = Core()          core.run()          ver_4 = _VersionManager._get_latest_version()          assert ver_4 == \"2.1\"          assert len(_VersionManager._get_all()) == 3          core.stop()        with patch(\"sys.argv\", [\"prog\", \"--experiment\"]):          core = Core()          core.run()          ver_5 = _VersionManager._get_latest_version()          assert ver_5 != ver_3          assert ver_5 != ver_4          assert ver_5 != ver_dev          assert len(_VersionManager._get_all()) == 4          core.stop()        # When run with production mode, the latest version is used as production      with patch(\"sys.argv\", [\"prog\", \"--production\"]):          core = Core()          core.run()          ver_6 = _VersionManager._get_latest_version()          production_versions = _VersionManager._get_production_versions()          assert ver_6 == ver_5          assert production_versions == [ver_6]          assert len(_VersionManager._get_all()) == 4          core.stop()        # When run with production mode, the \"2.1\" version is used as production      with patch(\"sys.argv\", [\"prog\", \"--production\", \"2.1\"]):          core = Core()          core.run()          ver_7 = _VersionManager._get_latest_version()          production_versions = _VersionManager._get_production_versions()          assert ver_7 == \"2.1\"          assert production_versions == [ver_7, ver_6]          assert len(_VersionManager._get_all()) == 4          core.stop()        # Run with dev mode, the version number is the same as the first dev version to overide it      with patch(\"sys.argv\", [\"prog\", \"--development\"]):          core = Core()          core.run()          ver_7 = _VersionManager._get_latest_version()          assert ver_1 == ver_7          assert len(_VersionManager._get_all()) == 4          core.stop()      def test_production_mode_load_all_entities_from_previous_production_version(init_sql_repo):      scenario_config = config_scenario()      init_managers()        with patch(\"sys.argv\", [\"prog\", \"--development\"]):          core = Core()          core.run()          scenario = _ScenarioManager._create(scenario_config)          _ScenarioManager._submit(scenario)          core.stop()        with patch(\"sys.argv\", [\"prog\", \"--production\", \"1.0\"]):          core = Core()          core.run()          production_ver_1 = _VersionManager._get_latest_version()          assert _VersionManager._get_production_versions() == [production_ver_1]          # When run production mode on a new app, a dev version is created alongside          assert _VersionManager._get_development_version() not in _VersionManager._get_production_versions()          assert len(_VersionManager._get_all()) == 2            scenario = _ScenarioManager._create(scenario_config)          _ScenarioManager._submit(scenario)            assert len(_DataManager._get_all()) == 2          assert len(_TaskManager._get_all()) == 1          assert len(_SequenceManager._get_all()) == 1          assert len(_ScenarioManager._get_all()) == 1          assert len(_CycleManager._get_all()) == 1          assert len(_JobManager._get_all()) == 1          core.stop()        with patch(\"sys.argv\", [\"prog\", \"--production\", \"2.0\"]):          core = Core()          core.run()          production_ver_2 = _VersionManager._get_latest_version()          assert _VersionManager._get_production_versions() == [production_ver_1, production_ver_2]          assert len(_VersionManager._get_all()) == 3            # All entities from previous production version should be saved          scenario = _ScenarioManager._create(scenario_config)          _ScenarioManager._submit(scenario)            assert len(_DataManager._get_all()) == 4          assert len(_TaskManager._get_all()) == 2          assert len(_SequenceManager._get_all()) == 2          assert len(_ScenarioManager._get_all()) == 2          assert len(_CycleManager._get_all()) == 1          assert len(_JobManager._get_all()) == 2          core.stop()      def test_force_override_experiment_version(init_sql_repo):      scenario_config = config_scenario()      init_managers()        with patch(\"sys.argv\", [\"prog\", \"--experiment\", \"1.0\"]):          core = Core()          core.run()          ver_1 = _VersionManager._get_latest_version()          assert ver_1 == \"1.0\"          # When create new experiment version, a development version entity is also created as a placeholder          assert len(_VersionManager._get_all()) == 2  # 2 version include 1 experiment 1 development            scenario = _ScenarioManager._create(scenario_config)          _ScenarioManager._submit(scenario)            assert len(_DataManager._get_all()) == 2          assert len(_TaskManager._get_all()) == 1          assert len(_SequenceManager._get_all()) == 1          assert len(_ScenarioManager._get_all()) == 1          assert len(_CycleManager._get_all()) == 1          assert len(_JobManager._get_all()) == 1          core.stop()        Config.configure_global_app(foo=\"bar\")        # Without --taipy-force parameter, a SystemExit will be raised      with pytest.raises(SystemExit):          with patch(\"sys.argv\", [\"prog\", \"--experiment\", \"1.0\"]):              core = Core()              core.run()      core.stop()        # With --taipy-force parameter      with patch(\"sys.argv\", [\"prog\", \"--experiment\", \"1.0\", \"--taipy-force\"]):          core = Core()          core.run()          core.stop()      ver_2 = _VersionManager._get_latest_version()      assert ver_2 == \"1.0\"      assert len(_VersionManager._get_all()) == 2  # 2 version include 1 experiment 1 development        # All entities from previous submit should be saved      scenario = _ScenarioManager._create(scenario_config)      _ScenarioManager._submit(scenario)        assert len(_DataManager._get_all()) == 4      assert len(_TaskManager._get_all()) == 2      assert len(_SequenceManager._get_all()) == 2      assert len(_ScenarioManager._get_all()) == 2      assert len(_CycleManager._get_all()) == 1      assert len(_JobManager._get_all()) == 2      def test_force_override_production_version(init_sql_repo):      scenario_config = config_scenario()      init_managers()        with patch(\"sys.argv\", [\"prog\", \"--production\", \"1.0\"]):          core = Core()          core.run()          ver_1 = _VersionManager._get_latest_version()          production_versions = _VersionManager._get_production_versions()          assert ver_1 == \"1.0\"          assert production_versions == [\"1.0\"]          # When create new production version, a development version entity is also created as a placeholder          assert len(_VersionManager._get_all()) == 2  # 2 version include 1 production 1 development            scenario = _ScenarioManager._create(scenario_config)          _ScenarioManager._submit(scenario)            assert len(_DataManager._get_all()) == 2          assert len(_TaskManager._get_all()) == 1          assert len(_SequenceManager._get_all()) == 1          assert len(_ScenarioManager._get_all()) == 1          assert len(_CycleManager._get_all()) == 1          assert len(_JobManager._get_all()) == 1          core.stop()        Config.configure_global_app(foo=\"bar\")        # Without --taipy-force parameter, a SystemExit will be raised      with pytest.raises(SystemExit):          with patch(\"sys.argv\", [\"prog\", \"--production\", \"1.0\"]):              core = Core()              core.run()      core.stop()        # With --taipy-force parameter      with patch(\"sys.argv\", [\"prog\", \"--production\", \"1.0\", \"--taipy-force\"]):          core = Core()          core.run()          ver_2 = _VersionManager._get_latest_version()          assert ver_2 == \"1.0\"          assert len(_VersionManager._get_all()) == 2  # 2 version include 1 production 1 development            # All entities from previous submit should be saved          scenario = _ScenarioManager._create(scenario_config)          _ScenarioManager._submit(scenario)            assert len(_DataManager._get_all()) == 4          assert len(_TaskManager._get_all()) == 2          assert len(_SequenceManager._get_all()) == 2          assert len(_ScenarioManager._get_all()) == 2          assert len(_CycleManager._get_all()) == 1          assert len(_JobManager._get_all()) == 2          core.stop()      def test_modify_config_properties_without_force(caplog, init_sql_repo):      scenario_config = config_scenario()      init_managers()        with patch(\"sys.argv\", [\"prog\", \"--experiment\", \"1.0\"]):          core = Core()          core.run()          scenario = _ScenarioManager._create(scenario_config)          _ScenarioManager._submit(scenario)          core.stop()        init_config()      Config.configure_core(repository_type=\"sql\", repository_properties={\"db_location\": init_sql_repo})        scenario_config_2 = config_scenario_2()        with pytest.raises(SystemExit):          with patch(\"sys.argv\", [\"prog\", \"--experiment\", \"1.0\"]):              core = Core()              core.run()              scenario = _ScenarioManager._create(scenario_config_2)              _ScenarioManager._submit(scenario)      core.stop()        error_message = str(caplog.text)        assert 'DATA_NODE \"d3\" was added' in error_message        assert 'DATA_NODE \"d0\" was removed' in error_message        assert 'DATA_NODE \"d2\" has attribute \"default_path\" modified' in error_message      assert 'CORE \"root_folder\" was modified' in error_message      assert 'JOB \"mode\" was modified' in error_message      assert 'JOB \"max_nb_of_workers\" was modified' in error_message      assert 'SCENARIO \"my_scenario\" has attribute \"frequency\" modified' in error_message      assert 'SCENARIO \"my_scenario\" has attribute \"tasks\" modified' in error_message      assert 'TASK \"my_task\" has attribute \"inputs\" modified' in error_message      assert 'TASK \"my_task\" has attribute \"function\" modified' in error_message      assert 'TASK \"my_task\" has attribute \"outputs\" modified' in error_message      assert 'DATA_NODE \"d2\" has attribute \"has_header\" modified' in error_message      assert 'DATA_NODE \"d2\" has attribute \"exposed_type\" modified' in error_message      def test_modify_job_configuration_dont_stop_application(caplog, init_sql_repo):      scenario_config = config_scenario()      init_managers()        with patch(\"sys.argv\", [\"prog\", \"--experiment\", \"1.0\"]):          Config.configure_job_executions(mode=\"development\")          core = Core()          core.run(force_restart=True)          scenario = _ScenarioManager._create(scenario_config)          jobs = _ScenarioManager._submit(scenario)          assert all([job.is_finished() for job in jobs])          core.stop()        init_config()      Config.configure_core(repository_type=\"sql\", repository_properties={\"db_location\": init_sql_repo})        scenario_config = config_scenario()        with patch(\"sys.argv\", [\"prog\", \"--experiment\", \"1.0\"]):          Config.configure_job_executions(mode=\"standalone\", max_nb_of_workers=2)          core = Core()          core.run(force_restart=True)          scenario = _ScenarioManager._create(scenario_config)            jobs = _ScenarioManager._submit(scenario)          assert_true_after_time(lambda: all(job.is_finished() for job in jobs))          error_message = str(caplog.text)          assert 'JOB \"mode\" was modified' in error_message          assert 'JOB \"max_nb_of_workers\" was modified' in error_message          core.stop()          assert_true_after_time(lambda: core._dispatcher is None)      def twice(a):      return a * 2      def config_scenario():      Config.configure_data_node(id=\"d0\")      data_node_1_config = Config.configure_data_node(          id=\"d1\", storage_type=\"pickle\", default_data=\"abc\", scope=Scope.SCENARIO      )      data_node_2_config = Config.configure_data_node(id=\"d2\", storage_type=\"csv\", default_path=\"foo.csv\")      task_config = Config.configure_task(\"my_task\", twice, data_node_1_config, data_node_2_config)      scenario_config = Config.configure_scenario(\"my_scenario\", [task_config], frequency=Frequency.DAILY)      scenario_config.add_sequences({\"my_sequence\": [task_config]})        return scenario_config      def double_twice(a):      return a * 2, a * 2      def config_scenario_2():      Config.configure_core(          root_folder=\"foo_root\",          # Changing the \"storage_folder\" will fail since older versions are stored in older folder          # storage_folder=\"foo_storage\",      )      Config.configure_job_executions(mode=\"standalone\", max_nb_of_workers=5)      data_node_1_config = Config.configure_data_node(          id=\"d1\", storage_type=\"pickle\", default_data=\"abc\", scope=Scope.SCENARIO      )      # Modify properties of \"d2\"      data_node_2_config = Config.configure_data_node(          id=\"d2\", storage_type=\"csv\", default_path=\"bar.csv\", has_header=False, exposed_type=\"numpy\"      )      # Add new data node \"d3\"      data_node_3_config = Config.configure_data_node(          id=\"d3\", storage_type=\"csv\", default_path=\"baz.csv\", has_header=False, exposed_type=\"numpy\"      )      # Modify properties of \"my_task\", including the function and outputs list      Config.configure_task(\"my_task\", double_twice, data_node_3_config, [data_node_1_config, data_node_2_config])      task_config_1 = Config.configure_task(\"my_task_1\", double_twice, data_node_3_config, [data_node_2_config])      # Modify properties of \"my_scenario\", where tasks is now my_task_1      scenario_config = Config.configure_scenario(\"my_scenario\", [task_config_1], frequency=Frequency.MONTHLY)      scenario_config.add_sequences({\"my_sequence\": [task_config_1]})        return scenario_config "}
{"text": "import os  import pickle  import shutil  from datetime import datetime  from queue import Queue    import pandas as pd  import pytest  from sqlalchemy import create_engine, text    from src.taipy.core._core import Core  from src.taipy.core._orchestrator._orchestrator_factory import _OrchestratorFactory  from src.taipy.core._repository.db._sql_connection import _SQLConnection  from src.taipy.core._version._version import _Version  from src.taipy.core._version._version_manager_factory import _VersionManagerFactory  from src.taipy.core.config import (      CoreSection,      DataNodeConfig,      JobConfig,      MigrationConfig,      ScenarioConfig,      TaskConfig,      _ConfigIdChecker,      _CoreSectionChecker,      _DataNodeConfigChecker,      _JobConfigChecker,      _ScenarioConfigChecker,      _TaskConfigChecker,  )  from src.taipy.core.cycle._cycle_manager_factory import _CycleManagerFactory  from src.taipy.core.cycle._cycle_model import _CycleModel  from src.taipy.core.cycle.cycle import Cycle  from src.taipy.core.cycle.cycle_id import CycleId  from src.taipy.core.data._data_manager_factory import _DataManagerFactory  from src.taipy.core.data._data_model import _DataNodeModel  from src.taipy.core.data.in_memory import InMemoryDataNode  from src.taipy.core.job._job_manager_factory import _JobManagerFactory  from src.taipy.core.job.job import Job  from src.taipy.core.job.job_id import JobId  from src.taipy.core.notification.notifier import Notifier  from src.taipy.core.scenario._scenario_manager_factory import _ScenarioManagerFactory  from src.taipy.core.scenario._scenario_model import _ScenarioModel  from src.taipy.core.scenario.scenario import Scenario  from src.taipy.core.scenario.scenario_id import ScenarioId  from src.taipy.core.sequence._sequence_manager_factory import _SequenceManagerFactory  from src.taipy.core.sequence.sequence import Sequence  from src.taipy.core.sequence.sequence_id import SequenceId  from src.taipy.core.submission._submission_manager_factory import _SubmissionManagerFactory  from src.taipy.core.submission._submission_model import _SubmissionModel  from src.taipy.core.task._task_manager_factory import _TaskManagerFactory  from src.taipy.core.task.task import Task  from taipy.config import _inject_section  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.config.common.frequency import Frequency  from taipy.config.common.scope import Scope  from taipy.config.config import Config    current_time = datetime.now()  _OrchestratorFactory._build_orchestrator()      @pytest.fixture(scope=\"function\")  def csv_file(tmpdir_factory) -> str:      csv = pd.DataFrame([{\"a\": 1, \"b\": 2, \"c\": 3}, {\"a\": 4, \"b\": 5, \"c\": 6}])      fn = tmpdir_factory.mktemp(\"data\").join(\"df.csv\")      csv.to_csv(str(fn), index=False)      return fn.strpath      @pytest.fixture(scope=\"function\")  def excel_file(tmpdir_factory) -> str:      excel = pd.DataFrame([{\"a\": 1, \"b\": 2, \"c\": 3}, {\"a\": 4, \"b\": 5, \"c\": 6}])      fn = tmpdir_factory.mktemp(\"data\").join(\"df.xlsx\")      excel.to_excel(str(fn), index=False)      return fn.strpath      @pytest.fixture(scope=\"function\")  def excel_file_with_sheet_name(tmpdir_factory) -> str:      excel = pd.DataFrame([{\"a\": 1, \"b\": 2, \"c\": 3}, {\"a\": 4, \"b\": 5, \"c\": 6}])      fn = tmpdir_factory.mktemp(\"data\").join(\"df.xlsx\")      excel.to_excel(str(fn), sheet_name=\"sheet_name\", index=False)      return fn.strpath      @pytest.fixture(scope=\"function\")  def json_file(tmpdir_factory) -> str:      json_data = pd.DataFrame([{\"a\": 1, \"b\": 2, \"c\": 3}, {\"a\": 4, \"b\": 5, \"c\": 6}])      fn = tmpdir_factory.mktemp(\"data\").join(\"df.json\")      json_data.to_json(str(fn), orient=\"records\")      return fn.strpath      @pytest.fixture(scope=\"function\")  def excel_file_with_multi_sheet(tmpdir_factory) -> str:      excel_multi_sheet = {          \"Sheet1\": pd.DataFrame([{\"a\": 1, \"b\": 2, \"c\": 3}, {\"a\": 4, \"b\": 5, \"c\": 6}]),          \"Sheet2\": pd.DataFrame([{\"a\": 7, \"b\": 8, \"c\": 9}, {\"a\": 10, \"b\": 11, \"c\": 12}]),      }      fn = tmpdir_factory.mktemp(\"data\").join(\"df.xlsx\")        with pd.ExcelWriter(str(fn)) as writer:          for key in excel_multi_sheet.keys():              excel_multi_sheet[key].to_excel(writer, key, index=False)        return fn.strpath      @pytest.fixture(scope=\"function\")  def pickle_file_path(tmpdir_factory) -> str:      data = pd.DataFrame([{\"a\": 1, \"b\": 2, \"c\": 3}, {\"a\": 4, \"b\": 5, \"c\": 6}])      fn = tmpdir_factory.mktemp(\"data\").join(\"df.p\")      with open(str(fn), \"wb\") as f:          pickle.dump(data, f)      return fn.strpath      @pytest.fixture(scope=\"function\")  def parquet_file_path(tmpdir_factory) -> str:      data = pd.DataFrame([{\"a\": 1, \"b\": 2, \"c\": 3}, {\"a\": 4, \"b\": 5, \"c\": 6}])      fn = tmpdir_factory.mktemp(\"data\").join(\"df.parquet\")      data.to_parquet(str(fn))      return fn.strpath      @pytest.fixture(scope=\"function\")  def tmp_sqlite_db_file_path(tmpdir_factory):      fn = tmpdir_factory.mktemp(\"data\")      db_name = \"df\"      file_extension = \".db\"      db = create_engine(\"sqlite:///\" + os.path.join(fn.strpath, f\"{db_name}{file_extension}\"))      conn = db.connect()      conn.execute(text(\"CREATE TABLE example (foo int, bar int);\"))      conn.execute(text(\"INSERT INTO example (foo, bar) VALUES (1, 2);\"))      conn.execute(text(\"INSERT INTO example (foo, bar) VALUES (3, 4);\"))      conn.commit()      conn.close()      db.dispose()        return fn.strpath, db_name, file_extension      @pytest.fixture(scope=\"function\")  def tmp_sqlite_sqlite3_file_path(tmpdir_factory):      fn = tmpdir_factory.mktemp(\"data\")      db_name = \"df\"      file_extension = \".sqlite3\"        db = create_engine(\"sqlite:///\" + os.path.join(fn.strpath, f\"{db_name}{file_extension}\"))      conn = db.connect()      conn.execute(text(\"CREATE TABLE example (foo int, bar int);\"))      conn.execute(text(\"INSERT INTO example (foo, bar) VALUES (1, 2);\"))      conn.execute(text(\"INSERT INTO example (foo, bar) VALUES (3, 4);\"))      conn.commit()      conn.close()      db.dispose()        return fn.strpath, db_name, file_extension      @pytest.fixture(scope=\"function\")  def default_data_frame():      return pd.DataFrame([{\"a\": 1, \"b\": 2, \"c\": 3}, {\"a\": 4, \"b\": 5, \"c\": 6}])      @pytest.fixture(scope=\"function\")  def default_multi_sheet_data_frame():      return {          \"Sheet1\": pd.DataFrame([{\"a\": 1, \"b\": 2, \"c\": 3}, {\"a\": 4, \"b\": 5, \"c\": 6}]),          \"Sheet2\": pd.DataFrame([{\"a\": 7, \"b\": 8, \"c\": 9}, {\"a\": 10, \"b\": 11, \"c\": 12}]),      }      @pytest.fixture(scope=\"session\", autouse=True)  def cleanup_files():      yield        if os.path.exists(\".data\"):          shutil.rmtree(\".data\", ignore_errors=True)      if os.path.exists(\".my_data\"):          shutil.rmtree(\".my_data\", ignore_errors=True)      @pytest.fixture(scope=\"function\")  def current_datetime():      return current_time      @pytest.fixture(scope=\"function\")  def scenario(cycle):      return Scenario(          \"sc\",          set(),          {},          set(),          ScenarioId(\"sc_id\"),          current_time,          is_primary=False,          tags={\"foo\"},          version=\"random_version_number\",          cycle=None,      )      @pytest.fixture(scope=\"function\")  def data_node():      return InMemoryDataNode(\"data_node_config_id\", Scope.SCENARIO, version=\"random_version_number\")      @pytest.fixture(scope=\"function\")  def data_node_model():      return _DataNodeModel(          \"my_dn_id\",          \"test_data_node\",          Scope.SCENARIO,          \"csv\",          \"name\",          \"owner_id\",          list({\"parent_id_1\", \"parent_id_2\"}),          datetime(1985, 10, 14, 2, 30, 0).isoformat(),          [dict(timestamp=datetime(1985, 10, 14, 2, 30, 0).isoformat(), job_id=\"job_id\")],          \"latest\",          None,          None,          False,          {\"path\": \"/path\", \"has_header\": True, \"prop\": \"ENV[FOO]\", \"exposed_type\": \"pandas\"},      )      @pytest.fixture(scope=\"function\")  def task(data_node):      dn = InMemoryDataNode(\"dn_config_id\", Scope.SCENARIO, version=\"random_version_number\")      return Task(\"task_config_id\", {}, print, [data_node], [dn])      @pytest.fixture(scope=\"function\")  def scenario_model(cycle):      return _ScenarioModel(          ScenarioId(\"sc_id\"),          \"sc\",          set(),          set(),          {},          creation_date=current_time.isoformat(),          primary_scenario=False,          subscribers=[],          tags=[\"foo\"],          version=\"random_version_number\",          cycle=None,      )      @pytest.fixture(scope=\"function\")  def cycle():      example_date = datetime.fromisoformat(\"2021-11-11T11:11:01.000001\")      return Cycle(          Frequency.DAILY,          {},          creation_date=example_date,          start_date=example_date,          end_date=example_date,          name=\"cc\",          id=CycleId(\"cc_id\"),      )      @pytest.fixture(scope=\"class\")  def sequence():      return Sequence(          {},          [],          SequenceId(\"sequence_id\"),          owner_id=\"owner_id\",          parent_ids=set([\"parent_id_1\", \"parent_id_2\"]),          version=\"random_version_number\",      )      @pytest.fixture(scope=\"function\")  def job(task):      return Job(JobId(\"job\"), task, \"foo\", \"bar\", version=\"random_version_number\")      @pytest.fixture(scope=\"function\")  def _version():      return _Version(id=\"foo\", config=Config._applied_config)      @pytest.fixture(scope=\"function\")  def cycle_model():      return _CycleModel(          CycleId(\"cc_id\"),          \"cc\",          Frequency.DAILY,          {},          creation_date=\"2021-11-11T11:11:01.000001\",          start_date=\"2021-11-11T11:11:01.000001\",          end_date=\"2021-11-11T11:11:01.000001\",      )      @pytest.fixture(scope=\"function\")  def tmp_sqlite(tmpdir_factory):      fn = tmpdir_factory.mktemp(\"db\")      return os.path.join(fn.strpath, \"test.db\")      @pytest.fixture(scope=\"function\", autouse=True)  def clean_repository():      from sqlalchemy.orm import close_all_sessions        close_all_sessions()      init_config()      init_orchestrator()      init_managers()      init_config()      init_notifier()        yield      def init_config():      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()      _Checker._checkers = []        _inject_section(          JobConfig, \"job_config\", JobConfig(\"development\"), [(\"configure_job_executions\", JobConfig._configure)], True      )      _inject_section(          CoreSection,          \"core\",          CoreSection.default_config(),          [(\"configure_core\", CoreSection._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_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)],          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)        Config.configure_core(read_entity_retry=0)      Core._is_running = False      def init_managers():      _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()      _SubmissionManagerFactory._build_manager()._delete_all()      def init_orchestrator():      if _OrchestratorFactory._orchestrator is None:          _OrchestratorFactory._build_orchestrator()      _OrchestratorFactory._build_dispatcher()      _OrchestratorFactory._orchestrator.jobs_to_run = Queue()      _OrchestratorFactory._orchestrator.blocked_jobs = []      def init_notifier():      Notifier._topics_registrations_list = {}      @pytest.fixture  def sql_engine():      return create_engine(\"sqlite:///:memory:\")      @pytest.fixture  def init_sql_repo(tmp_sqlite):      Config.configure_core(repository_type=\"sql\", repository_properties={\"db_location\": tmp_sqlite})        # Clean SQLite database      if _SQLConnection._connection:          _SQLConnection._connection.close()          _SQLConnection._connection = None      _SQLConnection.init_db()        return tmp_sqlite "}
{"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": "import os  import pathlib  from time import sleep  from unittest.mock import patch    import pandas as pd    import src.taipy.core.taipy as tp  from src.taipy.core import Core, Status  from src.taipy.core._orchestrator._orchestrator_factory import _OrchestratorFactory  from src.taipy.core.config.job_config import JobConfig  from taipy.config import Config    # ################################  USER FUNCTIONS  ##################################      def sum(a, b):      a = a[\"number\"]      b = b[\"number\"]      return a + b      def subtract(a, b):      a = a[\"number\"]      b = b[\"number\"]      return a - b      def mult(a, b):      return a * b      def mult_by_2(a):      return a      def divide(a, b):      return a / b      def average(a):      return [a.sum() / len(a)]      def div_constant_with_sleep(a):      sleep(1)      return a[\"number\"] / 10      def return_a_number():      return 10      def return_a_number_with_sleep():      sleep(1)      return 10      # ################################  TEST METHODS    ##################################      def test_skipped_jobs():      Config.configure_job_executions(mode=JobConfig._DEVELOPMENT_MODE)      _OrchestratorFactory._build_orchestrator()      input_config = Config.configure_data_node(\"input\")      intermediate_config = Config.configure_data_node(\"intermediate\")      output_config = Config.configure_data_node(\"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_config_1, task_config_2])        with patch(\"sys.argv\", [\"prog\"]):          core = Core()          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          core.stop()      def test_complex():      # d1 --- t1      # |      # | --- t2 --- d5 --- |                   t10 --- d12      #        |            |                   |      #        |            |                   |      #        d2           | --- t5 --- d7 --- t7 --- d9 --- t8 --- d10 --- t9 --- d11      #                     |                   |             |      # d3 --- |            |                   |             |      # |      |            |     t6 --- d8 -------------------      # |      t3 --- d6 ---|      # |      |      # |      |      # t4     d4        Config.configure_job_executions(mode=JobConfig._DEVELOPMENT_MODE)      _OrchestratorFactory._build_orchestrator()        csv_path_inp = os.path.join(pathlib.Path(__file__).parent.resolve(), \"data_sample/example.csv\")      excel_path_inp = os.path.join(pathlib.Path(__file__).parent.resolve(), \"data_sample/example.xlsx\")        csv_path_sum = os.path.join(pathlib.Path(__file__).parent.resolve(), \"data_sample/sum.csv\")      excel_path_sum = os.path.join(pathlib.Path(__file__).parent.resolve(), \"data_sample/sum.xlsx\")        excel_path_out = os.path.join(pathlib.Path(__file__).parent.resolve(), \"data_sample/res.xlsx\")      csv_path_out = os.path.join(pathlib.Path(__file__).parent.resolve(), \"data_sample/res.csv\")        inp_csv_dn_1 = Config.configure_csv_data_node(\"dn_csv_in_1\", default_path=csv_path_inp)      inp_csv_dn_2 = Config.configure_csv_data_node(\"dn_csv_in_2\", default_path=csv_path_inp)        inp_excel_dn_1 = Config.configure_excel_data_node(\"dn_excel_in_1\", default_path=excel_path_inp, sheet_name=\"Sheet1\")      inp_excel_dn_2 = Config.configure_excel_data_node(\"dn_excel_in_2\", default_path=excel_path_inp, sheet_name=\"Sheet1\")        placeholder = Config.configure_data_node(\"dn_placeholder\", default_data=10)        dn_csv_sum = Config.configure_csv_data_node(\"dn_sum_csv\", default_path=csv_path_sum)      dn_excel_sum = Config.configure_excel_data_node(\"dn_sum_excel\", default_path=excel_path_sum, sheet_name=\"Sheet1\")        dn_subtract_csv_excel = Config.configure_pickle_data_node(\"dn_subtract_csv_excel\")      dn_mult = Config.configure_pickle_data_node(\"dn_mult\")      dn_div = Config.configure_pickle_data_node(\"dn_div\")        output_csv_dn = Config.configure_csv_data_node(\"csv_out\", csv_path_out)      output_excel_dn = Config.configure_excel_data_node(\"excel_out\", excel_path_out)        task_print_csv = Config.configure_task(\"task_print_csv\", print, input=inp_csv_dn_1)      task_print_excel = Config.configure_task(\"task_print_excel\", print, input=inp_excel_dn_1)      task_sum_csv = Config.configure_task(\"task_sum_csv\", sum, input=[inp_csv_dn_2, inp_csv_dn_1], output=dn_csv_sum)      task_sum_excel = Config.configure_task(          \"task_sum_excel\", sum, input=[inp_excel_dn_2, inp_excel_dn_1], output=dn_excel_sum      )        task_subtract_csv_excel = Config.configure_task(          \"task_subtract_csv_excel\", subtract, input=[dn_csv_sum, dn_excel_sum], output=dn_subtract_csv_excel      )      task_insert_placeholder = Config.configure_task(\"task_insert_placeholder\", return_a_number, output=[placeholder])      task_mult = Config.configure_task(          \"task_mult_by_placeholder\", mult, input=[dn_subtract_csv_excel, placeholder], output=dn_mult      )      task_div = Config.configure_task(\"task_div_by_placeholder\", divide, input=[dn_mult, placeholder], output=dn_div)      task_avg_div = Config.configure_task(\"task_avg_div\", average, input=dn_div, output=output_csv_dn)      task_avg_mult = Config.configure_task(\"task_avg_mult\", average, input=dn_mult, output=output_excel_dn)        scenario_config = Config.configure_scenario(          \"scenario\",          [              task_print_csv,              task_print_excel,              task_sum_csv,              task_sum_excel,              task_subtract_csv_excel,              task_insert_placeholder,              task_mult,              task_div,              task_avg_div,              task_avg_mult,          ],      )        with patch(\"sys.argv\", [\"prog\"]):          core = Core()          core.run()          scenario = tp.create_scenario(scenario_config)          tp.submit(scenario)          core.stop()        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) "}
{"text": "#  # Licensed under the Apache License, Version 2.0 (the \"License\"); you may not use this file except in compliance with  # the License. You may obtain a copy of the License at  #  #        http://www.apache.org/licenses/LICENSE-2.0  #  # Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on  # an \"AS IS\" BASIS, WITHOUT 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 patch    import pytest    from src.taipy.core import Core  from src.taipy.core._version._version_manager import _VersionManager  from src.taipy.core._version._version_manager_factory import _VersionManagerFactory  from src.taipy.core.common._utils import _load_fct  from src.taipy.core.cycle._cycle_manager import _CycleManager  from src.taipy.core.data._data_manager import _DataManager  from src.taipy.core.exceptions.exceptions import NonExistingVersion  from src.taipy.core.job._job_manager import _JobManager  from src.taipy.core.scenario._scenario_manager import _ScenarioManager  from src.taipy.core.sequence._sequence_manager import _SequenceManager  from src.taipy.core.task._task_manager import _TaskManager  from taipy.config.common.frequency import Frequency  from taipy.config.common.scope import Scope  from taipy.config.config import Config  from tests.core.conftest import init_config  from tests.core.utils import assert_true_after_time      def test_core_cli_no_arguments():      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()      def test_core_cli_development_mode():      with patch(\"sys.argv\", [\"prog\", \"--development\"]):          core = Core()          core.run()          assert Config.core.mode == \"development\"          assert Config.core.version_number == _VersionManagerFactory._build_manager()._get_development_version()          core.stop()      def test_core_cli_dev_mode():      with patch(\"sys.argv\", [\"prog\", \"-dev\"]):          core = Core()          core.run()          assert Config.core.mode == \"development\"          assert Config.core.version_number == _VersionManagerFactory._build_manager()._get_development_version()          core.stop()      def test_core_cli_experiment_mode():      with patch(\"sys.argv\", [\"prog\", \"--experiment\"]):          core = Core()          core.run()          assert Config.core.mode == \"experiment\"          assert Config.core.version_number == _VersionManagerFactory._build_manager()._get_latest_version()          assert not Config.core.force          core.stop()      def test_core_cli_experiment_mode_with_version():      with patch(\"sys.argv\", [\"prog\", \"--experiment\", \"2.1\"]):          core = Core()          core.run()          assert Config.core.mode == \"experiment\"          assert Config.core.version_number == \"2.1\"          assert not Config.core.force          core.stop()      def test_core_cli_experiment_mode_with_force_version():      with patch(\"sys.argv\", [\"prog\", \"--experiment\", \"2.1\", \"--taipy-force\"]):          init_config()          core = Core()          core.run()          assert Config.core.mode == \"experiment\"          assert Config.core.version_number == \"2.1\"          assert Config.core.force          core.stop()      def test_core_cli_production_mode():      with patch(\"sys.argv\", [\"prog\", \"--production\"]):          core = Core()          core.run()          assert Config.core.mode == \"production\"          assert Config.core.version_number == _VersionManagerFactory._build_manager()._get_latest_version()          assert not Config.core.force          core.stop()      def test_dev_mode_clean_all_entities_of_the_latest_version():      scenario_config = config_scenario()        # Create a scenario in development mode      with patch(\"sys.argv\", [\"prog\"]):          core = Core()          core.run()          scenario = _ScenarioManager._create(scenario_config)          _ScenarioManager._submit(scenario)          core.stop()        # Initial assertion      assert len(_DataManager._get_all(version_number=\"all\")) == 2      assert len(_TaskManager._get_all(version_number=\"all\")) == 1      assert len(_SequenceManager._get_all(version_number=\"all\")) == 1      assert len(_ScenarioManager._get_all(version_number=\"all\")) == 1      assert len(_CycleManager._get_all(version_number=\"all\")) == 1      assert len(_JobManager._get_all(version_number=\"all\")) == 1        # Create a new scenario in experiment mode      with patch(\"sys.argv\", [\"prog\", \"--experiment\"]):          core = Core()          core.run()          scenario = _ScenarioManager._create(scenario_config)          _ScenarioManager._submit(scenario)          core.stop()        # Assert number of entities in 2nd version      assert len(_DataManager._get_all(version_number=\"all\")) == 4      assert len(_TaskManager._get_all(version_number=\"all\")) == 2      assert len(_SequenceManager._get_all(version_number=\"all\")) == 2      assert len(_ScenarioManager._get_all(version_number=\"all\")) == 2      assert (          len(_CycleManager._get_all(version_number=\"all\")) == 1      )  # No new cycle is created since old dev version use the same cycle      assert len(_JobManager._get_all(version_number=\"all\")) == 2        # Run development mode again      with patch(\"sys.argv\", [\"prog\", \"--development\"]):          core = Core()          core.run()            # The 1st dev version should be deleted run with development mode          assert len(_DataManager._get_all(version_number=\"all\")) == 2          assert len(_TaskManager._get_all(version_number=\"all\")) == 1          assert len(_SequenceManager._get_all(version_number=\"all\")) == 1          assert len(_ScenarioManager._get_all(version_number=\"all\")) == 1          assert len(_CycleManager._get_all(version_number=\"all\")) == 1          assert len(_JobManager._get_all(version_number=\"all\")) == 1            # Submit new dev version          scenario = _ScenarioManager._create(scenario_config)          _ScenarioManager._submit(scenario)          core.stop()            # Assert number of entities with 1 dev version and 1 exp version          assert len(_DataManager._get_all(version_number=\"all\")) == 4          assert len(_TaskManager._get_all(version_number=\"all\")) == 2          assert len(_SequenceManager._get_all(version_number=\"all\")) == 2          assert len(_ScenarioManager._get_all(version_number=\"all\")) == 2          assert len(_CycleManager._get_all(version_number=\"all\")) == 1          assert len(_JobManager._get_all(version_number=\"all\")) == 2            # Assert number of entities of the latest version only          assert len(_DataManager._get_all(version_number=\"latest\")) == 2          assert len(_TaskManager._get_all(version_number=\"latest\")) == 1          assert len(_SequenceManager._get_all(version_number=\"latest\")) == 1          assert len(_ScenarioManager._get_all(version_number=\"latest\")) == 1          assert len(_JobManager._get_all(version_number=\"latest\")) == 1            # Assert number of entities of the development version only          assert len(_DataManager._get_all(version_number=\"development\")) == 2          assert len(_TaskManager._get_all(version_number=\"development\")) == 1          assert len(_SequenceManager._get_all(version_number=\"development\")) == 1          assert len(_ScenarioManager._get_all(version_number=\"development\")) == 1          assert len(_JobManager._get_all(version_number=\"development\")) == 1            # Assert number of entities of an unknown version          with pytest.raises(NonExistingVersion):              assert _DataManager._get_all(version_number=\"foo\")          with pytest.raises(NonExistingVersion):              assert _TaskManager._get_all(version_number=\"foo\")          with pytest.raises(NonExistingVersion):              assert _SequenceManager._get_all(version_number=\"foo\")          with pytest.raises(NonExistingVersion):              assert _ScenarioManager._get_all(version_number=\"foo\")          with pytest.raises(NonExistingVersion):              assert _JobManager._get_all(version_number=\"foo\")      def twice_doppelganger(a):      return a * 2      def test_dev_mode_clean_all_entities_when_config_is_alternated():      data_node_1_config = Config.configure_data_node(          id=\"d1\", storage_type=\"pickle\", default_data=\"abc\", scope=Scope.SCENARIO      )      data_node_2_config = Config.configure_data_node(id=\"d2\", storage_type=\"csv\", default_path=\"foo.csv\")      task_config = Config.configure_task(\"my_task\", twice_doppelganger, data_node_1_config, data_node_2_config)      scenario_config = Config.configure_scenario(\"my_scenario\", [task_config], frequency=Frequency.DAILY)        # Create a scenario in development mode with the doppelganger function      with patch(\"sys.argv\", [\"prog\"]):          core = Core()          core.run()          scenario = _ScenarioManager._create(scenario_config)          _ScenarioManager._submit(scenario)          core.stop()        # Delete the twice_doppelganger function      # and clear cache of _load_fct() to simulate a new run      del globals()[\"twice_doppelganger\"]      _load_fct.cache_clear()        # Create a scenario in development mode with another function      scenario_config = config_scenario()      with patch(\"sys.argv\", [\"prog\"]):          core = Core()          core.run()          scenario = _ScenarioManager._create(scenario_config)          _ScenarioManager._submit(scenario)          core.stop()      def test_version_number_when_switching_mode():      with patch(\"sys.argv\", [\"prog\", \"--development\"]):          core = Core()          core.run()          ver_1 = _VersionManager._get_latest_version()          ver_dev = _VersionManager._get_development_version()          assert ver_1 == ver_dev          assert len(_VersionManager._get_all()) == 1          core.stop()        # Run with dev mode, the version number is the same      with patch(\"sys.argv\", [\"prog\", \"--development\"]):          core = Core()          core.run()          ver_2 = _VersionManager._get_latest_version()          assert ver_2 == ver_dev          assert len(_VersionManager._get_all()) == 1          core.stop()        # When run with experiment mode, a new version is created      with patch(\"sys.argv\", [\"prog\", \"--experiment\"]):          core = Core()          core.run()          ver_3 = _VersionManager._get_latest_version()          assert ver_3 != ver_dev          assert len(_VersionManager._get_all()) == 2          core.stop()        with patch(\"sys.argv\", [\"prog\", \"--experiment\", \"2.1\"]):          core = Core()          core.run()          ver_4 = _VersionManager._get_latest_version()          assert ver_4 == \"2.1\"          assert len(_VersionManager._get_all()) == 3          core.stop()        with patch(\"sys.argv\", [\"prog\", \"--experiment\"]):          core = Core()          core.run()          ver_5 = _VersionManager._get_latest_version()          assert ver_5 != ver_3          assert ver_5 != ver_4          assert ver_5 != ver_dev          assert len(_VersionManager._get_all()) == 4          core.stop()        # When run with production mode, the latest version is used as production      with patch(\"sys.argv\", [\"prog\", \"--production\"]):          core = Core()          core.run()          ver_6 = _VersionManager._get_latest_version()          production_versions = _VersionManager._get_production_versions()          assert ver_6 == ver_5          assert production_versions == [ver_6]          assert len(_VersionManager._get_all()) == 4          core.stop()        # When run with production mode, the \"2.1\" version is used as production      with patch(\"sys.argv\", [\"prog\", \"--production\", \"2.1\"]):          core = Core()          core.run()          ver_7 = _VersionManager._get_latest_version()          production_versions = _VersionManager._get_production_versions()          assert ver_7 == \"2.1\"          assert production_versions == [ver_6, ver_7]          assert len(_VersionManager._get_all()) == 4          core.stop()        # Run with dev mode, the version number is the same as the first dev version to overide it      with patch(\"sys.argv\", [\"prog\", \"--development\"]):          core = Core()          core.run()          ver_7 = _VersionManager._get_latest_version()          assert ver_1 == ver_7          assert len(_VersionManager._get_all()) == 4          core.stop()      def test_production_mode_load_all_entities_from_previous_production_version():      scenario_config = config_scenario()        with patch(\"sys.argv\", [\"prog\", \"--development\"]):          core = Core()          core.run()          scenario = _ScenarioManager._create(scenario_config)          _ScenarioManager._submit(scenario)          core.stop()        with patch(\"sys.argv\", [\"prog\", \"--production\", \"1.0\"]):          core = Core()          core.run()          production_ver_1 = _VersionManager._get_latest_version()          assert _VersionManager._get_production_versions() == [production_ver_1]          # When run production mode on a new app, a dev version is created alongside          assert _VersionManager._get_development_version() not in _VersionManager._get_production_versions()          assert len(_VersionManager._get_all()) == 2            scenario = _ScenarioManager._create(scenario_config)          _ScenarioManager._submit(scenario)            assert len(_DataManager._get_all()) == 2          assert len(_TaskManager._get_all()) == 1          assert len(_SequenceManager._get_all()) == 1          assert len(_ScenarioManager._get_all()) == 1          assert len(_CycleManager._get_all()) == 1          assert len(_JobManager._get_all()) == 1          core.stop()        with patch(\"sys.argv\", [\"prog\", \"--production\", \"2.0\"]):          core = Core()          core.run()          production_ver_2 = _VersionManager._get_latest_version()          assert _VersionManager._get_production_versions() == [production_ver_1, production_ver_2]          assert len(_VersionManager._get_all()) == 3            # All entities from previous production version should be saved          scenario = _ScenarioManager._create(scenario_config)          _ScenarioManager._submit(scenario)            assert len(_DataManager._get_all()) == 4          assert len(_TaskManager._get_all()) == 2          assert len(_SequenceManager._get_all()) == 2          assert len(_ScenarioManager._get_all()) == 2          assert len(_CycleManager._get_all()) == 1          assert len(_JobManager._get_all()) == 2          core.stop()      def test_force_override_experiment_version():      scenario_config = config_scenario()        with patch(\"sys.argv\", [\"prog\", \"--experiment\", \"1.0\"]):          core = Core()          core.run()          ver_1 = _VersionManager._get_latest_version()          assert ver_1 == \"1.0\"          # When create new experiment version, a development version entity is also created as a placeholder          assert len(_VersionManager._get_all()) == 2  # 2 version include 1 experiment 1 development            scenario = _ScenarioManager._create(scenario_config)          _ScenarioManager._submit(scenario)            assert len(_DataManager._get_all()) == 2          assert len(_TaskManager._get_all()) == 1          assert len(_SequenceManager._get_all()) == 1          assert len(_ScenarioManager._get_all()) == 1          assert len(_CycleManager._get_all()) == 1          assert len(_JobManager._get_all()) == 1          core.stop()        Config.configure_global_app(foo=\"bar\")        # Without --taipy-force parameter, a SystemExit will be raised      with pytest.raises(SystemExit):          with patch(\"sys.argv\", [\"prog\", \"--experiment\", \"1.0\"]):              core = Core()              core.run()      core.stop()        # With --taipy-force parameter      with patch(\"sys.argv\", [\"prog\", \"--experiment\", \"1.0\", \"--taipy-force\"]):          core = Core()          core.run()          ver_2 = _VersionManager._get_latest_version()          assert ver_2 == \"1.0\"          assert len(_VersionManager._get_all()) == 2  # 2 version include 1 experiment 1 development            # All entities from previous submit should be saved          scenario = _ScenarioManager._create(scenario_config)          _ScenarioManager._submit(scenario)            assert len(_DataManager._get_all()) == 4          assert len(_TaskManager._get_all()) == 2          assert len(_SequenceManager._get_all()) == 2          assert len(_ScenarioManager._get_all()) == 2          assert len(_CycleManager._get_all()) == 1          assert len(_JobManager._get_all()) == 2          core.stop()      def test_force_override_production_version():      scenario_config = config_scenario()        with patch(\"sys.argv\", [\"prog\", \"--production\", \"1.0\"]):          core = Core()          core.run()          ver_1 = _VersionManager._get_latest_version()          production_versions = _VersionManager._get_production_versions()          assert ver_1 == \"1.0\"          assert production_versions == [\"1.0\"]          # When create new production version, a development version entity is also created as a placeholder          assert len(_VersionManager._get_all()) == 2  # 2 version include 1 production 1 development            scenario = _ScenarioManager._create(scenario_config)          _ScenarioManager._submit(scenario)            assert len(_DataManager._get_all()) == 2          assert len(_TaskManager._get_all()) == 1          assert len(_SequenceManager._get_all()) == 1          assert len(_ScenarioManager._get_all()) == 1          assert len(_CycleManager._get_all()) == 1          assert len(_JobManager._get_all()) == 1          core.stop()        Config.configure_global_app(foo=\"bar\")        # Without --taipy-force parameter, a SystemExit will be raised      with pytest.raises(SystemExit):          with patch(\"sys.argv\", [\"prog\", \"--production\", \"1.0\"]):              core = Core()              core.run()      core.stop()        # With --taipy-force parameter      with patch(\"sys.argv\", [\"prog\", \"--production\", \"1.0\", \"--taipy-force\"]):          core = Core()          core.run()          ver_2 = _VersionManager._get_latest_version()          assert ver_2 == \"1.0\"          assert len(_VersionManager._get_all()) == 2  # 2 version include 1 production 1 development            # All entities from previous submit should be saved          scenario = _ScenarioManager._create(scenario_config)          _ScenarioManager._submit(scenario)            assert len(_DataManager._get_all()) == 4          assert len(_TaskManager._get_all()) == 2          assert len(_SequenceManager._get_all()) == 2          assert len(_ScenarioManager._get_all()) == 2          assert len(_CycleManager._get_all()) == 1          assert len(_JobManager._get_all()) == 2          core.stop()      def test_modify_job_configuration_dont_stop_application(caplog):      scenario_config = config_scenario()        with patch(\"sys.argv\", [\"prog\", \"--experiment\", \"1.0\"]):          core = Core()          Config.configure_job_executions(mode=\"development\")          core.run(force_restart=True)          scenario = _ScenarioManager._create(scenario_config)          jobs = _ScenarioManager._submit(scenario)          assert all([job.is_finished() for job in jobs])          core.stop()        init_config()      scenario_config = config_scenario()        with patch(\"sys.argv\", [\"prog\", \"--experiment\", \"1.0\"]):          core = Core()          Config.configure_job_executions(mode=\"standalone\", max_nb_of_workers=5)          core.run(force_restart=True)          scenario = _ScenarioManager._create(scenario_config)            jobs = _ScenarioManager._submit(scenario)          assert_true_after_time(lambda: all(job.is_finished() for job in jobs))          error_message = str(caplog.text)          assert 'JOB \"mode\" was modified' in error_message          assert 'JOB \"max_nb_of_workers\" was modified' in error_message          core.stop()      def test_modify_config_properties_without_force(caplog):      scenario_config = config_scenario()        with patch(\"sys.argv\", [\"prog\", \"--experiment\", \"1.0\"]):          core = Core()          core.run()          scenario = _ScenarioManager._create(scenario_config)          _ScenarioManager._submit(scenario)          core.stop()        init_config()        scenario_config_2 = config_scenario_2()        with pytest.raises(SystemExit):          with patch(\"sys.argv\", [\"prog\", \"--experiment\", \"1.0\"]):              core = Core()              core.run()              scenario = _ScenarioManager._create(scenario_config_2)              _ScenarioManager._submit(scenario)      core.stop()      error_message = str(caplog.text)        assert 'DATA_NODE \"d3\" was added' in error_message        assert 'DATA_NODE \"d0\" was removed' in error_message        assert 'DATA_NODE \"d2\" has attribute \"default_path\" modified' in error_message      assert 'CORE \"root_folder\" was modified' in error_message      assert 'CORE \"repository_type\" was modified' in error_message      assert 'JOB \"mode\" was modified' in error_message      assert 'JOB \"max_nb_of_workers\" was modified' in error_message      assert 'SCENARIO \"my_scenario\" has attribute \"frequency\" modified' in error_message      assert 'SCENARIO \"my_scenario\" has attribute \"tasks\" modified' in error_message      assert 'TASK \"my_task\" has attribute \"inputs\" modified' in error_message      assert 'TASK \"my_task\" has attribute \"function\" modified' in error_message      assert 'TASK \"my_task\" has attribute \"outputs\" modified' in error_message      assert 'DATA_NODE \"d2\" has attribute \"has_header\" modified' in error_message      assert 'DATA_NODE \"d2\" has attribute \"exposed_type\" modified' in error_message        assert 'CORE \"repository_properties\" was added' in error_message      def twice(a):      return a * 2      def config_scenario():      Config.configure_data_node(id=\"d0\")      data_node_1_config = Config.configure_data_node(          id=\"d1\", storage_type=\"pickle\", default_data=\"abc\", scope=Scope.SCENARIO      )      data_node_2_config = Config.configure_data_node(id=\"d2\", storage_type=\"csv\", default_path=\"foo.csv\")      task_config = Config.configure_task(\"my_task\", twice, data_node_1_config, data_node_2_config)      scenario_config = Config.configure_scenario(\"my_scenario\", [task_config], frequency=Frequency.DAILY)      scenario_config.add_sequences({\"my_sequence\": [task_config]})        return scenario_config      def double_twice(a):      return a * 2, a * 2      def config_scenario_2():      Config.configure_core(          root_folder=\"foo_root\",          # Changing the \"storage_folder\" will fail since older versions are stored in older folder          # storage_folder=\"foo_storage\",          repository_type=\"bar\",          repository_properties={\"foo\": \"bar\"},      )      Config.configure_job_executions(mode=\"standalone\", max_nb_of_workers=5)      data_node_1_config = Config.configure_data_node(          id=\"d1\", storage_type=\"pickle\", default_data=\"abc\", scope=Scope.SCENARIO      )      # Modify properties of \"d2\"      data_node_2_config = Config.configure_data_node(          id=\"d2\", storage_type=\"csv\", default_path=\"bar.csv\", has_header=False, exposed_type=\"numpy\"      )      # Add new data node \"d3\"      data_node_3_config = Config.configure_data_node(          id=\"d3\", storage_type=\"csv\", default_path=\"baz.csv\", has_header=False, exposed_type=\"numpy\"      )      # Modify properties of \"my_task\", including the function and outputs list      Config.configure_task(\"my_task\", double_twice, data_node_3_config, [data_node_1_config, data_node_2_config])      task_config_1 = Config.configure_task(\"my_task_1\", double_twice, data_node_3_config, [data_node_2_config])      # Modify properties of \"my_scenario\", where tasks is now my_task_1      scenario_config = Config.configure_scenario(\"my_scenario\", [task_config_1], frequency=Frequency.MONTHLY)      scenario_config.add_sequences({\"my_sequence\": [task_config_1]})        return scenario_config "}
{"text": "import datetime  import os  import pathlib  import shutil  from unittest import mock    import pytest    import src.taipy.core.taipy as tp  from src.taipy.core import (      Core,      Cycle,      CycleId,      DataNodeId,      JobId,      Scenario,      ScenarioId,      Sequence,      SequenceId,      Task,      TaskId,  )  from src.taipy.core._orchestrator._orchestrator_factory import _OrchestratorFactory  from src.taipy.core._version._version_manager import _VersionManager  from src.taipy.core.config.data_node_config import DataNodeConfig  from src.taipy.core.config.job_config import JobConfig  from src.taipy.core.config.scenario_config import ScenarioConfig  from src.taipy.core.cycle._cycle_manager import _CycleManager  from src.taipy.core.data._data_manager import _DataManager  from src.taipy.core.data.pickle import PickleDataNode  from src.taipy.core.exceptions.exceptions import DataNodeConfigIsNotGlobal, InvalidExportPath  from src.taipy.core.job._job_manager import _JobManager  from src.taipy.core.job.job import Job  from src.taipy.core.scenario._scenario_manager import _ScenarioManager  from src.taipy.core.sequence._sequence_manager import _SequenceManager  from src.taipy.core.task._task_manager import _TaskManager  from taipy.config.common.frequency import Frequency  from taipy.config.common.scope import Scope  from taipy.config.config import Config  from taipy.config.exceptions.exceptions import ConfigurationUpdateBlocked      class TestTaipy:      def test_set(self, scenario, cycle, sequence, data_node, task):          with mock.patch(\"src.taipy.core.data._data_manager._DataManager._set\") as mck:              tp.set(data_node)              mck.assert_called_once_with(data_node)          with mock.patch(\"src.taipy.core.task._task_manager._TaskManager._set\") as mck:              tp.set(task)              mck.assert_called_once_with(task)          with mock.patch(\"src.taipy.core.sequence._sequence_manager._SequenceManager._set\") as mck:              tp.set(sequence)              mck.assert_called_once_with(sequence)          with mock.patch(\"src.taipy.core.scenario._scenario_manager._ScenarioManager._set\") as mck:              tp.set(scenario)              mck.assert_called_once_with(scenario)          with mock.patch(\"src.taipy.core.cycle._cycle_manager._CycleManager._set\") as mck:              tp.set(cycle)              mck.assert_called_once_with(cycle)        def test_is_editable_is_called(self, cycle, job, data_node):          with mock.patch(\"src.taipy.core.cycle._cycle_manager._CycleManager._is_editable\") as mck:              cycle_id = CycleId(\"CYCLE_id\")              tp.is_editable(cycle_id)              mck.assert_called_once_with(cycle_id)            with mock.patch(\"src.taipy.core.cycle._cycle_manager._CycleManager._is_editable\") as mck:              tp.is_editable(cycle)              mck.assert_called_once_with(cycle)            with mock.patch(\"src.taipy.core.scenario._scenario_manager._ScenarioManager._is_editable\") as mck:              scenario_id = ScenarioId(\"SCENARIO_id\")              tp.is_editable(scenario_id)              mck.assert_called_once_with(scenario_id)            with mock.patch(\"src.taipy.core.scenario._scenario_manager._ScenarioManager._is_editable\") as mck:              scenario = Scenario(\"scenario_config_id\", [], {})              tp.is_editable(scenario)              mck.assert_called_once_with(scenario)            with mock.patch(\"src.taipy.core.sequence._sequence_manager._SequenceManager._is_editable\") as mck:              sequence_id = SequenceId(\"SEQUENCE_id\")              tp.is_editable(sequence_id)              mck.assert_called_once_with(sequence_id)            with mock.patch(\"src.taipy.core.sequence._sequence_manager._SequenceManager._is_editable\") as mck:              sequence = Sequence({}, [], \"sequence_id\")              tp.is_editable(sequence)              mck.assert_called_once_with(sequence)            with mock.patch(\"src.taipy.core.task._task_manager._TaskManager._is_editable\") as mck:              task_id = TaskId(\"TASK_id\")              tp.is_editable(task_id)              mck.assert_called_once_with(task_id)            with mock.patch(\"src.taipy.core.task._task_manager._TaskManager._is_editable\") as mck:              task = Task(\"task_config_id\", {}, print)              tp.is_editable(task)              mck.assert_called_once_with(task)            with mock.patch(\"src.taipy.core.job._job_manager._JobManager._is_editable\") as mck:              job_id = JobId(\"JOB_id\")              tp.is_editable(job_id)              mck.assert_called_once_with(job_id)            with mock.patch(\"src.taipy.core.job._job_manager._JobManager._is_editable\") as mck:              tp.is_editable(job)              mck.assert_called_once_with(job)            with mock.patch(\"src.taipy.core.data._data_manager._DataManager._is_editable\") as mck:              dn_id = DataNodeId(\"DATANODE_id\")              tp.is_editable(dn_id)              mck.assert_called_once_with(dn_id)            with mock.patch(\"src.taipy.core.data._data_manager._DataManager._is_editable\") as mck:              tp.is_editable(data_node)              mck.assert_called_once_with(data_node)        def test_is_editable(self):          current_date = datetime.datetime.now()            cycle = Cycle(Frequency.DAILY, {}, current_date, current_date, current_date)          scenario = Scenario(\"scenario_config_id\", [], {}, sequences={\"sequence\": {}})            task = Task(\"task_config_id\", {}, print)          job = Job(\"job_id\", task, \"submit_id\", scenario.id)          dn = PickleDataNode(\"data_node_config_id\", Scope.SCENARIO)            _CycleManager._set(cycle)          _ScenarioManager._set(scenario)          _TaskManager._set(task)          _JobManager._set(job)          _DataManager._set(dn)          sequence = scenario.sequences[\"sequence\"]            assert tp.is_editable(scenario)          assert tp.is_editable(sequence)          assert tp.is_editable(task)          assert tp.is_editable(cycle)          assert tp.is_editable(job)          assert tp.is_editable(dn)        def test_is_readable_is_called(self, cycle, job, data_node):          with mock.patch(\"src.taipy.core.cycle._cycle_manager._CycleManager._is_readable\") as mck:              cycle_id = CycleId(\"CYCLE_id\")              tp.is_readable(cycle_id)              mck.assert_called_once_with(cycle_id)            with mock.patch(\"src.taipy.core.cycle._cycle_manager._CycleManager._is_readable\") as mck:              tp.is_readable(cycle)              mck.assert_called_once_with(cycle)            with mock.patch(\"src.taipy.core.scenario._scenario_manager._ScenarioManager._is_readable\") as mck:              scenario_id = ScenarioId(\"SCENARIO_id\")              tp.is_readable(scenario_id)              mck.assert_called_once_with(scenario_id)            with mock.patch(\"src.taipy.core.scenario._scenario_manager._ScenarioManager._is_readable\") as mck:              scenario = Scenario(\"scenario_config_id\", [], {})              tp.is_readable(scenario)              mck.assert_called_once_with(scenario)            with mock.patch(\"src.taipy.core.sequence._sequence_manager._SequenceManager._is_readable\") as mck:              sequence_id = SequenceId(\"SEQUENCE_id\")              tp.is_readable(sequence_id)              mck.assert_called_once_with(sequence_id)            with mock.patch(\"src.taipy.core.sequence._sequence_manager._SequenceManager._is_readable\") as mck:              sequence = Sequence({}, [], \"sequence_id\")              tp.is_readable(sequence)              mck.assert_called_once_with(sequence)            with mock.patch(\"src.taipy.core.task._task_manager._TaskManager._is_readable\") as mck:              task_id = TaskId(\"TASK_id\")              tp.is_readable(task_id)              mck.assert_called_once_with(task_id)            with mock.patch(\"src.taipy.core.task._task_manager._TaskManager._is_readable\") as mck:              task = Task(\"task_config_id\", {}, print)              tp.is_readable(task)              mck.assert_called_once_with(task)            with mock.patch(\"src.taipy.core.job._job_manager._JobManager._is_readable\") as mck:              job_id = JobId(\"JOB_id\")              tp.is_readable(job_id)              mck.assert_called_once_with(job_id)            with mock.patch(\"src.taipy.core.job._job_manager._JobManager._is_readable\") as mck:              tp.is_readable(job)              mck.assert_called_once_with(job)            with mock.patch(\"src.taipy.core.data._data_manager._DataManager._is_readable\") as mck:              dn_id = DataNodeId(\"DATANODE_id\")              tp.is_readable(dn_id)              mck.assert_called_once_with(dn_id)            with mock.patch(\"src.taipy.core.data._data_manager._DataManager._is_readable\") as mck:              tp.is_readable(data_node)              mck.assert_called_once_with(data_node)        def test_is_readable(self):          current_date = datetime.datetime.now()            cycle = Cycle(Frequency.DAILY, {}, current_date, current_date, current_date)          scenario = Scenario(\"scenario_config_id\", [], {}, sequences={\"sequence\": {}})            task = Task(\"task_config_id\", {}, print)          job = Job(\"job_id\", task, \"submit_id\", scenario.id)          dn = PickleDataNode(\"data_node_config_id\", Scope.SCENARIO)            _CycleManager._set(cycle)          _ScenarioManager._set(scenario)          _TaskManager._set(task)          _JobManager._set(job)          _DataManager._set(dn)          sequence = scenario.sequences[\"sequence\"]            assert tp.is_readable(scenario)          assert tp.is_readable(sequence)          assert tp.is_readable(task)          assert tp.is_readable(cycle)          assert tp.is_readable(job)          assert tp.is_readable(dn)        def test_is_submittable_is_called(self):          with mock.patch(\"src.taipy.core.scenario._scenario_manager._ScenarioManager._is_submittable\") as mck:              scenario_id = ScenarioId(\"SCENARIO_id\")              tp.is_submittable(scenario_id)              mck.assert_called_once_with(scenario_id)            with mock.patch(\"src.taipy.core.scenario._scenario_manager._ScenarioManager._is_submittable\") as mck:              scenario = Scenario(\"scenario_config_id\", [], {})              tp.is_submittable(scenario)              mck.assert_called_once_with(scenario)            with mock.patch(\"src.taipy.core.sequence._sequence_manager._SequenceManager._is_submittable\") as mck:              sequence_id = SequenceId(\"SEQUENCE_id\")              tp.is_submittable(sequence_id)              mck.assert_called_once_with(sequence_id)            with mock.patch(\"src.taipy.core.sequence._sequence_manager._SequenceManager._is_submittable\") as mck:              sequence = Sequence({}, [], \"sequence_id\")              tp.is_submittable(sequence)              mck.assert_called_once_with(sequence)            with mock.patch(\"src.taipy.core.task._task_manager._TaskManager._is_submittable\") as mck:              task_id = TaskId(\"TASK_id\")              tp.is_submittable(task_id)              mck.assert_called_once_with(task_id)            with mock.patch(\"src.taipy.core.task._task_manager._TaskManager._is_submittable\") as mck:              task = Task(\"task_config_id\", {}, print)              tp.is_submittable(task)              mck.assert_called_once_with(task)        def test_is_submittable(self):          current_date = datetime.datetime.now()            cycle = Cycle(Frequency.DAILY, {}, current_date, current_date, current_date)          scenario = Scenario(\"scenario_config_id\", [], {}, sequences={\"sequence\": {}})            task = Task(\"task_config_id\", {}, print)          job = Job(\"job_id\", task, \"submit_id\", scenario.id)          dn = PickleDataNode(\"data_node_config_id\", Scope.SCENARIO)            _CycleManager._set(cycle)          _ScenarioManager._set(scenario)          _TaskManager._set(task)          _JobManager._set(job)          _DataManager._set(dn)          sequence = scenario.sequences[\"sequence\"]            assert tp.is_submittable(scenario)          assert tp.is_submittable(sequence)          assert tp.is_submittable(task)          assert not tp.is_submittable(cycle)          assert not tp.is_submittable(job)          assert not tp.is_submittable(dn)        def test_submit(self, scenario, sequence, task):          with mock.patch(\"src.taipy.core.scenario._scenario_manager._ScenarioManager._submit\") as mck:              tp.submit(scenario)              mck.assert_called_once_with(scenario, force=False, wait=False, timeout=None)          with mock.patch(\"src.taipy.core.sequence._sequence_manager._SequenceManager._submit\") as mck:              tp.submit(sequence)              mck.assert_called_once_with(sequence, force=False, wait=False, timeout=None)          with mock.patch(\"src.taipy.core.task._task_manager._TaskManager._submit\") as mck:              tp.submit(task)              mck.assert_called_once_with(task, force=False, wait=False, timeout=None)          with mock.patch(\"src.taipy.core.scenario._scenario_manager._ScenarioManager._submit\") as mck:              tp.submit(scenario, False, False, None)              mck.assert_called_once_with(scenario, force=False, wait=False, timeout=None)          with mock.patch(\"src.taipy.core.sequence._sequence_manager._SequenceManager._submit\") as mck:              tp.submit(sequence, False, False, None)              mck.assert_called_once_with(sequence, force=False, wait=False, timeout=None)          with mock.patch(\"src.taipy.core.task._task_manager._TaskManager._submit\") as mck:              tp.submit(task, False, False, None)              mck.assert_called_once_with(task, force=False, wait=False, timeout=None)          with mock.patch(\"src.taipy.core.scenario._scenario_manager._ScenarioManager._submit\") as mck:              tp.submit(scenario, True, True, 60)              mck.assert_called_once_with(scenario, force=True, wait=True, timeout=60)          with mock.patch(\"src.taipy.core.sequence._sequence_manager._SequenceManager._submit\") as mck:              tp.submit(sequence, True, True, 60)              mck.assert_called_once_with(sequence, force=True, wait=True, timeout=60)          with mock.patch(\"src.taipy.core.task._task_manager._TaskManager._submit\") as mck:              tp.submit(task, True, True, 60)              mck.assert_called_once_with(task, force=True, wait=True, timeout=60)        def test_warning_no_core_service_running(self, scenario):          _OrchestratorFactory._remove_dispatcher()            with pytest.warns(ResourceWarning) as warning:              with mock.patch(\"src.taipy.core.scenario._scenario_manager._ScenarioManager._submit\"):                  tp.submit(scenario)            assert len(warning) == 1          assert warning[0].message.args[0] == \"The Core service is NOT running\"        def test_get_tasks(self):          with mock.patch(\"src.taipy.core.task._task_manager._TaskManager._get_all\") as mck:              tp.get_tasks()              mck.assert_called_once_with()        def test_get_task(self, task):          with mock.patch(\"src.taipy.core.task._task_manager._TaskManager._get\") as mck:              task_id = TaskId(\"TASK_id\")              tp.get(task_id)              mck.assert_called_once_with(task_id)        def test_task_exists(self):          with mock.patch(\"src.taipy.core.task._task_manager._TaskManager._exists\") as mck:              task_id = TaskId(\"TASK_id\")              tp.exists(task_id)              mck.assert_called_once_with(task_id)        def test_is_deletable(self, task):          with mock.patch(\"src.taipy.core.scenario._scenario_manager._ScenarioManager._is_deletable\") as mck:              scenario_id = ScenarioId(\"SCENARIO_id\")              tp.is_deletable(scenario_id)              mck.assert_called_once_with(scenario_id)            with mock.patch(\"src.taipy.core.scenario._scenario_manager._ScenarioManager._is_deletable\") as mck:              scenario = Scenario(\"config_id\", [], {})              tp.is_deletable(scenario)              mck.assert_called_once_with(scenario)            with mock.patch(\"src.taipy.core.job._job_manager._JobManager._is_deletable\") as mck:              job_id = JobId(\"JOB_job_id\")              tp.is_deletable(job_id)              mck.assert_called_once_with(job_id)            with mock.patch(\"src.taipy.core.job._job_manager._JobManager._is_deletable\") as mck:              job = Job(\"job_id\", task, \"submit_id\", task.id)              tp.is_deletable(job)              mck.assert_called_once_with(job)        def test_is_promotable(self):          with mock.patch(\"src.taipy.core.scenario._scenario_manager._ScenarioManager._is_promotable_to_primary\") as mck:              scenario_id = ScenarioId(\"SCENARIO_id\")              tp.is_promotable(scenario_id)              mck.assert_called_once_with(scenario_id)            with mock.patch(\"src.taipy.core.scenario._scenario_manager._ScenarioManager._is_promotable_to_primary\") as mck:              scenario = Scenario(\"config_id\", [], {})              tp.is_promotable(scenario)              mck.assert_called_once_with(scenario)        def test_delete_scenario(self):          with mock.patch(\"src.taipy.core.scenario._scenario_manager._ScenarioManager._hard_delete\") as mck:              scenario_id = ScenarioId(\"SCENARIO_id\")              tp.delete(scenario_id)              mck.assert_called_once_with(scenario_id)        def test_delete(self):          with mock.patch(\"src.taipy.core.cycle._cycle_manager._CycleManager._hard_delete\") as mck:              cycle_id = CycleId(\"CYCLE_id\")              tp.delete(cycle_id)              mck.assert_called_once_with(cycle_id)        def test_get_scenarios(self, cycle):          with mock.patch(\"src.taipy.core.scenario._scenario_manager._ScenarioManager._get_all\") as mck:              tp.get_scenarios()              mck.assert_called_once_with()          with mock.patch(\"src.taipy.core.scenario._scenario_manager._ScenarioManager._get_all_by_cycle\") as mck:              tp.get_scenarios(cycle)              mck.assert_called_once_with(cycle)          with mock.patch(\"src.taipy.core.scenario._scenario_manager._ScenarioManager._get_all_by_tag\") as mck:              tp.get_scenarios(tag=\"tag\")              mck.assert_called_once_with(\"tag\")        def test_get_scenario(self, scenario):          with mock.patch(\"src.taipy.core.scenario._scenario_manager._ScenarioManager._get\") as mck:              scenario_id = ScenarioId(\"SCENARIO_id\")              tp.get(scenario_id)              mck.assert_called_once_with(scenario_id)        def test_scenario_exists(self):          with mock.patch(\"src.taipy.core.scenario._scenario_manager._ScenarioManager._exists\") as mck:              scenario_id = ScenarioId(\"SCENARIO_id\")              tp.exists(scenario_id)              mck.assert_called_once_with(scenario_id)        def test_get_primary(self, cycle):          with mock.patch(\"src.taipy.core.scenario._scenario_manager._ScenarioManager._get_primary\") as mck:              tp.get_primary(cycle)              mck.assert_called_once_with(cycle)        def test_get_primary_scenarios(self):          with mock.patch(\"src.taipy.core.scenario._scenario_manager._ScenarioManager._get_primary_scenarios\") as mck:              tp.get_primary_scenarios()              mck.assert_called_once_with()        def test_set_primary(self, scenario):          with mock.patch(\"src.taipy.core.scenario._scenario_manager._ScenarioManager._set_primary\") as mck:              tp.set_primary(scenario)              mck.assert_called_once_with(scenario)        def test_tag_and_untag(self, scenario):          with mock.patch(\"src.taipy.core.scenario._scenario_manager._ScenarioManager._tag\") as mck:              tp.tag(scenario, \"tag\")              mck.assert_called_once_with(scenario, \"tag\")          with mock.patch(\"src.taipy.core.scenario._scenario_manager._ScenarioManager._untag\") as mck:              tp.untag(scenario, \"tag\")              mck.assert_called_once_with(scenario, \"tag\")        def test_compare_scenarios(self, scenario):          with mock.patch(\"src.taipy.core.scenario._scenario_manager._ScenarioManager._compare\") as mck:              tp.compare_scenarios(scenario, scenario, data_node_config_id=\"dn\")              mck.assert_called_once_with(scenario, scenario, data_node_config_id=\"dn\")        def test_subscribe_scenario(self, scenario):          with mock.patch(\"src.taipy.core.scenario._scenario_manager._ScenarioManager._subscribe\") as mck:              tp.subscribe_scenario(print)              mck.assert_called_once_with(print, [], None)          with mock.patch(\"src.taipy.core.scenario._scenario_manager._ScenarioManager._subscribe\") as mck:              tp.subscribe_scenario(print, scenario=scenario)              mck.assert_called_once_with(print, [], scenario)        def test_unsubscribe_scenario(self, scenario):          with mock.patch(\"src.taipy.core.scenario._scenario_manager._ScenarioManager._unsubscribe\") as mck:              tp.unsubscribe_scenario(print)              mck.assert_called_once_with(print, None, None)          with mock.patch(\"src.taipy.core.scenario._scenario_manager._ScenarioManager._unsubscribe\") as mck:              tp.unsubscribe_scenario(print, scenario=scenario)              mck.assert_called_once_with(print, None, scenario)        def test_subscribe_sequence(self, sequence):          with mock.patch(\"src.taipy.core.sequence._sequence_manager._SequenceManager._subscribe\") as mck:              tp.subscribe_sequence(print)              mck.assert_called_once_with(print, None, None)          with mock.patch(\"src.taipy.core.sequence._sequence_manager._SequenceManager._subscribe\") as mck:              tp.subscribe_sequence(print, sequence=sequence)              mck.assert_called_once_with(print, None, sequence)        def test_unsubscribe_sequence(self, sequence):          with mock.patch(\"src.taipy.core.sequence._sequence_manager._SequenceManager._unsubscribe\") as mck:              tp.unsubscribe_sequence(callback=print)              mck.assert_called_once_with(print, None, None)          with mock.patch(\"src.taipy.core.sequence._sequence_manager._SequenceManager._unsubscribe\") as mck:              tp.unsubscribe_sequence(callback=print, sequence=sequence)              mck.assert_called_once_with(print, None, sequence)        def test_delete_sequence(self):          with mock.patch(\"src.taipy.core.sequence._sequence_manager._SequenceManager._hard_delete\") as mck:              sequence_id = SequenceId(\"SEQUENCE_id\")              tp.delete(sequence_id)              mck.assert_called_once_with(sequence_id)        def test_get_sequence(self, sequence):          with mock.patch(\"src.taipy.core.sequence._sequence_manager._SequenceManager._get\") as mck:              sequence_id = SequenceId(\"SEQUENCE_id\")              tp.get(sequence_id)              mck.assert_called_once_with(sequence_id)        def test_get_sequences(self):          with mock.patch(\"src.taipy.core.sequence._sequence_manager._SequenceManager._get_all\") as mck:              tp.get_sequences()              mck.assert_called_once_with()        def test_sequence_exists(self):          with mock.patch(\"src.taipy.core.sequence._sequence_manager._SequenceManager._exists\") as mck:              sequence_id = SequenceId(\"SEQUENCE_id\")              tp.exists(sequence_id)              mck.assert_called_once_with(sequence_id)        def test_get_job(self):          with mock.patch(\"src.taipy.core.job._job_manager._JobManager._get\") as mck:              job_id = JobId(\"JOB_id\")              tp.get(job_id)              mck.assert_called_once_with(job_id)        def test_get_jobs(self):          with mock.patch(\"src.taipy.core.job._job_manager._JobManager._get_all\") as mck:              tp.get_jobs()              mck.assert_called_once_with()        def test_job_exists(self):          with mock.patch(\"src.taipy.core.job._job_manager._JobManager._exists\") as mck:              job_id = JobId(\"JOB_id\")              tp.exists(job_id)              mck.assert_called_once_with(job_id)        def test_delete_job(self, task):          with mock.patch(\"src.taipy.core.job._job_manager._JobManager._delete\") as mck:              job = Job(JobId(\"job_id\"), task, \"submit_id\", \"scenario_id\")              tp.delete_job(job)              mck.assert_called_once_with(job, False)          with mock.patch(\"src.taipy.core.job._job_manager._JobManager._delete\") as mck:              job = Job(JobId(\"job_id\"), task, \"submit_id\", \"scenario_id\")              tp.delete_job(job, False)              mck.assert_called_once_with(job, False)          with mock.patch(\"src.taipy.core.job._job_manager._JobManager._delete\") as mck:              job = Job(JobId(\"job_id\"), task, \"submit_id\", \"scenario_id\")              tp.delete_job(job, True)              mck.assert_called_once_with(job, True)        def test_delete_jobs(self):          with mock.patch(\"src.taipy.core.job._job_manager._JobManager._delete_all\") as mck:              tp.delete_jobs()              mck.assert_called_once_with()        def test_get_latest_job(self, task):          with mock.patch(\"src.taipy.core.job._job_manager._JobManager._get_latest\") as mck:              tp.get_latest_job(task)              mck.assert_called_once_with(task)        def test_get_latest_submission(self, task):          with mock.patch(\"src.taipy.core.submission._submission_manager._SubmissionManager._get_latest\") as mck:              tp.get_latest_submission(task)              mck.assert_called_once_with(task)        def test_cancel_job(self):          with mock.patch(\"src.taipy.core.job._job_manager._JobManager._cancel\") as mck:              tp.cancel_job(\"job_id\")              mck.assert_called_once_with(\"job_id\")        def test_block_config_when_core_is_running_in_development_mode(self):          input_cfg_1 = Config.configure_data_node(id=\"i1\", storage_type=\"pickle\", default_data=1, scope=Scope.SCENARIO)          output_cfg_1 = Config.configure_data_node(id=\"o1\", storage_type=\"pickle\", scope=Scope.SCENARIO)          task_cfg_1 = Config.configure_task(\"t1\", print, input_cfg_1, output_cfg_1)          scenario_cfg_1 = Config.configure_scenario(\"s1\", [task_cfg_1], [], Frequency.DAILY)            with mock.patch(\"sys.argv\", [\"prog\"]):              core = Core()              core.run()            scenario_1 = tp.create_scenario(scenario_cfg_1)          tp.submit(scenario_1)            with pytest.raises(ConfigurationUpdateBlocked):              Config.configure_scenario(\"block_scenario\", set([task_cfg_1]))          core.stop()        def test_block_config_when_core_is_running_in_standalone_mode(self):          Config.configure_job_executions(mode=JobConfig._STANDALONE_MODE)            input_cfg_1 = Config.configure_data_node(id=\"i1\", storage_type=\"pickle\", default_data=1, scope=Scope.SCENARIO)          output_cfg_1 = Config.configure_data_node(id=\"o1\", storage_type=\"pickle\", scope=Scope.SCENARIO)          task_cfg_1 = Config.configure_task(\"t1\", print, input_cfg_1, output_cfg_1)          scenario_cfg_1 = Config.configure_scenario(\"s1\", [task_cfg_1], [], Frequency.DAILY)            with mock.patch(\"sys.argv\", [\"prog\"]):              core = Core()              core.run()            scenario_1 = tp.create_scenario(scenario_cfg_1)          tp.submit(scenario_1, wait=True)            with pytest.raises(ConfigurationUpdateBlocked):              Config.configure_scenario(\"block_scenario\", set([task_cfg_1]))          core.stop()        def test_get_data_node(self, data_node):          with mock.patch(\"src.taipy.core.data._data_manager._DataManager._get\") as mck:              tp.get(data_node.id)              mck.assert_called_once_with(data_node.id)        def test_get_data_nodes(self):          with mock.patch(\"src.taipy.core.data._data_manager._DataManager._get_all\") as mck:              tp.get_data_nodes()              mck.assert_called_once_with()        def test_data_node_exists(self):          with mock.patch(\"src.taipy.core.data._data_manager._DataManager._exists\") as mck:              data_node_id = DataNodeId(\"DATANODE_id\")              tp.exists(data_node_id)              mck.assert_called_once_with(data_node_id)        def test_get_cycles(self):          with mock.patch(\"src.taipy.core.cycle._cycle_manager._CycleManager._get_all\") as mck:              tp.get_cycles()              mck.assert_called_once_with()        def test_cycle_exists(self):          with mock.patch(\"src.taipy.core.cycle._cycle_manager._CycleManager._exists\") as mck:              cycle_id = CycleId(\"CYCLE_id\")              tp.exists(cycle_id)              mck.assert_called_once_with(cycle_id)        def test_create_global_data_node(self):          dn_cfg = DataNodeConfig(\"id\", \"pickle\", Scope.GLOBAL)          with mock.patch(\"src.taipy.core.data._data_manager._DataManager._create_and_set\") as mck:              dn = tp.create_global_data_node(dn_cfg)              mck.assert_called_once_with(dn_cfg, None, None)            dn = tp.create_global_data_node(dn_cfg)          assert dn.scope == Scope.GLOBAL          assert dn.config_id == dn_cfg.id            # Create a global data node from the same configuration should return the same data node          dn_2 = tp.create_global_data_node(dn_cfg)          assert dn_2.id == dn.id            dn_cfg.scope = Scope.SCENARIO          with pytest.raises(DataNodeConfigIsNotGlobal):              tp.create_global_data_node(dn_cfg)        def test_create_scenario(self, scenario):          scenario_config = ScenarioConfig(\"scenario_config\")          with mock.patch(\"src.taipy.core.scenario._scenario_manager._ScenarioManager._create\") as mck:              tp.create_scenario(scenario_config)              mck.assert_called_once_with(scenario_config, None, None)          with mock.patch(\"src.taipy.core.scenario._scenario_manager._ScenarioManager._create\") as mck:              tp.create_scenario(scenario_config, datetime.datetime(2022, 2, 5))              mck.assert_called_once_with(scenario_config, datetime.datetime(2022, 2, 5), None)          with mock.patch(\"src.taipy.core.scenario._scenario_manager._ScenarioManager._create\") as mck:              tp.create_scenario(scenario_config, datetime.datetime(2022, 2, 5), \"displayable_name\")              mck.assert_called_once_with(scenario_config, datetime.datetime(2022, 2, 5), \"displayable_name\")        def test_export_scenario_filesystem(self):          shutil.rmtree(\"./tmp\", ignore_errors=True)            input_cfg_1 = Config.configure_data_node(id=\"i1\", storage_type=\"pickle\", default_data=1, scope=Scope.SCENARIO)          output_cfg_1 = Config.configure_data_node(id=\"o1\", storage_type=\"pickle\", scope=Scope.SCENARIO)          task_cfg_1 = Config.configure_task(\"t1\", print, input_cfg_1, output_cfg_1)          scenario_cfg_1 = Config.configure_scenario(\"s1\", [task_cfg_1], [], Frequency.DAILY)            input_cfg_2 = Config.configure_data_node(id=\"i2\", storage_type=\"pickle\", default_data=2, scope=Scope.SCENARIO)          output_cfg_2 = Config.configure_data_node(id=\"o2\", storage_type=\"pickle\", scope=Scope.SCENARIO)          task_cfg_2 = Config.configure_task(\"t2\", print, input_cfg_2, output_cfg_2)          scenario_cfg_2 = Config.configure_scenario(\"s2\", [task_cfg_2], [], Frequency.DAILY)            scenario_1 = tp.create_scenario(scenario_cfg_1)          job_1 = tp.submit(scenario_1)[0]            # Export scenario 1          tp.export_scenario(scenario_1.id, \"./tmp/exp_scenario_1\")          assert sorted(os.listdir(\"./tmp/exp_scenario_1/data_nodes\")) == sorted(              [f\"{scenario_1.i1.id}.json\", f\"{scenario_1.o1.id}.json\"]          )          assert sorted(os.listdir(\"./tmp/exp_scenario_1/tasks\")) == sorted([f\"{scenario_1.t1.id}.json\"])          assert sorted(os.listdir(\"./tmp/exp_scenario_1/scenarios\")) == sorted([f\"{scenario_1.id}.json\"])          assert sorted(os.listdir(\"./tmp/exp_scenario_1/jobs\")) == sorted([f\"{job_1.id}.json\"])          assert sorted(os.listdir(\"./tmp/exp_scenario_1/cycles\")) == sorted([f\"{scenario_1.cycle.id}.json\"])            scenario_2 = tp.create_scenario(scenario_cfg_2)          job_2 = tp.submit(scenario_2)[0]            # Export scenario 2          scenario_2.export(pathlib.Path.cwd() / \"./tmp/exp_scenario_2\")          assert sorted(os.listdir(\"./tmp/exp_scenario_2/data_nodes\")) == sorted(              [f\"{scenario_2.i2.id}.json\", f\"{scenario_2.o2.id}.json\"]          )          assert sorted(os.listdir(\"./tmp/exp_scenario_2/tasks\")) == sorted([f\"{scenario_2.t2.id}.json\"])          assert sorted(os.listdir(\"./tmp/exp_scenario_2/scenarios\")) == sorted([f\"{scenario_2.id}.json\"])          assert sorted(os.listdir(\"./tmp/exp_scenario_2/jobs\")) == sorted([f\"{job_2.id}.json\"])          assert sorted(os.listdir(\"./tmp/exp_scenario_2/cycles\")) == sorted([f\"{scenario_2.cycle.id}.json\"])            # Export scenario 2 into the folder containing scenario 1 files          tp.export_scenario(scenario_2.id, \"./tmp/exp_scenario_1\")          # Should have the files as scenario 1 only          assert sorted(os.listdir(\"./tmp/exp_scenario_1/tasks\")) == sorted([f\"{scenario_2.t2.id}.json\"])          assert sorted(os.listdir(\"./tmp/exp_scenario_1/scenarios\")) == sorted([f\"{scenario_2.id}.json\"])          assert sorted(os.listdir(\"./tmp/exp_scenario_1/jobs\")) == sorted([f\"{job_2.id}.json\"])          assert sorted(os.listdir(\"./tmp/exp_scenario_1/cycles\")) == sorted([f\"{scenario_2.cycle.id}.json\"])            with pytest.raises(InvalidExportPath):              tp.export_scenario(scenario_2.id, Config.core.storage_folder)            shutil.rmtree(\"./tmp\", ignore_errors=True)        def test_get_parents(self):          def assert_result_parents_and_expected_parents(parents, expected_parents):              for key, items in expected_parents.items():                  assert len(parents[key]) == len(expected_parents[key])                  parent_ids = [parent.id for parent in parents[key]]                  assert all([item.id in parent_ids for item in items])            dn_config_1 = Config.configure_data_node(id=\"d1\", storage_type=\"in_memory\", scope=Scope.SCENARIO)          dn_config_2 = Config.configure_data_node(id=\"d2\", storage_type=\"in_memory\", scope=Scope.SCENARIO)          dn_config_3 = Config.configure_data_node(id=\"d3\", storage_type=\"in_memory\", scope=Scope.SCENARIO)          dn_config_4 = Config.configure_data_node(id=\"d4\", storage_type=\"in_memory\", scope=Scope.SCENARIO)          task_config_1 = Config.configure_task(\"t1\", print, dn_config_1, dn_config_2)          task_config_2 = Config.configure_task(\"t2\", print, dn_config_2, dn_config_3)          scenario_cfg_1 = Config.configure_scenario(\"s1\", [task_config_1, task_config_2], [dn_config_4], Frequency.DAILY)            scenario = tp.create_scenario(scenario_cfg_1)          tasks = scenario.tasks            expected_parents = {              \"scenario\": {scenario},              \"task\": {tasks[\"t1\"]},          }          parents = tp.get_parents(scenario.tasks[\"t1\"].data_nodes[\"d1\"])          assert_result_parents_and_expected_parents(parents, expected_parents)            expected_parents = {              \"scenario\": {scenario},              \"task\": {tasks[\"t1\"], tasks[\"t2\"]},          }          parents = tp.get_parents(scenario.tasks[\"t1\"].data_nodes[\"d2\"])          assert_result_parents_and_expected_parents(parents, expected_parents)            expected_parents = {\"scenario\": {scenario}, \"task\": {tasks[\"t2\"]}}          parents = tp.get_parents(scenario.tasks[\"t2\"].data_nodes[\"d3\"])          assert_result_parents_and_expected_parents(parents, expected_parents)            expected_parents = {\"scenario\": {scenario}}          parents = tp.get_parents(scenario.tasks[\"t1\"])          assert_result_parents_and_expected_parents(parents, expected_parents)            expected_parents = {\"scenario\": {scenario}}          parents = tp.get_parents(scenario.tasks[\"t2\"])          assert_result_parents_and_expected_parents(parents, expected_parents)            expected_parents = {\"scenario\": {scenario}}          parents = tp.get_parents(scenario.additional_data_nodes[\"d4\"])          assert_result_parents_and_expected_parents(parents, expected_parents)            expected_parents = {}          parents = tp.get_parents(scenario)          assert_result_parents_and_expected_parents(parents, expected_parents)            expected_parents = {}          parents = tp.get_parents(scenario.cycle)          assert_result_parents_and_expected_parents(parents, expected_parents)        def test_get_cycles_scenarios(self):          scenario_cfg_1 = Config.configure_scenario(              \"s1\",              set(),              set(),              Frequency.DAILY,          )          scenario_cfg_2 = Config.configure_scenario(\"s2\", set(), set(), Frequency.WEEKLY)          scenario_cfg_3 = Config.configure_scenario(\"s3\", set(), set(), Frequency.MONTHLY)          scenario_cfg_4 = Config.configure_scenario(\"s4\", set(), set(), Frequency.YEARLY)          scenario_cfg_5 = Config.configure_scenario(\"s5\", set(), set(), None)            now = datetime.datetime.now()          scenario_1_1 = tp.create_scenario(scenario_cfg_1, now)          scenario_1_2 = tp.create_scenario(scenario_cfg_1, datetime.datetime.now())          scenario_1_3 = tp.create_scenario(scenario_cfg_1, now + datetime.timedelta(days=1))          scenario_1_4 = tp.create_scenario(scenario_cfg_1, now + datetime.timedelta(days=8))          scenario_1_5 = tp.create_scenario(scenario_cfg_1, now + datetime.timedelta(days=25))          scenario_2 = tp.create_scenario(scenario_cfg_2)          scenario_3 = tp.create_scenario(scenario_cfg_3)          scenario_4 = tp.create_scenario(scenario_cfg_4)          scenario_5_1 = tp.create_scenario(scenario_cfg_5)          scenario_5_2 = tp.create_scenario(scenario_cfg_5)          scenario_5_3 = tp.create_scenario(scenario_cfg_5)            expected_cycles_scenarios = {              scenario_1_1.cycle: [scenario_1_1.id, scenario_1_2.id],              scenario_1_3.cycle: [scenario_1_3.id],              scenario_1_4.cycle: [scenario_1_4.id],              scenario_1_5.cycle: [scenario_1_5.id],              scenario_2.cycle: [scenario_2.id],              scenario_3.cycle: [scenario_3.id],              scenario_4.cycle: [scenario_4.id],              None: [scenario_5_1.id, scenario_5_2.id, scenario_5_3.id],          }            cycles_scenarios = tp.get_cycles_scenarios()            assert expected_cycles_scenarios.keys() == cycles_scenarios.keys()          for cycle, scenarios in cycles_scenarios.items():              expected_scenarios = expected_cycles_scenarios[cycle]              assert sorted([scenario.id for scenario in scenarios]) == sorted(expected_scenarios)        def test_get_entities_by_config_id(self):          scenario_config_1 = Config.configure_scenario(\"s1\", sequence_configs=[])          scenario_config_2 = Config.configure_scenario(\"s2\", sequence_configs=[])            s_1_1 = tp.create_scenario(scenario_config_1)          s_1_2 = tp.create_scenario(scenario_config_1)          s_1_3 = tp.create_scenario(scenario_config_1)            assert len(tp.get_scenarios()) == 3            s_2_1 = tp.create_scenario(scenario_config_2)          s_2_2 = tp.create_scenario(scenario_config_2)          assert len(tp.get_scenarios()) == 5            s1_scenarios = tp.get_entities_by_config_id(scenario_config_1.id)          assert len(s1_scenarios) == 3          assert sorted([s_1_1.id, s_1_2.id, s_1_3.id]) == sorted([scenario.id for scenario in s1_scenarios])            s2_scenarios = tp.get_entities_by_config_id(scenario_config_2.id)          assert len(s2_scenarios) == 2          assert sorted([s_2_1.id, s_2_2.id]) == sorted([scenario.id for scenario in s2_scenarios])        def test_get_entities_by_config_id_in_multiple_versions_environment(self):          scenario_config_1 = Config.configure_scenario(\"s1\", sequence_configs=[])          scenario_config_2 = Config.configure_scenario(\"s2\", sequence_configs=[])            _VersionManager._set_experiment_version(\"1.0\")          tp.create_scenario(scenario_config_1)          tp.create_scenario(scenario_config_1)          tp.create_scenario(scenario_config_1)          tp.create_scenario(scenario_config_2)          tp.create_scenario(scenario_config_2)          assert len(tp.get_scenarios()) == 5          assert len(tp.get_entities_by_config_id(scenario_config_1.id)) == 3          assert len(tp.get_entities_by_config_id(scenario_config_2.id)) == 2            _VersionManager._set_experiment_version(\"2.0\")          tp.create_scenario(scenario_config_1)          tp.create_scenario(scenario_config_1)          tp.create_scenario(scenario_config_1)          tp.create_scenario(scenario_config_2)          tp.create_scenario(scenario_config_2)          assert len(tp.get_scenarios()) == 5          assert len(tp.get_entities_by_config_id(scenario_config_1.id)) == 3          assert len(tp.get_entities_by_config_id(scenario_config_2.id)) == 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": "import os  from unittest.mock import patch    import pytest    from src.taipy.core import Core  from src.taipy.core.data._data_manager import _DataManager  from src.taipy.core.data.csv import CSVDataNode  from src.taipy.core.data.excel import ExcelDataNode  from src.taipy.core.data.json import JSONDataNode  from src.taipy.core.data.parquet import ParquetDataNode  from src.taipy.core.data.pickle import PickleDataNode  from taipy.config.config import Config      def read_backup_file(path):      with open(path, \"r\") as f:          lines = f.readlines()      return lines      @pytest.fixture(scope=\"function\", autouse=True)  def init_backup_file():      os.environ[\"TAIPY_BACKUP_FILE_PATH\"] = \".taipy_backups\"      if os.path.exists(os.environ[\"TAIPY_BACKUP_FILE_PATH\"]):          os.remove(os.environ[\"TAIPY_BACKUP_FILE_PATH\"])        yield        if os.path.exists(\".taipy_backups\"):          os.remove(\".taipy_backups\")      del os.environ[\"TAIPY_BACKUP_FILE_PATH\"]      backup_file_path = \".taipy_backups\"      def test_backup_storage_folder_when_core_run():      with patch(\"sys.argv\", [\"prog\"]):          core = Core()          core.run()      backup_files = read_backup_file(backup_file_path)      assert backup_files == [f\"{Config.core.storage_folder}\\n\"]      core.stop()      def test_no_new_entry_when_file_is_in_storage_folder():      dn_cfg_1 = Config.configure_data_node(\"dn_cfg_1\", path=\"dn_1.pickle\")      dn_cfg_2 = Config.configure_data_node(\"dn_cfg_2\")  # stored in .data folder        dn_1 = _DataManager._create_and_set(dn_cfg_1, None, None)      dn_2 = _DataManager._create_and_set(dn_cfg_2, None, None)        dn_1.write(\"DN1_CONTENT\")      dn_2.write(\"DN2_CONTENT\")        backup_files = read_backup_file(backup_file_path)      assert backup_files == [f\"{dn_1.path}\\n\"]      os.remove(dn_1.path)      def test_backup_csv_files():      dn_cfg_1 = Config.configure_data_node(\"dn_cfg_1\", \"csv\", path=\"example_1.csv\")      dn_cfg_2 = Config.configure_data_node(\"dn_cfg_2\", \"csv\", path=\"example_2.csv\")        csv_dn_1 = _DataManager._create_and_set(dn_cfg_1, None, None)      assert isinstance(csv_dn_1, CSVDataNode)        backup_files = read_backup_file(backup_file_path)      assert backup_files == [f\"{csv_dn_1.path}\\n\"]        csv_dn_2 = _DataManager._create_and_set(dn_cfg_2, None, None)      assert isinstance(csv_dn_2, CSVDataNode)        backup_files = read_backup_file(backup_file_path)      assert backup_files == [f\"{csv_dn_1.path}\\n\", f\"{csv_dn_2.path}\\n\"]        csv_dn_1.path = \"example_3.csv\"      backup_files = read_backup_file(backup_file_path)      assert backup_files == [f\"{csv_dn_2.path}\\n\", f\"{csv_dn_1.path}\\n\"]        csv_dn_2.path = \"example_4.csv\"      backup_files = read_backup_file(backup_file_path)      assert backup_files == [f\"{csv_dn_1.path}\\n\", f\"{csv_dn_2.path}\\n\"]        _DataManager._delete(csv_dn_1.id)        backup_files = read_backup_file(backup_file_path)      assert backup_files == [f\"{csv_dn_2.path}\\n\"]        csv_dn_3 = _DataManager._create_and_set(dn_cfg_1, None, None)      csv_dn_4 = _DataManager._create_and_set(dn_cfg_1, None, None)      assert isinstance(csv_dn_3, CSVDataNode)      assert isinstance(csv_dn_4, CSVDataNode)        backup_files = read_backup_file(backup_file_path)      assert backup_files == [f\"{csv_dn_2.path}\\n\", f\"{csv_dn_3.path}\\n\", f\"{csv_dn_4.path}\\n\"]        csv_dn_4.path = \"example_5.csv\"      backup_files = read_backup_file(backup_file_path)      assert backup_files == [f\"{csv_dn_2.path}\\n\", f\"{csv_dn_3.path}\\n\", f\"{csv_dn_4.path}\\n\"]        _DataManager._delete_all()        backup_files = read_backup_file(backup_file_path)      assert backup_files == []      def test_backup_excel_files():      dn_cfg_1 = Config.configure_data_node(\"dn_cfg_1\", \"excel\", path=\"example_1.xlsx\")      dn_cfg_2 = Config.configure_data_node(\"dn_cfg_2\", \"excel\", path=\"example_2.xlsx\")        excel_dn_1 = _DataManager._create_and_set(dn_cfg_1, None, None)      assert isinstance(excel_dn_1, ExcelDataNode)        backup_files = read_backup_file(backup_file_path)      assert backup_files == [f\"{excel_dn_1.path}\\n\"]        excel_dn_2 = _DataManager._create_and_set(dn_cfg_2, None, None)      assert isinstance(excel_dn_2, ExcelDataNode)        backup_files = read_backup_file(backup_file_path)      assert backup_files == [f\"{excel_dn_1.path}\\n\", f\"{excel_dn_2.path}\\n\"]        excel_dn_1.path = \"example_3.excel\"      backup_files = read_backup_file(backup_file_path)      assert backup_files == [f\"{excel_dn_2.path}\\n\", f\"{excel_dn_1.path}\\n\"]        excel_dn_2.path = \"example_4.excel\"      backup_files = read_backup_file(backup_file_path)      assert backup_files == [f\"{excel_dn_1.path}\\n\", f\"{excel_dn_2.path}\\n\"]        _DataManager._delete(excel_dn_1.id)        backup_files = read_backup_file(backup_file_path)      assert backup_files == [f\"{excel_dn_2.path}\\n\"]        excel_dn_3 = _DataManager._create_and_set(dn_cfg_1, None, None)      excel_dn_4 = _DataManager._create_and_set(dn_cfg_1, None, None)      assert isinstance(excel_dn_3, ExcelDataNode)      assert isinstance(excel_dn_4, ExcelDataNode)        backup_files = read_backup_file(backup_file_path)      assert backup_files == [f\"{excel_dn_2.path}\\n\", f\"{excel_dn_3.path}\\n\", f\"{excel_dn_4.path}\\n\"]        excel_dn_4.path = \"example_5.excel\"      backup_files = read_backup_file(backup_file_path)      assert backup_files == [f\"{excel_dn_2.path}\\n\", f\"{excel_dn_3.path}\\n\", f\"{excel_dn_4.path}\\n\"]        _DataManager._delete_all()        backup_files = read_backup_file(backup_file_path)      assert backup_files == []      def test_backup_pickle_files():      dn_cfg_1 = Config.configure_data_node(\"dn_cfg_1\", \"pickle\", path=\"example_1.p\")      dn_cfg_2 = Config.configure_data_node(\"dn_cfg_2\", \"pickle\", path=\"example_2.p\")        pickle_dn_1 = _DataManager._create_and_set(dn_cfg_1, None, None)      assert isinstance(pickle_dn_1, PickleDataNode)        backup_files = read_backup_file(backup_file_path)      assert backup_files == [f\"{pickle_dn_1.path}\\n\"]        pickle_dn_2 = _DataManager._create_and_set(dn_cfg_2, None, None)      assert isinstance(pickle_dn_2, PickleDataNode)        backup_files = read_backup_file(backup_file_path)      assert backup_files == [f\"{pickle_dn_1.path}\\n\", f\"{pickle_dn_2.path}\\n\"]        pickle_dn_1.path = \"example_3.pickle\"      backup_files = read_backup_file(backup_file_path)      assert backup_files == [f\"{pickle_dn_2.path}\\n\", f\"{pickle_dn_1.path}\\n\"]        pickle_dn_2.path = \"example_4.pickle\"      backup_files = read_backup_file(backup_file_path)      assert backup_files == [f\"{pickle_dn_1.path}\\n\", f\"{pickle_dn_2.path}\\n\"]        _DataManager._delete(pickle_dn_1.id)        backup_files = read_backup_file(backup_file_path)      assert backup_files == [f\"{pickle_dn_2.path}\\n\"]        pickle_dn_3 = _DataManager._create_and_set(dn_cfg_1, None, None)      pickle_dn_4 = _DataManager._create_and_set(dn_cfg_1, None, None)      assert isinstance(pickle_dn_3, PickleDataNode)      assert isinstance(pickle_dn_4, PickleDataNode)        backup_files = read_backup_file(backup_file_path)      assert backup_files == [f\"{pickle_dn_2.path}\\n\", f\"{pickle_dn_3.path}\\n\", f\"{pickle_dn_4.path}\\n\"]        pickle_dn_4.path = \"example_5.pickle\"      backup_files = read_backup_file(backup_file_path)      assert backup_files == [f\"{pickle_dn_2.path}\\n\", f\"{pickle_dn_3.path}\\n\", f\"{pickle_dn_4.path}\\n\"]        _DataManager._delete_all()        backup_files = read_backup_file(backup_file_path)      assert backup_files == []      def test_backup_json_files():      dn_cfg_1 = Config.configure_data_node(\"dn_cfg_1\", \"json\", path=\"example_1.json\")      dn_cfg_2 = Config.configure_data_node(\"dn_cfg_2\", \"json\", path=\"example_2.json\")        json_dn_1 = _DataManager._create_and_set(dn_cfg_1, None, None)      assert isinstance(json_dn_1, JSONDataNode)        backup_files = read_backup_file(backup_file_path)      assert backup_files == [f\"{json_dn_1.path}\\n\"]        json_dn_2 = _DataManager._create_and_set(dn_cfg_2, None, None)      assert isinstance(json_dn_2, JSONDataNode)        backup_files = read_backup_file(backup_file_path)      assert backup_files == [f\"{json_dn_1.path}\\n\", f\"{json_dn_2.path}\\n\"]        json_dn_1.path = \"example_3.json\"      backup_files = read_backup_file(backup_file_path)      assert backup_files == [f\"{json_dn_2.path}\\n\", f\"{json_dn_1.path}\\n\"]        json_dn_2.path = \"example_4.json\"      backup_files = read_backup_file(backup_file_path)      assert backup_files == [f\"{json_dn_1.path}\\n\", f\"{json_dn_2.path}\\n\"]        _DataManager._delete(json_dn_1.id)        backup_files = read_backup_file(backup_file_path)      assert backup_files == [f\"{json_dn_2.path}\\n\"]        json_dn_3 = _DataManager._create_and_set(dn_cfg_1, None, None)      json_dn_4 = _DataManager._create_and_set(dn_cfg_1, None, None)      assert isinstance(json_dn_3, JSONDataNode)      assert isinstance(json_dn_4, JSONDataNode)        backup_files = read_backup_file(backup_file_path)      assert backup_files == [f\"{json_dn_2.path}\\n\", f\"{json_dn_3.path}\\n\", f\"{json_dn_4.path}\\n\"]        json_dn_4.path = \"example_5.json\"      backup_files = read_backup_file(backup_file_path)      assert backup_files == [f\"{json_dn_2.path}\\n\", f\"{json_dn_3.path}\\n\", f\"{json_dn_4.path}\\n\"]        _DataManager._delete_all()        backup_files = read_backup_file(backup_file_path)      assert backup_files == []      def test_backup_parquet_files():      dn_cfg_1 = Config.configure_data_node(\"dn_cfg_1\", \"parquet\", path=\"example_1.parquet\")      dn_cfg_2 = Config.configure_data_node(\"dn_cfg_2\", \"parquet\", path=\"example_2.parquet\")        parquet_dn_1 = _DataManager._create_and_set(dn_cfg_1, None, None)      assert isinstance(parquet_dn_1, ParquetDataNode)        backup_files = read_backup_file(backup_file_path)      assert backup_files == [f\"{parquet_dn_1.path}\\n\"]        parquet_dn_2 = _DataManager._create_and_set(dn_cfg_2, None, None)      assert isinstance(parquet_dn_2, ParquetDataNode)        backup_files = read_backup_file(backup_file_path)      assert backup_files == [f\"{parquet_dn_1.path}\\n\", f\"{parquet_dn_2.path}\\n\"]        parquet_dn_1.path = \"example_3.parquet\"      backup_files = read_backup_file(backup_file_path)      assert backup_files == [f\"{parquet_dn_2.path}\\n\", f\"{parquet_dn_1.path}\\n\"]        parquet_dn_2.path = \"example_4.parquet\"      backup_files = read_backup_file(backup_file_path)      assert backup_files == [f\"{parquet_dn_1.path}\\n\", f\"{parquet_dn_2.path}\\n\"]        _DataManager._delete(parquet_dn_1.id)        backup_files = read_backup_file(backup_file_path)      assert backup_files == [f\"{parquet_dn_2.path}\\n\"]        parquet_dn_3 = _DataManager._create_and_set(dn_cfg_1, None, None)      parquet_dn_4 = _DataManager._create_and_set(dn_cfg_1, None, None)      assert isinstance(parquet_dn_3, ParquetDataNode)      assert isinstance(parquet_dn_4, ParquetDataNode)        backup_files = read_backup_file(backup_file_path)      assert backup_files == [f\"{parquet_dn_2.path}\\n\", f\"{parquet_dn_3.path}\\n\", f\"{parquet_dn_4.path}\\n\"]        parquet_dn_4.path = \"example_5.parquet\"      backup_files = read_backup_file(backup_file_path)      assert backup_files == [f\"{parquet_dn_2.path}\\n\", f\"{parquet_dn_3.path}\\n\", f\"{parquet_dn_4.path}\\n\"]        _DataManager._delete_all()        backup_files = read_backup_file(backup_file_path)      assert backup_files == []      def test_no_backup_if_no_env_var():      dn_cfg_1 = Config.configure_data_node(\"dn_cfg_1\", \"csv\", path=\"example_1.csv\")      _DataManager._create_and_set(dn_cfg_1, None, None) "}
{"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 json  from datetime import timedelta    from src.taipy.core.common.mongo_default_document import MongoDefaultDocument  from taipy.config.common.scope import Scope  from taipy.config.config import Config      def test_set_default_data_node_configuration():      data_node1 = Config.configure_data_node(id=\"input_data1\")      assert data_node1.storage_type == \"pickle\"      assert data_node1.scope == Scope.SCENARIO      assert data_node1.validity_period is None        Config.set_default_data_node_configuration(\"in_memory\", scope=Scope.GLOBAL)      data_node2 = Config.configure_data_node(id=\"input_data2\")      assert data_node2.storage_type == \"in_memory\"      assert data_node2.scope == Scope.GLOBAL      assert data_node2.validity_period is None        Config.set_default_data_node_configuration(\"csv\")      data_node3 = Config.configure_data_node(id=\"input_data3\")      assert data_node3.storage_type == \"csv\"      assert data_node3.scope == Scope.SCENARIO      assert data_node3.validity_period is None        Config.set_default_data_node_configuration(\"json\", validity_period=timedelta(1))      data_node4 = Config.configure_data_node(id=\"input_data4\")      assert data_node4.storage_type == \"json\"      assert data_node4.scope == Scope.SCENARIO      assert data_node4.validity_period == timedelta(1)      def test_set_default_data_node_configuration_replace_old_default_config():      Config.set_default_data_node_configuration(          \"in_memory\",          prop1=\"1\",          prop2=\"2\",          prop3=\"3\",      )      dn1 = Config.configure_data_node(id=\"dn1\")      assert len(dn1.properties) == 3        Config.set_default_data_node_configuration(          \"csv\",          prop4=\"4\",          prop5=\"5\",          prop6=\"6\",      )      dn2 = Config.configure_data_node(id=\"dn2\")      assert dn2.storage_type == \"csv\"      assert len(dn2.properties) == 6  # encoding, exposed_type, and has_header too      assert dn2.prop4 == \"4\"      assert dn2.prop5 == \"5\"      assert dn2.prop6 == \"6\"      assert dn2.prop1 is None      assert dn2.prop2 is None      assert dn2.prop3 is None      def test_config_storage_type_different_from_default_data_node():      Config.set_default_data_node_configuration(          storage_type=\"pickle\",          custom_property={\"foo\": \"bar\"},          scope=Scope.GLOBAL,      )        # Config a datanode with specific \"storage_type\" different than \"pickle\"      # should ignore the default datanode      csv_dn = Config.configure_data_node(id=\"csv_dn\", storage_type=\"csv\")      assert len(csv_dn.properties) == 3  # encoding, exposed_type, and has_header      assert csv_dn.properties.get(\"custom_property\") is None      assert csv_dn.scope == Scope.SCENARIO      def test_set_default_csv_data_node_configuration():      Config.set_default_data_node_configuration(          storage_type=\"csv\",          default_path=\"default.csv\",          has_header=False,          exposed_type=\"numpy\",          scope=Scope.GLOBAL,          validity_period=timedelta(2),      )        # Config with generic config_data_node without storage_type      # should return the default DataNode      dn1 = Config.configure_data_node(id=\"dn1\")      assert dn1.storage_type == \"csv\"      assert dn1.scope == Scope.GLOBAL      assert dn1.default_path == \"default.csv\"      assert dn1.has_header is False      assert dn1.exposed_type == \"numpy\"      assert dn1.validity_period == timedelta(2)        # Config with generic config_data_node without storage_type      # with custom properties      dn2 = Config.configure_data_node(id=\"dn2\", default_path=\"dn2.csv\")      assert dn2.storage_type == \"csv\"      assert dn2.default_path == \"dn2.csv\"      assert dn2.has_header is False      assert dn2.exposed_type == \"numpy\"      assert dn2.scope == Scope.GLOBAL      assert dn2.validity_period == timedelta(2)        # Config a datanode with specific \"storage_type\" = \"csv\"      # should use properties from the default datanode      dn3 = Config.configure_data_node(          id=\"dn3\",          storage_type=\"csv\",          default_path=\"dn3.csv\",          scope=Scope.SCENARIO,          validity_period=timedelta(1),      )      assert dn3.storage_type == \"csv\"      assert dn3.default_path == \"dn3.csv\"      assert dn3.has_header is False      assert dn3.exposed_type == \"numpy\"      assert dn3.scope == Scope.SCENARIO      assert dn3.validity_period == timedelta(1)      def test_set_default_json_data_node_configuration():      class MyCustomEncoder(json.JSONEncoder):          ...        class MyCustomDecoder(json.JSONDecoder):          ...        Config.set_default_data_node_configuration(          storage_type=\"json\",          default_path=\"default.json\",          encoder=MyCustomEncoder,          scope=Scope.GLOBAL,          validity_period=timedelta(2),      )        # Config with generic config_data_node without storage_type      # should return the default DataNode      dn1 = Config.configure_data_node(id=\"dn1\")      assert dn1.storage_type == \"json\"      assert dn1.default_path == \"default.json\"      assert dn1.encoder == MyCustomEncoder      assert dn1.decoder is None      assert dn1.scope == Scope.GLOBAL      assert dn1.validity_period == timedelta(2)        # Config with generic config_data_node without storage_type      # with custom properties      dn2 = Config.configure_data_node(id=\"dn2\", default_path=\"dn2.json\")      assert dn2.storage_type == \"json\"      assert dn2.default_path == \"dn2.json\"      assert dn2.encoder == MyCustomEncoder      assert dn2.decoder is None      assert dn2.scope == Scope.GLOBAL      assert dn2.validity_period == timedelta(2)        # Config a datanode with specific \"storage_type\" = \"json\"      # should use properties from the default datanode      dn3 = Config.configure_data_node(          id=\"dn3\",          storage_type=\"json\",          default_path=\"dn3.json\",          decoder=MyCustomDecoder,          validity_period=timedelta(1),      )      assert dn3.storage_type == \"json\"      assert dn3.default_path == \"dn3.json\"      assert dn3.encoder == MyCustomEncoder      assert dn3.decoder == MyCustomDecoder      assert dn3.scope == Scope.GLOBAL      assert dn3.validity_period == timedelta(1)      def test_set_default_parquet_data_node_configuration():      Config.set_default_data_node_configuration(          storage_type=\"parquet\",          default_path=\"default.parquet\",          compression=\"gzip\",          exposed_type=\"numpy\",          scope=Scope.GLOBAL,          validity_period=timedelta(2),      )        # Config with generic config_data_node without storage_type      # should return the default DataNode      dn1 = Config.configure_data_node(id=\"dn1\")      assert dn1.storage_type == \"parquet\"      assert dn1.default_path == \"default.parquet\"      assert dn1.engine == \"pyarrow\"      assert dn1.compression == \"gzip\"      assert dn1.read_kwargs is None      assert dn1.write_kwargs is None      assert dn1.exposed_type == \"numpy\"      assert dn1.scope == Scope.GLOBAL      assert dn1.validity_period == timedelta(2)        # Config with generic config_data_node without storage_type      # with custom properties      dn2 = Config.configure_data_node(          id=\"dn2\",          default_path=\"dn2.parquet\",          engine=\"fastparquet\",      )      assert dn2.storage_type == \"parquet\"      assert dn2.default_path == \"dn2.parquet\"      assert dn2.engine == \"fastparquet\"      assert dn2.compression == \"gzip\"      assert dn2.read_kwargs is None      assert dn2.write_kwargs is None      assert dn2.exposed_type == \"numpy\"      assert dn2.scope == Scope.GLOBAL      assert dn2.validity_period == timedelta(2)        # Config a datanode with specific \"storage_type\" = \"parquet\"      # should use properties from the default datanode      dn3 = Config.configure_data_node(          id=\"dn3\",          storage_type=\"parquet\",          default_path=\"dn3.parquet\",          read_kwargs={\"filter\": \"foo\"},          scope=Scope.SCENARIO,          validity_period=timedelta(1),      )      assert dn3.storage_type == \"parquet\"      assert dn3.default_path == \"dn3.parquet\"      assert dn3.engine == \"pyarrow\"      assert dn3.compression == \"gzip\"      assert dn3.read_kwargs == {\"filter\": \"foo\"}      assert dn3.write_kwargs is None      assert dn3.exposed_type == \"numpy\"      assert dn3.scope == Scope.SCENARIO      assert dn3.validity_period == timedelta(1)      def test_set_default_excel_data_node_configuration():      Config.set_default_data_node_configuration(          storage_type=\"excel\",          default_path=\"default.xlsx\",          has_header=False,          exposed_type=\"numpy\",          scope=Scope.GLOBAL,          validity_period=timedelta(2),      )        # Config with generic config_data_node without storage_type      # should return the default DataNode      dn1 = Config.configure_data_node(id=\"dn1\")      assert dn1.storage_type == \"excel\"      assert dn1.scope == Scope.GLOBAL      assert dn1.default_path == \"default.xlsx\"      assert dn1.has_header is False      assert dn1.sheet_name is None      assert dn1.exposed_type == \"numpy\"      assert dn1.validity_period == timedelta(2)        # Config with generic config_data_node without storage_type      # with custom properties      dn2 = Config.configure_data_node(id=\"dn2\", default_path=\"dn2.xlsx\", sheet_name=\"sheet_1\")      assert dn2.storage_type == \"excel\"      assert dn2.default_path == \"dn2.xlsx\"      assert dn2.has_header is False      assert dn2.sheet_name == \"sheet_1\"      assert dn2.exposed_type == \"numpy\"      assert dn2.scope == Scope.GLOBAL      assert dn2.validity_period == timedelta(2)        # Config a datanode with specific \"storage_type\" = \"excel\"      # should use properties from the default datanode      dn3 = Config.configure_data_node(          id=\"dn3\",          storage_type=\"excel\",          default_path=\"dn3.xlsx\",          scope=Scope.SCENARIO,          validity_period=timedelta(1),      )      assert dn3.storage_type == \"excel\"      assert dn3.default_path == \"dn3.xlsx\"      assert dn3.has_header is False      assert dn3.sheet_name is None      assert dn3.exposed_type == \"numpy\"      assert dn3.scope == Scope.SCENARIO      assert dn3.validity_period == timedelta(1)      def test_set_default_pickle_data_node_configuration():      Config.set_default_data_node_configuration(          storage_type=\"pickle\",          default_data=1,          exposed_type=\"numpy\",          scope=Scope.GLOBAL,          validity_period=timedelta(2),      )        # Config with generic config_data_node without storage_type      # should return the default DataNode      dn1 = Config.configure_data_node(id=\"dn1\")      assert dn1.storage_type == \"pickle\"      assert dn1.scope == Scope.GLOBAL      assert dn1.default_path is None      assert dn1.default_data == 1      assert dn1.exposed_type == \"numpy\"      assert dn1.validity_period == timedelta(2)        # Config with generic config_data_node without storage_type      # with custom properties      dn2 = Config.configure_data_node(id=\"dn2\", default_path=\"dn2.pkl\", default_data=2)      assert dn2.storage_type == \"pickle\"      assert dn2.default_path == \"dn2.pkl\"      assert dn2.default_data == 2      assert dn2.exposed_type == \"numpy\"      assert dn2.scope == Scope.GLOBAL      assert dn2.validity_period == timedelta(2)        # Config a datanode with specific \"storage_type\" = \"pickle\"      # should use properties from the default datanode      dn3 = Config.configure_data_node(          id=\"dn3\",          storage_type=\"pickle\",          default_path=\"dn3.pkl\",          scope=Scope.SCENARIO,          validity_period=timedelta(1),      )      assert dn3.storage_type == \"pickle\"      assert dn3.default_path == \"dn3.pkl\"      assert dn3.default_data == 1      assert dn3.exposed_type == \"numpy\"      assert dn3.scope == Scope.SCENARIO      assert dn3.validity_period == timedelta(1)      def test_set_default_sql_table_data_node_configuration():      Config.set_default_data_node_configuration(          storage_type=\"sql_table\",          db_username=\"default_user\",          db_password=\"default_pwd\",          db_name=\"default_db_name\",          db_engine=\"mssql\",          table_name=\"default_table\",          db_port=1010,          db_host=\"default_host\",          db_driver=\"default server\",          db_extra_args={\"default\": \"default\"},          scope=Scope.GLOBAL,          validity_period=timedelta(2),      )        # Config with generic config_data_node without storage_type      # should return the default DataNode      dn1 = Config.configure_data_node(id=\"dn1\")      assert dn1.storage_type == \"sql_table\"      assert dn1.db_username == \"default_user\"      assert dn1.db_password == \"default_pwd\"      assert dn1.db_name == \"default_db_name\"      assert dn1.db_engine == \"mssql\"      assert dn1.table_name == \"default_table\"      assert dn1.db_port == 1010      assert dn1.db_host == \"default_host\"      assert dn1.db_driver == \"default server\"      assert dn1.db_extra_args == {\"default\": \"default\"}      assert dn1.scope == Scope.GLOBAL      assert dn1.validity_period == timedelta(2)        # Config with generic config_data_node without storage_type      # with custom properties      dn2 = Config.configure_data_node(          id=\"dn2\",          table_name=\"table_2\",          db_port=2020,          db_host=\"host_2\",      )      assert dn2.storage_type == \"sql_table\"      assert dn2.db_username == \"default_user\"      assert dn2.db_password == \"default_pwd\"      assert dn2.db_name == \"default_db_name\"      assert dn2.db_engine == \"mssql\"      assert dn2.table_name == \"table_2\"      assert dn2.db_port == 2020      assert dn2.db_host == \"host_2\"      assert dn2.db_driver == \"default server\"      assert dn2.db_extra_args == {\"default\": \"default\"}      assert dn2.scope == Scope.GLOBAL      assert dn2.validity_period == timedelta(2)        # Config a datanode with specific \"storage_type\" = \"sql_table\"      # should use properties from the default datanode      dn3 = Config.configure_data_node(          id=\"dn3\",          storage_type=\"sql_table\",          db_username=\"user_3\",          db_password=\"pwd_3\",          db_name=\"db_3\",          db_engine=\"postgresql\",          table_name=\"table_3\",          validity_period=timedelta(1),      )      assert dn3.storage_type == \"sql_table\"      assert dn3.db_username == \"user_3\"      assert dn3.db_password == \"pwd_3\"      assert dn3.db_name == \"db_3\"      assert dn3.db_engine == \"postgresql\"      assert dn3.table_name == \"table_3\"      assert dn3.db_port == 1010      assert dn3.db_host == \"default_host\"      assert dn3.db_driver == \"default server\"      assert dn3.db_extra_args == {\"default\": \"default\"}      assert dn3.scope == Scope.GLOBAL      assert dn3.validity_period == timedelta(1)      def test_set_default_sql_data_node_configuration():      def query_builder():          ...        Config.set_default_data_node_configuration(          storage_type=\"sql\",          db_username=\"default_user\",          db_password=\"default_pwd\",          db_name=\"default_db_name\",          db_engine=\"mssql\",          read_query=\"SELECT * FROM default_table\",          write_query_builder=query_builder,          append_query_builder=query_builder,          db_port=1010,          db_host=\"default_host\",          db_driver=\"default server\",          db_extra_args={\"default\": \"default\"},          scope=Scope.GLOBAL,          validity_period=timedelta(2),      )        # Config with generic config_data_node without storage_type      # should return the default DataNode      dn1 = Config.configure_data_node(id=\"dn1\")      assert dn1.storage_type == \"sql\"      assert dn1.db_username == \"default_user\"      assert dn1.db_password == \"default_pwd\"      assert dn1.db_name == \"default_db_name\"      assert dn1.db_engine == \"mssql\"      assert dn1.read_query == \"SELECT * FROM default_table\"      assert dn1.write_query_builder == query_builder      assert dn1.append_query_builder == query_builder      assert dn1.db_port == 1010      assert dn1.db_host == \"default_host\"      assert dn1.db_driver == \"default server\"      assert dn1.db_extra_args == {\"default\": \"default\"}      assert dn1.scope == Scope.GLOBAL      assert dn1.validity_period == timedelta(2)        # Config with generic config_data_node without storage_type      # with custom properties      dn2 = Config.configure_data_node(          id=\"dn2\", table_name=\"table_2\", db_port=2020, db_host=\"host_2\", read_query=\"SELECT * FROM table_2\"      )      assert dn2.storage_type == \"sql\"      assert dn2.db_username == \"default_user\"      assert dn2.db_password == \"default_pwd\"      assert dn2.db_name == \"default_db_name\"      assert dn2.db_engine == \"mssql\"      assert dn2.read_query == \"SELECT * FROM table_2\"      assert dn2.write_query_builder == query_builder      assert dn2.append_query_builder == query_builder      assert dn2.db_port == 2020      assert dn2.db_host == \"host_2\"      assert dn2.db_driver == \"default server\"      assert dn2.db_extra_args == {\"default\": \"default\"}      assert dn2.scope == Scope.GLOBAL      assert dn2.validity_period == timedelta(2)        # Config a datanode with specific \"storage_type\" = \"sql\"      # should use properties from the default datanode      dn3 = Config.configure_data_node(          id=\"dn3\",          storage_type=\"sql\",          db_username=\"user_3\",          db_password=\"pwd_3\",          db_name=\"db_3\",          db_engine=\"postgresql\",          read_query=\"SELECT * FROM table_3\",          write_query_builder=query_builder,          validity_period=timedelta(1),      )      assert dn3.storage_type == \"sql\"      assert dn3.db_username == \"user_3\"      assert dn3.db_password == \"pwd_3\"      assert dn3.db_name == \"db_3\"      assert dn3.db_engine == \"postgresql\"      assert dn3.read_query == \"SELECT * FROM table_3\"      assert dn3.write_query_builder == query_builder      assert dn3.append_query_builder == query_builder      assert dn3.db_port == 1010      assert dn3.db_host == \"default_host\"      assert dn3.db_driver == \"default server\"      assert dn3.db_extra_args == {\"default\": \"default\"}      assert dn3.scope == Scope.GLOBAL      assert dn3.validity_period == timedelta(1)      def test_set_default_mongo_collection_data_node_configuration():      Config.set_default_data_node_configuration(          storage_type=\"mongo_collection\",          db_name=\"default_db_name\",          collection_name=\"default_collection\",          db_port=1010,          db_host=\"default_host\",          db_driver=\"default server\",          db_extra_args={\"default\": \"default\"},          scope=Scope.GLOBAL,          validity_period=timedelta(2),      )        # Config with generic config_data_node without storage_type      # should return the default DataNode      dn1 = Config.configure_data_node(id=\"dn1\")      assert dn1.storage_type == \"mongo_collection\"      assert dn1.db_username == \"\"      assert dn1.db_password == \"\"      assert dn1.db_name == \"default_db_name\"      assert dn1.collection_name == \"default_collection\"      assert dn1.custom_document == MongoDefaultDocument      assert dn1.db_host == \"default_host\"      assert dn1.db_port == 1010      assert dn1.db_driver == \"default server\"      assert dn1.db_extra_args == {\"default\": \"default\"}      assert dn1.scope == Scope.GLOBAL      assert dn1.validity_period == timedelta(2)        # Config with generic config_data_node without storage_type      # with custom properties      dn2 = Config.configure_data_node(          id=\"dn2\",          collection_name=\"collection_2\",          db_port=2020,          db_host=\"host_2\",      )      assert dn2.storage_type == \"mongo_collection\"      assert dn2.db_username == \"\"      assert dn2.db_password == \"\"      assert dn2.db_name == \"default_db_name\"      assert dn2.collection_name == \"collection_2\"      assert dn2.custom_document == MongoDefaultDocument      assert dn2.db_host == \"host_2\"      assert dn2.db_port == 2020      assert dn2.db_driver == \"default server\"      assert dn2.db_extra_args == {\"default\": \"default\"}      assert dn2.scope == Scope.GLOBAL      assert dn2.validity_period == timedelta(2)        # Config a datanode with specific \"storage_type\" = \"mongo_collection\"      # should use properties from the default datanode      dn3 = Config.configure_data_node(          id=\"dn3\",          storage_type=\"mongo_collection\",          db_name=\"db_3\",          collection_name=\"collection_3\",          db_username=\"user_3\",          db_password=\"pwd_3\",          validity_period=timedelta(1),      )      assert dn3.storage_type == \"mongo_collection\"      assert dn3.db_username == \"user_3\"      assert dn3.db_password == \"pwd_3\"      assert dn3.db_name == \"db_3\"      assert dn3.collection_name == \"collection_3\"      assert dn3.custom_document == MongoDefaultDocument      assert dn3.db_port == 1010      assert dn3.db_host == \"default_host\"      assert dn3.db_driver == \"default server\"      assert dn3.db_extra_args == {\"default\": \"default\"}      assert dn3.scope == Scope.GLOBAL      assert dn3.validity_period == timedelta(1) "}
{"text": "import os  from unittest import mock    from src.taipy.core.config import DataNodeConfig  from taipy.config.common.scope import Scope  from taipy.config.config import Config  from tests.core.utils.named_temporary_file import NamedTemporaryFile      def _configure_task_in_toml():      return NamedTemporaryFile(          content=\"\"\"  [TAIPY]    [DATA_NODE.input]    [DATA_NODE.output]    [TASK.tasks1]  function = \"builtins.print:function\"  inputs = [ \"input:SECTION\",]  outputs = [ \"output:SECTION\",]      \"\"\"      )      def _check_data_nodes_instance(dn_id, task_id):      \"\"\"Check if the data node instance in the task config correctly points to the Config._applied_config,      not the Config._python_config or the Config._file_config      \"\"\"      dn_config_applied_instance = Config.data_nodes[dn_id]      for dn in Config.tasks[task_id].inputs:          if dn.id == dn_id:              dn_config_instance_via_task = dn      for dn in Config.tasks[task_id].outputs:          if dn.id == dn_id:              dn_config_instance_via_task = dn        dn_config_python_instance = None      if Config._python_config._sections.get(\"DATA_NODE\", None):          dn_config_python_instance = Config._python_config._sections[\"DATA_NODE\"][dn_id]        dn_config_file_instance = None      if Config._file_config._sections.get(\"DATA_NODE\", None):          dn_config_file_instance = Config._file_config._sections[\"DATA_NODE\"][dn_id]        if dn_config_python_instance:          assert dn_config_python_instance.scope is None      assert dn_config_python_instance is not dn_config_applied_instance      assert dn_config_python_instance is not dn_config_instance_via_task        if dn_config_file_instance:          assert dn_config_file_instance.scope is None      assert dn_config_file_instance is not dn_config_applied_instance      assert dn_config_file_instance is not dn_config_instance_via_task        assert dn_config_applied_instance.scope == DataNodeConfig._DEFAULT_SCOPE      assert dn_config_instance_via_task is dn_config_applied_instance      def test_data_node_instance_when_configure_task_in_python():      input_config = Config.configure_data_node(\"input\")      output_config = Config.configure_data_node(\"output\")      Config.configure_task(\"tasks1\", print, input_config, output_config)        _check_data_nodes_instance(\"input\", \"tasks1\")      _check_data_nodes_instance(\"output\", \"tasks1\")      def test_data_node_instance_when_configure_task_by_loading_toml():      toml_config = _configure_task_in_toml()      Config.load(toml_config.filename)        _check_data_nodes_instance(\"input\", \"tasks1\")      _check_data_nodes_instance(\"output\", \"tasks1\")      def test_data_node_instance_when_configure_task_by_overriding_toml():      toml_config = _configure_task_in_toml()      Config.override(toml_config.filename)        _check_data_nodes_instance(\"input\", \"tasks1\")      _check_data_nodes_instance(\"output\", \"tasks1\")      def test_task_config_creation():      input_config = Config.configure_data_node(\"input\")      output_config = Config.configure_data_node(\"output\")      task_config = Config.configure_task(\"tasks1\", print, input_config, output_config)        assert not task_config.skippable      assert list(Config.tasks) == [\"default\", task_config.id]        task2 = Config.configure_task(\"tasks2\", print, input_config, output_config, skippable=True)      assert task2.skippable      assert list(Config.tasks) == [\"default\", task_config.id, task2.id]      def test_task_count():      input_config = Config.configure_data_node(\"input\")      output_config = Config.configure_data_node(\"output\")      Config.configure_task(\"tasks1\", print, input_config, output_config)      assert len(Config.tasks) == 2        Config.configure_task(\"tasks2\", print, input_config, output_config)      assert len(Config.tasks) == 3        Config.configure_task(\"tasks3\", print, input_config, output_config)      assert len(Config.tasks) == 4      def test_task_getitem():      input_config = Config.configure_data_node(\"input\")      output_config = Config.configure_data_node(\"output\")      task_id = \"tasks1\"      task_cfg = Config.configure_task(task_id, print, input_config, output_config)        assert Config.tasks[task_id].id == task_cfg.id      assert Config.tasks[task_id].properties == task_cfg.properties      assert Config.tasks[task_id].function == task_cfg.function      assert Config.tasks[task_id].input_configs == task_cfg.input_configs      assert Config.tasks[task_id].output_configs == task_cfg.output_configs      assert Config.tasks[task_id].skippable == task_cfg.skippable      def test_task_creation_no_duplication():      input_config = Config.configure_data_node(\"input\")      output_config = Config.configure_data_node(\"output\")      Config.configure_task(\"tasks1\", print, input_config, output_config)        assert len(Config.tasks) == 2        Config.configure_task(\"tasks1\", print, input_config, output_config)      assert len(Config.tasks) == 2      def test_task_config_with_env_variable_value():      input_config = Config.configure_data_node(\"input\")      output_config = Config.configure_data_node(\"output\")        with mock.patch.dict(os.environ, {\"FOO\": \"plop\", \"BAR\": \"baz\"}):          Config.configure_task(\"task_name\", print, input_config, output_config, prop=\"ENV[BAR]\")          assert Config.tasks[\"task_name\"].prop == \"baz\"          assert Config.tasks[\"task_name\"].properties[\"prop\"] == \"baz\"          assert Config.tasks[\"task_name\"]._properties[\"prop\"] == \"ENV[BAR]\"      def test_clean_config():      dn1 = Config.configure_data_node(\"dn1\")      dn2 = Config.configure_data_node(\"dn2\")      task1_config = Config.configure_task(\"id1\", print, dn1, dn2)      task2_config = Config.configure_task(\"id2\", print, dn2, dn1)        assert Config.tasks[\"id1\"] is task1_config      assert Config.tasks[\"id2\"] is task2_config        task1_config._clean()      task2_config._clean()        # Check if the instance before and after _clean() is the same      assert Config.tasks[\"id1\"] is task1_config      assert Config.tasks[\"id2\"] is task2_config        assert task1_config.id == \"id1\"      assert task2_config.id == \"id2\"      assert task1_config.function is task1_config.function is None      assert task1_config.inputs == task1_config.inputs == []      assert task1_config.input_configs == task1_config.input_configs == []      assert task1_config.outputs == task1_config.outputs == []      assert task1_config.output_configs == task1_config.output_configs == []      assert task1_config.skippable is task1_config.skippable is False      assert task1_config.properties == task1_config.properties == {}      def test_deprecated_cacheable_attribute_remains_compatible():      dn_1_id = \"dn_1_id\"      dn_1_config = Config.configure_data_node(          id=dn_1_id,          storage_type=\"pickle\",          cacheable=False,          scope=Scope.SCENARIO,      )      assert Config.data_nodes[dn_1_id].id == dn_1_id      assert Config.data_nodes[dn_1_id].storage_type == \"pickle\"      assert Config.data_nodes[dn_1_id].scope == Scope.SCENARIO      assert Config.data_nodes[dn_1_id].properties == {\"cacheable\": False}      assert not Config.data_nodes[dn_1_id].cacheable      dn_1_config.cacheable = True      assert Config.data_nodes[dn_1_id].properties == {\"cacheable\": True}      assert Config.data_nodes[dn_1_id].cacheable        dn_2_id = \"dn_2_id\"      dn_2_config = Config.configure_data_node(          id=dn_2_id,          storage_type=\"pickle\",          cacheable=True,          scope=Scope.SCENARIO,      )      assert Config.data_nodes[dn_2_id].id == dn_2_id      assert Config.data_nodes[dn_2_id].storage_type == \"pickle\"      assert Config.data_nodes[dn_2_id].scope == Scope.SCENARIO      assert Config.data_nodes[dn_2_id].properties == {\"cacheable\": True}      assert Config.data_nodes[dn_2_id].cacheable      dn_2_config.cacheable = False      assert Config.data_nodes[dn_1_id].properties == {\"cacheable\": False}      assert not Config.data_nodes[dn_1_id].cacheable        dn_3_id = \"dn_3_id\"      dn_3_config = Config.configure_data_node(          id=dn_3_id,          storage_type=\"pickle\",          scope=Scope.SCENARIO,      )      assert Config.data_nodes[dn_3_id].id == dn_3_id      assert Config.data_nodes[dn_3_id].storage_type == \"pickle\"      assert Config.data_nodes[dn_3_id].scope == Scope.SCENARIO      assert Config.data_nodes[dn_3_id].properties == {}      assert not Config.data_nodes[dn_3_id].cacheable      dn_3_config.cacheable = True      assert Config.data_nodes[dn_3_id].properties == {\"cacheable\": True}      assert Config.data_nodes[dn_3_id].cacheable "}
{"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": "import datetime  import json    from src.taipy.core.config import CoreSection, DataNodeConfig, JobConfig, MigrationConfig, ScenarioConfig, TaskConfig  from taipy.config import Config  from taipy.config._serializer._json_serializer import _JsonSerializer  from taipy.config.common.frequency import Frequency  from taipy.config.common.scope import Scope  from tests.core.utils.named_temporary_file import NamedTemporaryFile      def multiply(a):      return a * 2      def migrate_csv_path(dn):      dn.path = \"foo.csv\"      def compare_function(*data_node_results):      comparison_result = {}      current_result_index = 0      for current_result in data_node_results:          comparison_result[current_result_index] = {}          next_result_index = 0          for next_result in data_node_results:              print(f\"comparing result {current_result_index} with result {next_result_index}\")              comparison_result[current_result_index][next_result_index] = next_result - current_result              next_result_index += 1          current_result_index += 1      return comparison_result      class CustomClass:      a = None      b = None      class CustomEncoder(json.JSONEncoder):      def default(self, o):          if isinstance(o, datetime):              result = {\"__type__\": \"Datetime\", \"__value__\": o.isoformat()}          else:              result = json.JSONEncoder.default(self, o)          return result      class CustomDecoder(json.JSONDecoder):      def __init__(self, *args, **kwargs):          json.JSONDecoder.__init__(self, object_hook=self.object_hook, *args, **kwargs)        def object_hook(self, source):          if source.get(\"__type__\") == \"Datetime\":              return datetime.fromisoformat(source.get(\"__value__\"))          else:              return source      def config_test_scenario():      test_csv_dn_cfg = Config.configure_csv_data_node(          id=\"test_csv_dn\",          path=\"./test.csv\",          exposed_type=CustomClass,          scope=Scope.GLOBAL,          validity_period=datetime.timedelta(1),      )        test_json_dn_cfg = Config.configure_json_data_node(          id=\"test_json_dn\",          default_path=\"./test.json\",          encoder=CustomEncoder,          decoder=CustomDecoder,      )        test_pickle_dn_cfg = Config.configure_pickle_data_node(          id=\"test_pickle_dn\",          path=\"./test.p\",          scope=Scope.SCENARIO,          validity_period=datetime.timedelta(1),      )        test_task_cfg = Config.configure_task(          id=\"test_task\", input=test_csv_dn_cfg, function=multiply, output=test_json_dn_cfg      )        test_scenario_cfg = Config.configure_scenario(          id=\"test_scenario\",          task_configs=[test_task_cfg],          additional_data_node_configs=[test_pickle_dn_cfg],          comparators={test_json_dn_cfg.id: compare_function},          frequency=Frequency.DAILY,      )      test_scenario_cfg.add_sequences({\"sequence1\": [test_task_cfg]})        Config.add_migration_function(\"1.0\", test_csv_dn_cfg, migrate_csv_path)        return test_scenario_cfg      def test_read_write_toml_configuration_file():      expected_toml_config = f\"\"\"  [TAIPY]    [JOB]  mode = \"development\"  max_nb_of_workers = \"1: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 = \"{CoreSection._CURRENT_CORE_VERSION}\"    [DATA_NODE.default]  storage_type = \"pickle\"  scope = \"SCENARIO:SCOPE\"    [DATA_NODE.test_csv_dn]  storage_type = \"csv\"  scope = \"GLOBAL:SCOPE\"  validity_period = \"1d0h0m0s:timedelta\"  path = \"./test.csv\"  exposed_type = \"tests.core.config.test_config_serialization.CustomClass:class\"  encoding = \"utf-8\"  has_header = \"True:bool\"    [DATA_NODE.test_json_dn]  storage_type = \"json\"  scope = \"SCENARIO:SCOPE\"  default_path = \"./test.json\"  encoder = \"tests.core.config.test_config_serialization.CustomEncoder:class\"  decoder = \"tests.core.config.test_config_serialization.CustomDecoder:class\"  encoding = \"utf-8\"    [DATA_NODE.test_pickle_dn]  storage_type = \"pickle\"  scope = \"SCENARIO:SCOPE\"  validity_period = \"1d0h0m0s:timedelta\"  path = \"./test.p\"    [TASK.default]  inputs = []  outputs = []  skippable = \"False:bool\"    [TASK.test_task]  function = \"tests.core.config.test_config_serialization.multiply:function\"  inputs = [ \"test_csv_dn:SECTION\",]  outputs = [ \"test_json_dn:SECTION\",]  skippable = \"False:bool\"    [SCENARIO.default]  tasks = []  additional_data_nodes = []    [SCENARIO.test_scenario]  tasks = [ \"test_task:SECTION\",]  additional_data_nodes = [ \"test_pickle_dn:SECTION\",]  frequency = \"DAILY:FREQUENCY\"    [VERSION_MIGRATION.migration_fcts.\"1.0\"]  test_csv_dn = \"tests.core.config.test_config_serialization.migrate_csv_path:function\"    [SCENARIO.default.comparators]    [SCENARIO.default.sequences]    [SCENARIO.test_scenario.comparators]  test_json_dn = [ \"tests.core.config.test_config_serialization.compare_function:function\",]    [SCENARIO.test_scenario.sequences]  sequence1 = [ \"test_task:SECTION\",]  \"\"\".strip()        config_test_scenario()        tf = NamedTemporaryFile()      Config.backup(tf.filename)      actual_config = tf.read().strip()      assert actual_config == expected_toml_config        Config.load(tf.filename)      tf2 = NamedTemporaryFile()      Config.backup(tf2.filename)        actual_config_2 = tf2.read().strip()      assert actual_config_2 == expected_toml_config        assert Config.unique_sections is not None      assert len(Config.unique_sections) == 3        assert Config.unique_sections[JobConfig.name].mode == \"development\"      assert Config.unique_sections[JobConfig.name].max_nb_of_workers == 1        assert Config.unique_sections[MigrationConfig.name].migration_fcts[\"1.0\"] == {\"test_csv_dn\": migrate_csv_path}        assert Config.sections is not None      assert len(Config.sections) == 3        assert Config.sections[DataNodeConfig.name] is not None      assert len(Config.sections[DataNodeConfig.name]) == 4      assert Config.sections[DataNodeConfig.name][\"default\"] is not None      assert Config.sections[DataNodeConfig.name][\"default\"].storage_type == \"pickle\"      assert Config.sections[DataNodeConfig.name][\"default\"].scope == Scope.SCENARIO      assert Config.sections[DataNodeConfig.name][\"test_csv_dn\"].storage_type == \"csv\"      assert Config.sections[DataNodeConfig.name][\"test_csv_dn\"].scope == Scope.GLOBAL      assert Config.sections[DataNodeConfig.name][\"test_csv_dn\"].validity_period == datetime.timedelta(1)      assert Config.sections[DataNodeConfig.name][\"test_csv_dn\"].has_header is True      assert Config.sections[DataNodeConfig.name][\"test_csv_dn\"].path == \"./test.csv\"      assert Config.sections[DataNodeConfig.name][\"test_csv_dn\"].encoding == \"utf-8\"      assert Config.sections[DataNodeConfig.name][\"test_csv_dn\"].exposed_type == CustomClass      assert Config.sections[DataNodeConfig.name][\"test_json_dn\"].storage_type == \"json\"      assert Config.sections[DataNodeConfig.name][\"test_json_dn\"].scope == Scope.SCENARIO      assert Config.sections[DataNodeConfig.name][\"test_json_dn\"].default_path == \"./test.json\"      assert Config.sections[DataNodeConfig.name][\"test_json_dn\"].encoding == \"utf-8\"      assert Config.sections[DataNodeConfig.name][\"test_json_dn\"].encoder == CustomEncoder      assert Config.sections[DataNodeConfig.name][\"test_json_dn\"].decoder == CustomDecoder      assert Config.sections[DataNodeConfig.name][\"test_pickle_dn\"].storage_type == \"pickle\"      assert Config.sections[DataNodeConfig.name][\"test_pickle_dn\"].scope == Scope.SCENARIO      assert Config.sections[DataNodeConfig.name][\"test_pickle_dn\"].validity_period == datetime.timedelta(1)      assert Config.sections[DataNodeConfig.name][\"test_pickle_dn\"].path == \"./test.p\"        assert Config.sections[TaskConfig.name] is not None      assert len(Config.sections[TaskConfig.name]) == 2      assert Config.sections[TaskConfig.name][\"default\"] is not None      assert Config.sections[TaskConfig.name][\"default\"].inputs == []      assert Config.sections[TaskConfig.name][\"default\"].outputs == []      assert Config.sections[TaskConfig.name][\"default\"].function is None      assert not Config.sections[TaskConfig.name][\"default\"].skippable      assert [inp.id for inp in Config.sections[TaskConfig.name][\"test_task\"].inputs] == [          Config.sections[DataNodeConfig.name][\"test_csv_dn\"].id      ]      assert [outp.id for outp in Config.sections[TaskConfig.name][\"test_task\"].outputs] == [          Config.sections[DataNodeConfig.name][\"test_json_dn\"].id      ]      assert Config.sections[TaskConfig.name][\"test_task\"].function == multiply      assert Config.sections[TaskConfig.name][\"test_task\"].function == multiply        assert Config.sections[ScenarioConfig.name] is not None      assert len(Config.sections[ScenarioConfig.name]) == 2      assert Config.sections[ScenarioConfig.name][\"default\"] is not None      assert Config.sections[ScenarioConfig.name][\"default\"].tasks == []      assert Config.sections[ScenarioConfig.name][\"default\"].additional_data_nodes == []      assert Config.sections[ScenarioConfig.name][\"default\"].data_nodes == []      assert len(Config.sections[ScenarioConfig.name][\"default\"].comparators) == 0      assert [task.id for task in Config.sections[ScenarioConfig.name][\"test_scenario\"].tasks] == [          Config.sections[TaskConfig.name][\"test_task\"].id      ]      assert [          additional_data_node.id          for additional_data_node in Config.sections[ScenarioConfig.name][\"test_scenario\"].additional_data_nodes      ] == [Config.sections[DataNodeConfig.name][\"test_pickle_dn\"].id]      assert sorted([data_node.id for data_node in Config.sections[ScenarioConfig.name][\"test_scenario\"].data_nodes]) == [          Config.sections[DataNodeConfig.name][\"test_csv_dn\"].id,          Config.sections[DataNodeConfig.name][\"test_json_dn\"].id,          Config.sections[DataNodeConfig.name][\"test_pickle_dn\"].id,      ]      sequences = {}      for sequence_name, sequence_tasks in Config.sections[ScenarioConfig.name][\"test_scenario\"].sequences.items():          sequences[sequence_name] = [task.id for task in sequence_tasks]      assert sequences == {\"sequence1\": [Config.sections[TaskConfig.name][\"test_task\"].id]}        assert dict(Config.sections[ScenarioConfig.name][\"test_scenario\"].comparators) == {          \"test_json_dn\": [compare_function]      }      def test_read_write_json_configuration_file():      expected_json_config = (          \"\"\"{  \"TAIPY\": {},  \"JOB\": {  \"mode\": \"development\",  \"max_nb_of_workers\": \"1:int\"  },  \"CORE\": {  \"root_folder\": \"./taipy/\",  \"storage_folder\": \".data/\",  \"repository_type\": \"filesystem\",  \"read_entity_retry\": \"0:int\",  \"mode\": \"development\",  \"version_number\": \"\",  \"force\": \"False:bool\",\"\"\"          + f\"\"\"  \"core_version\": \"{CoreSection._CURRENT_CORE_VERSION}\"  \"\"\"          + \"\"\"  },  \"VERSION_MIGRATION\": {  \"migration_fcts\": {  \"1.0\": {  \"test_csv_dn\": \"tests.core.config.test_config_serialization.migrate_csv_path:function\"  }  }  },  \"DATA_NODE\": {  \"default\": {  \"storage_type\": \"pickle\",  \"scope\": \"SCENARIO:SCOPE\"  },  \"test_csv_dn\": {  \"storage_type\": \"csv\",  \"scope\": \"GLOBAL:SCOPE\",  \"validity_period\": \"1d0h0m0s:timedelta\",  \"path\": \"./test.csv\",  \"exposed_type\": \"tests.core.config.test_config_serialization.CustomClass:class\",  \"encoding\": \"utf-8\",  \"has_header\": \"True:bool\"  },  \"test_json_dn\": {  \"storage_type\": \"json\",  \"scope\": \"SCENARIO:SCOPE\",  \"default_path\": \"./test.json\",  \"encoder\": \"tests.core.config.test_config_serialization.CustomEncoder:class\",  \"decoder\": \"tests.core.config.test_config_serialization.CustomDecoder:class\",  \"encoding\": \"utf-8\"  },  \"test_pickle_dn\": {  \"storage_type\": \"pickle\",  \"scope\": \"SCENARIO:SCOPE\",  \"validity_period\": \"1d0h0m0s:timedelta\",  \"path\": \"./test.p\"  }  },  \"TASK\": {  \"default\": {  \"function\": null,  \"inputs\": [],  \"outputs\": [],  \"skippable\": \"False:bool\"  },  \"test_task\": {  \"function\": \"tests.core.config.test_config_serialization.multiply:function\",  \"inputs\": [  \"test_csv_dn:SECTION\"  ],  \"outputs\": [  \"test_json_dn:SECTION\"  ],  \"skippable\": \"False:bool\"  }  },  \"SCENARIO\": {  \"default\": {  \"comparators\": {},  \"tasks\": [],  \"additional_data_nodes\": [],  \"frequency\": null,  \"sequences\": {}  },  \"test_scenario\": {  \"comparators\": {  \"test_json_dn\": [  \"tests.core.config.test_config_serialization.compare_function:function\"  ]  },  \"tasks\": [  \"test_task:SECTION\"  ],  \"additional_data_nodes\": [  \"test_pickle_dn:SECTION\"  ],  \"frequency\": \"DAILY:FREQUENCY\",  \"sequences\": {  \"sequence1\": [  \"test_task:SECTION\"  ]  }  }  }  }      \"\"\".strip()      )        Config._serializer = _JsonSerializer()      config_test_scenario()        tf = NamedTemporaryFile()      Config.backup(tf.filename)      actual_config = tf.read().strip()      assert actual_config == expected_json_config        Config.load(tf.filename)      tf2 = NamedTemporaryFile()      Config.backup(tf2.filename)        actual_config_2 = tf2.read().strip()      assert actual_config_2 == expected_json_config        assert Config.unique_sections is not None      assert len(Config.unique_sections) == 3        assert Config.unique_sections[JobConfig.name].mode == \"development\"      assert Config.unique_sections[JobConfig.name].max_nb_of_workers == 1        assert Config.unique_sections[MigrationConfig.name].migration_fcts[\"1.0\"] == {\"test_csv_dn\": migrate_csv_path}        assert Config.sections is not None      assert len(Config.sections) == 3        assert Config.sections[DataNodeConfig.name] is not None      assert len(Config.sections[DataNodeConfig.name]) == 4      assert Config.sections[DataNodeConfig.name][\"default\"] is not None      assert Config.sections[DataNodeConfig.name][\"default\"].storage_type == \"pickle\"      assert Config.sections[DataNodeConfig.name][\"default\"].scope == Scope.SCENARIO      assert Config.sections[DataNodeConfig.name][\"test_csv_dn\"].storage_type == \"csv\"      assert Config.sections[DataNodeConfig.name][\"test_csv_dn\"].scope == Scope.GLOBAL      assert Config.sections[DataNodeConfig.name][\"test_csv_dn\"].validity_period == datetime.timedelta(1)      assert Config.sections[DataNodeConfig.name][\"test_csv_dn\"].has_header is True      assert Config.sections[DataNodeConfig.name][\"test_csv_dn\"].path == \"./test.csv\"      assert Config.sections[DataNodeConfig.name][\"test_csv_dn\"].encoding == \"utf-8\"      assert Config.sections[DataNodeConfig.name][\"test_csv_dn\"].exposed_type == CustomClass      assert Config.sections[DataNodeConfig.name][\"test_json_dn\"].storage_type == \"json\"      assert Config.sections[DataNodeConfig.name][\"test_json_dn\"].scope == Scope.SCENARIO      assert Config.sections[DataNodeConfig.name][\"test_json_dn\"].default_path == \"./test.json\"      assert Config.sections[DataNodeConfig.name][\"test_json_dn\"].encoding == \"utf-8\"      assert Config.sections[DataNodeConfig.name][\"test_json_dn\"].encoder == CustomEncoder      assert Config.sections[DataNodeConfig.name][\"test_json_dn\"].decoder == CustomDecoder      assert Config.sections[DataNodeConfig.name][\"test_pickle_dn\"].storage_type == \"pickle\"      assert Config.sections[DataNodeConfig.name][\"test_pickle_dn\"].scope == Scope.SCENARIO      assert Config.sections[DataNodeConfig.name][\"test_pickle_dn\"].validity_period == datetime.timedelta(1)      assert Config.sections[DataNodeConfig.name][\"test_pickle_dn\"].path == \"./test.p\"        assert Config.sections[TaskConfig.name] is not None      assert len(Config.sections[TaskConfig.name]) == 2      assert Config.sections[TaskConfig.name][\"default\"] is not None      assert Config.sections[TaskConfig.name][\"default\"].inputs == []      assert Config.sections[TaskConfig.name][\"default\"].outputs == []      assert Config.sections[TaskConfig.name][\"default\"].function is None      assert [inp.id for inp in Config.sections[TaskConfig.name][\"test_task\"].inputs] == [          Config.sections[DataNodeConfig.name][\"test_csv_dn\"].id      ]      assert [outp.id for outp in Config.sections[TaskConfig.name][\"test_task\"].outputs] == [          Config.sections[DataNodeConfig.name][\"test_json_dn\"].id      ]      assert Config.sections[TaskConfig.name][\"test_task\"].function == multiply        assert Config.sections[ScenarioConfig.name] is not None      assert len(Config.sections[ScenarioConfig.name]) == 2      assert Config.sections[ScenarioConfig.name][\"default\"] is not None      assert Config.sections[ScenarioConfig.name][\"default\"].tasks == []      assert Config.sections[ScenarioConfig.name][\"default\"].additional_data_nodes == []      assert Config.sections[ScenarioConfig.name][\"default\"].data_nodes == []      assert len(Config.sections[ScenarioConfig.name][\"default\"].comparators) == 0      assert [task.id for task in Config.sections[ScenarioConfig.name][\"test_scenario\"].tasks] == [          Config.sections[TaskConfig.name][\"test_task\"].id      ]      assert [          additional_data_node.id          for additional_data_node in Config.sections[ScenarioConfig.name][\"test_scenario\"].additional_data_nodes      ] == [Config.sections[DataNodeConfig.name][\"test_pickle_dn\"].id]      assert sorted([data_node.id for data_node in Config.sections[ScenarioConfig.name][\"test_scenario\"].data_nodes]) == [          Config.sections[DataNodeConfig.name][\"test_csv_dn\"].id,          Config.sections[DataNodeConfig.name][\"test_json_dn\"].id,          Config.sections[DataNodeConfig.name][\"test_pickle_dn\"].id,      ]      sequences = {}      for sequence_name, sequence_tasks in Config.sections[ScenarioConfig.name][\"test_scenario\"].sequences.items():          sequences[sequence_name] = [task.id for task in sequence_tasks]      assert sequences == {\"sequence1\": [Config.sections[TaskConfig.name][\"test_task\"].id]}        assert dict(Config.sections[ScenarioConfig.name][\"test_scenario\"].comparators) == {          \"test_json_dn\": [compare_function]      }      def test_read_write_toml_configuration_file_migrate_sequence_in_scenario():      old_toml_config = \"\"\"  [TAIPY]    [JOB]  mode = \"development\"  max_nb_of_workers = \"1:int\"    [CORE]  root_folder = \"./taipy/\"  storage_folder = \".data/\"  repository_type = \"filesystem\"  mode = \"development\"  version_number = \"\"  force = \"False:bool\"    [DATA_NODE.default]  storage_type = \"pickle\"  scope = \"SCENARIO:SCOPE\"    [DATA_NODE.test_csv_dn]  storage_type = \"csv\"  scope = \"GLOBAL:SCOPE\"  validity_period = \"1d0h0m0s:timedelta\"  path = \"./test.csv\"  exposed_type = \"tests.core.config.test_config_serialization.CustomClass:class\"  has_header = \"True:bool\"    [DATA_NODE.test_json_dn]  storage_type = \"json\"  scope = \"SCENARIO:SCOPE\"  default_path = \"./test.json\"  encoder = \"tests.core.config.test_config_serialization.CustomEncoder:class\"  decoder = \"tests.core.config.test_config_serialization.CustomDecoder:class\"    [TASK.default]  inputs = []  outputs = []  skippable = \"False:bool\"    [TASK.test_task]  function = \"tests.core.config.test_config_serialization.multiply:function\"  inputs = [ \"test_csv_dn:SECTION\",]  outputs = [ \"test_json_dn:SECTION\",]  skippable = \"False:bool\"    [SCENARIO.default]    [SCENARIO.test_scenario]  tasks = [ \"test_task:SECTION\",]  sequences.test_sequence = [ \"test_task:SECTION\",]  frequency = \"DAILY:FREQUENCY\"    [VERSION_MIGRATION.migration_fcts.\"1.0\"]  test_csv_dn = \"tests.core.config.test_config_serialization.migrate_csv_path:function\"    [SCENARIO.default.comparators]    [SCENARIO.test_scenario.comparators]  test_json_dn = [ \"tests.core.config.test_config_serialization.compare_function:function\",]      \"\"\".strip()        config_test_scenario()        tf = NamedTemporaryFile()      with open(tf.filename, \"w\") as fd:          fd.writelines(old_toml_config)      Config.restore(tf.filename)        assert Config.unique_sections is not None      assert len(Config.unique_sections) == 3        assert Config.unique_sections[CoreSection.name].root_folder == \"./taipy/\"      assert Config.unique_sections[CoreSection.name].storage_folder == \".data/\"      assert Config.unique_sections[CoreSection.name].repository_type == \"filesystem\"      assert Config.unique_sections[CoreSection.name].repository_properties == {}      assert Config.unique_sections[CoreSection.name].mode == \"development\"      assert Config.unique_sections[CoreSection.name].version_number == \"\"      assert Config.unique_sections[CoreSection.name].force is False        assert Config.unique_sections[JobConfig.name].mode == \"development\"      assert Config.unique_sections[JobConfig.name].max_nb_of_workers == 1        assert Config.unique_sections[MigrationConfig.name].migration_fcts[\"1.0\"] == {\"test_csv_dn\": migrate_csv_path}        assert Config.sections is not None      assert len(Config.sections) == 3        assert Config.sections[DataNodeConfig.name] is not None      assert len(Config.sections[DataNodeConfig.name]) == 3      assert Config.sections[DataNodeConfig.name][\"default\"] is not None      assert Config.sections[DataNodeConfig.name][\"default\"].storage_type == \"pickle\"      assert Config.sections[DataNodeConfig.name][\"default\"].scope == Scope.SCENARIO      assert Config.sections[DataNodeConfig.name][\"test_csv_dn\"].storage_type == \"csv\"      assert Config.sections[DataNodeConfig.name][\"test_csv_dn\"].scope == Scope.GLOBAL      assert Config.sections[DataNodeConfig.name][\"test_csv_dn\"].validity_period == datetime.timedelta(1)      assert Config.sections[DataNodeConfig.name][\"test_csv_dn\"].has_header is True      assert Config.sections[DataNodeConfig.name][\"test_csv_dn\"].path == \"./test.csv\"      assert Config.sections[DataNodeConfig.name][\"test_csv_dn\"].exposed_type == CustomClass      assert Config.sections[DataNodeConfig.name][\"test_json_dn\"].storage_type == \"json\"      assert Config.sections[DataNodeConfig.name][\"test_json_dn\"].scope == Scope.SCENARIO      assert Config.sections[DataNodeConfig.name][\"test_json_dn\"].default_path == \"./test.json\"      assert Config.sections[DataNodeConfig.name][\"test_json_dn\"].encoder == CustomEncoder      assert Config.sections[DataNodeConfig.name][\"test_json_dn\"].decoder == CustomDecoder        assert Config.sections[TaskConfig.name] is not None      assert len(Config.sections[TaskConfig.name]) == 2      assert Config.sections[TaskConfig.name][\"default\"] is not None      assert Config.sections[TaskConfig.name][\"default\"].inputs == []      assert Config.sections[TaskConfig.name][\"default\"].outputs == []      assert Config.sections[TaskConfig.name][\"default\"].function is None      assert not Config.sections[TaskConfig.name][\"default\"].skippable      assert [inp.id for inp in Config.sections[TaskConfig.name][\"test_task\"].inputs] == [          Config.sections[DataNodeConfig.name][\"test_csv_dn\"].id      ]      assert [outp.id for outp in Config.sections[TaskConfig.name][\"test_task\"].outputs] == [          Config.sections[DataNodeConfig.name][\"test_json_dn\"].id      ]      assert Config.sections[TaskConfig.name][\"test_task\"].function == multiply      assert Config.sections[TaskConfig.name][\"test_task\"].function == multiply        assert Config.sections[ScenarioConfig.name] is not None      assert len(Config.sections[ScenarioConfig.name]) == 2      assert Config.sections[ScenarioConfig.name][\"default\"] is not None      assert Config.sections[ScenarioConfig.name][\"default\"].tasks == []      assert Config.sections[ScenarioConfig.name][\"default\"].additional_data_nodes == []      assert Config.sections[ScenarioConfig.name][\"default\"].data_nodes == []      assert len(Config.sections[ScenarioConfig.name][\"default\"].comparators) == 0      assert [task.id for task in Config.sections[ScenarioConfig.name][\"test_scenario\"].tasks] == [          Config.sections[TaskConfig.name][\"test_task\"].id      ]      assert [          additional_data_node.id          for additional_data_node in Config.sections[ScenarioConfig.name][\"test_scenario\"].additional_data_nodes      ] == []      assert sorted([data_node.id for data_node in Config.sections[ScenarioConfig.name][\"test_scenario\"].data_nodes]) == [          Config.sections[DataNodeConfig.name][\"test_csv_dn\"].id,          Config.sections[DataNodeConfig.name][\"test_json_dn\"].id,      ]      assert Config.sections[ScenarioConfig.name][\"test_scenario\"].sequences == {          \"test_sequence\": [Config.sections[TaskConfig.name][\"test_task\"]]      }        assert dict(Config.sections[ScenarioConfig.name][\"test_scenario\"].comparators) == {          \"test_json_dn\": [compare_function]      }      def test_read_write_json_configuration_file_migrate_sequence_in_scenario():      old_json_config = \"\"\"  {  \"TAIPY\": {},  \"JOB\": {  \"mode\": \"development\",  \"max_nb_of_workers\": \"1: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\": {  \"1.0\": {  \"test_csv_dn\": \"tests.core.config.test_config_serialization.migrate_csv_path:function\"  }  }  },  \"DATA_NODE\": {  \"default\": {  \"storage_type\": \"pickle\",  \"scope\": \"SCENARIO:SCOPE\"  },  \"test_csv_dn\": {  \"storage_type\": \"csv\",  \"scope\": \"GLOBAL:SCOPE\",  \"validity_period\": \"1d0h0m0s:timedelta\",  \"path\": \"./test.csv\",  \"exposed_type\": \"tests.core.config.test_config_serialization.CustomClass:class\",  \"has_header\": \"True:bool\"  },  \"test_json_dn\": {  \"storage_type\": \"json\",  \"scope\": \"SCENARIO:SCOPE\",  \"default_path\": \"./test.json\",  \"encoder\": \"tests.core.config.test_config_serialization.CustomEncoder:class\",  \"decoder\": \"tests.core.config.test_config_serialization.CustomDecoder:class\"  }  },  \"TASK\": {  \"default\": {  \"function\": null,  \"inputs\": [],  \"outputs\": [],  \"skippable\": \"False:bool\"  },  \"test_task\": {  \"function\": \"tests.core.config.test_config_serialization.multiply:function\",  \"inputs\": [  \"test_csv_dn:SECTION\"  ],  \"outputs\": [  \"test_json_dn:SECTION\"  ],  \"skippable\": \"False:bool\"  }  },  \"SCENARIO\": {  \"default\": {  \"comparators\": {},  \"sequences\": {},  \"frequency\": null  },  \"test_scenario\": {  \"comparators\": {  \"test_json_dn\": [  \"tests.core.config.test_config_serialization.compare_function:function\"  ]  },  \"tasks\": [  \"test_task:SECTION\"  ],  \"sequences\": {  \"test_sequence\": [  \"test_task:SECTION\"  ]  },  \"frequency\": \"DAILY:FREQUENCY\"  }  }  }      \"\"\".strip()        Config._serializer = _JsonSerializer()      config_test_scenario()        tf = NamedTemporaryFile()      with open(tf.filename, \"w\") as fd:          fd.writelines(old_json_config)      Config.restore(tf.filename)        assert Config.unique_sections is not None      assert len(Config.unique_sections) == 3        assert Config.unique_sections[CoreSection.name].root_folder == \"./taipy/\"      assert Config.unique_sections[CoreSection.name].storage_folder == \".data/\"      assert Config.unique_sections[CoreSection.name].repository_type == \"filesystem\"      assert Config.unique_sections[CoreSection.name].repository_properties == {}      assert Config.unique_sections[CoreSection.name].mode == \"development\"      assert Config.unique_sections[CoreSection.name].version_number == \"\"      assert Config.unique_sections[CoreSection.name].force is False        assert Config.unique_sections[JobConfig.name].mode == \"development\"      assert Config.unique_sections[JobConfig.name].max_nb_of_workers == 1        assert Config.unique_sections[MigrationConfig.name].migration_fcts[\"1.0\"] == {\"test_csv_dn\": migrate_csv_path}        assert Config.sections is not None      assert len(Config.sections) == 3        assert Config.sections[DataNodeConfig.name] is not None      assert len(Config.sections[DataNodeConfig.name]) == 3      assert Config.sections[DataNodeConfig.name][\"default\"] is not None      assert Config.sections[DataNodeConfig.name][\"default\"].storage_type == \"pickle\"      assert Config.sections[DataNodeConfig.name][\"default\"].scope == Scope.SCENARIO      assert Config.sections[DataNodeConfig.name][\"test_csv_dn\"].storage_type == \"csv\"      assert Config.sections[DataNodeConfig.name][\"test_csv_dn\"].scope == Scope.GLOBAL      assert Config.sections[DataNodeConfig.name][\"test_csv_dn\"].validity_period == datetime.timedelta(1)      assert Config.sections[DataNodeConfig.name][\"test_csv_dn\"].has_header is True      assert Config.sections[DataNodeConfig.name][\"test_csv_dn\"].path == \"./test.csv\"      assert Config.sections[DataNodeConfig.name][\"test_csv_dn\"].exposed_type == CustomClass      assert Config.sections[DataNodeConfig.name][\"test_json_dn\"].storage_type == \"json\"      assert Config.sections[DataNodeConfig.name][\"test_json_dn\"].scope == Scope.SCENARIO      assert Config.sections[DataNodeConfig.name][\"test_json_dn\"].default_path == \"./test.json\"      assert Config.sections[DataNodeConfig.name][\"test_json_dn\"].encoder == CustomEncoder      assert Config.sections[DataNodeConfig.name][\"test_json_dn\"].decoder == CustomDecoder        assert Config.sections[TaskConfig.name] is not None      assert len(Config.sections[TaskConfig.name]) == 2      assert Config.sections[TaskConfig.name][\"default\"] is not None      assert Config.sections[TaskConfig.name][\"default\"].inputs == []      assert Config.sections[TaskConfig.name][\"default\"].outputs == []      assert Config.sections[TaskConfig.name][\"default\"].function is None      assert [inp.id for inp in Config.sections[TaskConfig.name][\"test_task\"].inputs] == [          Config.sections[DataNodeConfig.name][\"test_csv_dn\"].id      ]      assert [outp.id for outp in Config.sections[TaskConfig.name][\"test_task\"].outputs] == [          Config.sections[DataNodeConfig.name][\"test_json_dn\"].id      ]      assert Config.sections[TaskConfig.name][\"test_task\"].function == multiply        assert Config.sections[ScenarioConfig.name] is not None      assert len(Config.sections[ScenarioConfig.name]) == 2      assert Config.sections[ScenarioConfig.name][\"default\"] is not None      assert Config.sections[ScenarioConfig.name][\"default\"].tasks == []      assert Config.sections[ScenarioConfig.name][\"default\"].additional_data_nodes == []      assert Config.sections[ScenarioConfig.name][\"default\"].data_nodes == []      assert len(Config.sections[ScenarioConfig.name][\"default\"].comparators) == 0      assert [task.id for task in Config.sections[ScenarioConfig.name][\"test_scenario\"].tasks] == [          Config.sections[TaskConfig.name][\"test_task\"].id      ]      assert [          additional_data_node.id          for additional_data_node in Config.sections[ScenarioConfig.name][\"test_scenario\"].additional_data_nodes      ] == []      assert sorted([data_node.id for data_node in Config.sections[ScenarioConfig.name][\"test_scenario\"].data_nodes]) == [          Config.sections[DataNodeConfig.name][\"test_csv_dn\"].id,          Config.sections[DataNodeConfig.name][\"test_json_dn\"].id,      ]      assert Config.sections[ScenarioConfig.name][\"test_scenario\"].sequences == {          \"test_sequence\": [Config.sections[TaskConfig.name][\"test_task\"]]      }        assert dict(Config.sections[ScenarioConfig.name][\"test_scenario\"].comparators) == {          \"test_json_dn\": [compare_function]      } "}
{"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": "import os  from unittest import mock    from taipy.config.common.frequency import Frequency  from taipy.config.config import Config  from tests.core.utils.named_temporary_file import NamedTemporaryFile      def my_func():      pass      def _configure_scenario_in_toml():      return NamedTemporaryFile(          content=\"\"\"  [TAIPY]    [TASK.task1]  inputs = []  outputs = []    [TASK.task2]  inputs = []  outputs = []    [SCENARIO.scenarios1]  tasks = [ \"task1:SECTION\", \"task2:SECTION\"]      \"\"\"      )      def _check_tasks_instance(task_id, scenario_id):      \"\"\"Check if the task instance in the task config correctly points to the Config._applied_config,      not the Config._python_config or the Config._file_config      \"\"\"      task_config_applied_instance = Config.tasks[task_id]      task_config_instance_via_scenario = None      for task in Config.scenarios[scenario_id].tasks:          if task.id == task_id:              task_config_instance_via_scenario = task        task_config_python_instance = None      if Config._python_config._sections.get(\"TASK\", None):          task_config_python_instance = Config._python_config._sections[\"TASK\"][task_id]        task_config_file_instance = None      if Config._file_config._sections.get(\"TASK\", None):          task_config_file_instance = Config._file_config._sections[\"TASK\"][task_id]        assert task_config_python_instance is not task_config_applied_instance      assert task_config_python_instance is not task_config_instance_via_scenario      assert task_config_file_instance is not task_config_applied_instance      assert task_config_file_instance is not task_config_instance_via_scenario      assert task_config_instance_via_scenario is task_config_applied_instance      def test_task_instance_when_configure_scenario_in_python():      task1_config = Config.configure_task(\"task1\", [])      task2_config = Config.configure_task(\"task2\", print)      Config.configure_scenario(\"scenarios1\", [task1_config, task2_config])        _check_tasks_instance(\"task1\", \"scenarios1\")      _check_tasks_instance(\"task2\", \"scenarios1\")      def test_task_instance_when_configure_scenario_by_loading_toml():      toml_config = _configure_scenario_in_toml()      Config.load(toml_config.filename)        _check_tasks_instance(\"task1\", \"scenarios1\")      _check_tasks_instance(\"task2\", \"scenarios1\")      def test_task_instance_when_configure_scenario_by_overriding_toml():      toml_config = _configure_scenario_in_toml()      Config.override(toml_config.filename)        _check_tasks_instance(\"task1\", \"scenarios1\")      _check_tasks_instance(\"task2\", \"scenarios1\")      def test_scenario_creation():      dn_config_1 = Config.configure_data_node(\"dn1\")      dn_config_2 = Config.configure_data_node(\"dn2\")      dn_config_3 = Config.configure_data_node(\"dn3\")      dn_config_4 = Config.configure_data_node(\"dn4\")      task_config_1 = Config.configure_task(\"task1\", sum, [dn_config_1, dn_config_2], dn_config_3)      task_config_2 = Config.configure_task(\"task2\", print, dn_config_3)      scenario = Config.configure_scenario(          \"scenarios1\",          [task_config_1, task_config_2],          [dn_config_4],          comparators={\"dn_cfg\": [my_func]},          sequences={\"sequence\": []},      )        assert list(Config.scenarios) == [\"default\", scenario.id]        scenario2 = Config.configure_scenario(\"scenarios2\", [task_config_1], frequency=Frequency.MONTHLY)      assert list(Config.scenarios) == [\"default\", scenario.id, scenario2.id]      def test_scenario_count():      task_config_1 = Config.configure_task(\"task1\", my_func)      task_config_2 = Config.configure_task(\"task2\", print)      Config.configure_scenario(\"scenarios1\", [task_config_1, task_config_2])      assert len(Config.scenarios) == 2        Config.configure_scenario(\"scenarios2\", [task_config_1])      assert len(Config.scenarios) == 3        Config.configure_scenario(\"scenarios3\", [task_config_2])      assert len(Config.scenarios) == 4      def test_scenario_getitem():      dn_config_1 = Config.configure_data_node(\"dn1\")      dn_config_2 = Config.configure_data_node(\"dn2\")      dn_config_3 = Config.configure_data_node(\"dn3\")      dn_config_4 = Config.configure_data_node(\"dn4\")      task_config_1 = Config.configure_task(\"task1\", sum, [dn_config_1, dn_config_2], dn_config_3)      task_config_2 = Config.configure_task(\"task2\", print, dn_config_3)      scenario_id = \"scenarios1\"      scenario = Config.configure_scenario(scenario_id, [task_config_1, task_config_2], [dn_config_4])        assert Config.scenarios[scenario_id].id == scenario.id        assert Config.scenarios[scenario_id].task_configs == scenario.task_configs      assert Config.scenarios[scenario_id].tasks == scenario.tasks      assert Config.scenarios[scenario_id].task_configs == scenario.tasks        assert Config.scenarios[scenario_id].additional_data_node_configs == scenario.additional_data_node_configs      assert Config.scenarios[scenario_id].additional_data_nodes == scenario.additional_data_nodes      assert Config.scenarios[scenario_id].additional_data_node_configs == scenario.additional_data_nodes        assert Config.scenarios[scenario_id].data_node_configs == scenario.data_node_configs      assert Config.scenarios[scenario_id].data_nodes == scenario.data_nodes      assert Config.scenarios[scenario_id].data_node_configs == scenario.data_nodes        assert scenario.tasks == [task_config_1, task_config_2]      assert scenario.additional_data_node_configs == [dn_config_4]      assert set(scenario.data_nodes) == set([dn_config_4, dn_config_1, dn_config_2, dn_config_3])        assert Config.scenarios[scenario_id].properties == scenario.properties      def test_scenario_creation_no_duplication():      task_config_1 = Config.configure_task(\"task1\", my_func)      task_config_2 = Config.configure_task(\"task2\", print)      dn_config = Config.configure_data_node(\"dn\")      Config.configure_scenario(\"scenarios1\", [task_config_1, task_config_2], [dn_config])        assert len(Config.scenarios) == 2        Config.configure_scenario(\"scenarios1\", [task_config_1, task_config_2], [dn_config])      assert len(Config.scenarios) == 2      def test_scenario_get_set_and_remove_comparators():      task_config_1 = Config.configure_task(\"task1\", my_func)      task_config_2 = Config.configure_task(\"task2\", print)      dn_config_1 = \"dn_config_1\"      scenario_config_1 = Config.configure_scenario(          \"scenarios1\", [task_config_1, task_config_2], comparators={dn_config_1: my_func}      )        assert scenario_config_1.comparators is not None      assert scenario_config_1.comparators[dn_config_1] == [my_func]      assert len(scenario_config_1.comparators.keys()) == 1        dn_config_2 = \"dn_config_2\"      scenario_config_1.add_comparator(dn_config_2, my_func)      assert len(scenario_config_1.comparators.keys()) == 2        scenario_config_1.delete_comparator(dn_config_1)      assert len(scenario_config_1.comparators.keys()) == 1        scenario_config_1.delete_comparator(dn_config_2)      assert len(scenario_config_1.comparators.keys()) == 0        scenario_config_2 = Config.configure_scenario(\"scenarios2\", [task_config_1, task_config_2])        assert scenario_config_2.comparators is not None        scenario_config_2.add_comparator(dn_config_1, my_func)      assert len(scenario_config_2.comparators.keys()) == 1        scenario_config_2.delete_comparator(\"dn_config_3\")      def test_scenario_config_with_env_variable_value():      task_config_1 = Config.configure_task(\"task1\", my_func)      task_config_2 = Config.configure_task(\"task2\", print)      with mock.patch.dict(os.environ, {\"FOO\": \"bar\"}):          Config.configure_scenario(\"scenario_name\", [task_config_1, task_config_2], prop=\"ENV[FOO]\")          assert Config.scenarios[\"scenario_name\"].prop == \"bar\"          assert Config.scenarios[\"scenario_name\"].properties[\"prop\"] == \"bar\"          assert Config.scenarios[\"scenario_name\"]._properties[\"prop\"] == \"ENV[FOO]\"      def test_clean_config():      task1_config = Config.configure_task(\"task1\", print, [], [])      task2_config = Config.configure_task(\"task2\", print, [], [])      scenario1_config = Config.configure_scenario(          \"id1\",          [task1_config, task2_config],          [],          Frequency.YEARLY,          {\"foo\": \"bar\"},          prop=\"foo\",          sequences={\"sequence_1\": []},      )      scenario2_config = Config.configure_scenario(          \"id2\",          [task2_config, task1_config],          [],          Frequency.MONTHLY,          {\"foz\": \"baz\"},          prop=\"bar\",          sequences={\"sequence_2\": []},      )        assert Config.scenarios[\"id1\"] is scenario1_config      assert Config.scenarios[\"id2\"] is scenario2_config        scenario1_config._clean()      scenario2_config._clean()        # Check if the instance before and after _clean() is the same      assert Config.scenarios[\"id1\"] is scenario1_config      assert Config.scenarios[\"id2\"] is scenario2_config        assert scenario1_config.id == \"id1\"      assert scenario2_config.id == \"id2\"      assert scenario1_config.tasks == scenario1_config.task_configs == []      assert scenario1_config.additional_data_nodes == scenario1_config.additional_data_node_configs == []      assert scenario1_config.data_nodes == scenario1_config.data_node_configs == []      assert scenario1_config.sequences == scenario1_config.sequences == {}      assert scenario1_config.frequency is scenario1_config.frequency is None      assert scenario1_config.comparators == scenario1_config.comparators == {}      assert scenario1_config.properties == scenario1_config.properties == {}        assert scenario2_config.tasks == scenario2_config.task_configs == []      assert scenario2_config.additional_data_nodes == scenario2_config.additional_data_node_configs == []      assert scenario2_config.data_nodes == scenario2_config.data_node_configs == []      assert scenario2_config.sequences == scenario1_config.sequences == {}      assert scenario2_config.frequency is scenario2_config.frequency is None      assert scenario2_config.comparators == scenario2_config.comparators == {}      assert scenario2_config.properties == scenario2_config.properties == {}      def test_add_sequence():      task1_config = Config.configure_task(\"task1\", print, [], [])      task2_config = Config.configure_task(\"task2\", print, [], [])      task3_config = Config.configure_task(\"task3\", print, [], [])      task4_config = Config.configure_task(\"task4\", print, [], [])      scenario_config = Config.configure_scenario(          \"id\", [task1_config, task2_config, task3_config, task4_config], [], Frequency.YEARLY, prop=\"foo\"      )        assert Config.scenarios[\"id\"] is scenario_config        assert scenario_config.id == \"id\"      assert (          scenario_config.tasks          == scenario_config.task_configs          == [task1_config, task2_config, task3_config, task4_config]      )      assert scenario_config.additional_data_nodes == scenario_config.additional_data_node_configs == []      assert scenario_config.data_nodes == scenario_config.data_node_configs == []      assert scenario_config.frequency is scenario_config.frequency == Frequency.YEARLY      assert scenario_config.comparators == scenario_config.comparators == {}      assert scenario_config.properties == {\"prop\": \"foo\"}        scenario_config.add_sequences(          {              \"sequence1\": [task1_config],              \"sequence2\": [task2_config, task3_config],              \"sequence3\": [task1_config, task2_config, task4_config],          }      )      assert len(scenario_config.sequences) == 3      assert scenario_config.sequences[\"sequence1\"] == [task1_config]      assert scenario_config.sequences[\"sequence2\"] == [task2_config, task3_config]      assert scenario_config.sequences[\"sequence3\"] == [task1_config, task2_config, task4_config]        scenario_config.remove_sequences(\"sequence1\")      assert len(scenario_config.sequences) == 2      scenario_config.remove_sequences([\"sequence2\", \"sequence3\"])      assert len(scenario_config.sequences) == 0 "}
{"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": "import os  from datetime import timedelta  from unittest import mock    from src.taipy.core.config import DataNodeConfig, ScenarioConfig, TaskConfig  from src.taipy.core.config.core_section import CoreSection  from taipy.config.common.frequency import Frequency  from taipy.config.common.scope import Scope  from taipy.config.config import Config  from tests.core.utils.named_temporary_file import NamedTemporaryFile      def test_write_configuration_file():      expected_config = 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 = \"{CoreSection._CURRENT_CORE_VERSION}\"    [VERSION_MIGRATION.migration_fcts]    [DATA_NODE.default]  storage_type = \"in_memory\"  scope = \"SCENARIO:SCOPE\"  validity_period = \"1d0h0m0s:timedelta\"  custom = \"default_custom_prop\"    [DATA_NODE.dn1]  storage_type = \"pickle\"  scope = \"SCENARIO:SCOPE\"  validity_period = \"1d0h0m0s:timedelta\"  custom = \"custom property\"  default_data = \"dn1\"    [DATA_NODE.dn2]  storage_type = \"ENV[FOO]\"  scope = \"SCENARIO:SCOPE\"  validity_period = \"2d0h0m0s:timedelta\"  foo = \"bar\"  default_data = \"dn2\"  baz = \"ENV[QUX]\"  quux = \"ENV[QUUZ]:bool\"  corge = [ \"grault\", \"ENV[GARPLY]\", \"ENV[WALDO]:int\", \"3.0:float\",]    [DATA_NODE.dn3]  storage_type = \"ENV[FOO]\"  scope = \"SCENARIO:SCOPE\"  validity_period = \"1d0h0m0s:timedelta\"  foo = \"bar\"  default_data = \"dn3\"  quux = \"ENV[QUUZ]:bool\"    [TASK.default]  inputs = []  outputs = []  skippable = \"False:bool\"    [TASK.t1]  function = \"builtins.print:function\"  inputs = [ \"dn1:SECTION\",]  outputs = [ \"dn2:SECTION\",]  skippable = \"False:bool\"  description = \"t1 description\"    [SCENARIO.default]  tasks = []  additional_data_nodes = []  frequency = \"QUARTERLY:FREQUENCY\"  owner = \"Michel Platini\"    [SCENARIO.s1]  tasks = [ \"t1:SECTION\",]  additional_data_nodes = [ \"dn3:SECTION\",]  frequency = \"QUARTERLY:FREQUENCY\"  owner = \"Raymond Kopa\"    [SCENARIO.default.comparators]    [SCENARIO.default.sequences]    [SCENARIO.s1.comparators]    [SCENARIO.s1.sequences]  sequence = [ \"t1:SECTION\",]      \"\"\".strip()      tf = NamedTemporaryFile()      with mock.patch.dict(          os.environ, {\"FOO\": \"in_memory\", \"QUX\": \"qux\", \"QUUZ\": \"true\", \"GARPLY\": \"garply\", \"WALDO\": \"17\"}      ):          Config.configure_job_executions(mode=\"standalone\", max_nb_of_workers=2)          Config.set_default_data_node_configuration(              storage_type=\"in_memory\",              custom=\"default_custom_prop\",              validity_period=timedelta(1),          )          dn1_cfg_v2 = Config.configure_data_node(              \"dn1\", storage_type=\"pickle\", scope=Scope.SCENARIO, default_data=\"dn1\", custom=\"custom property\"          )          dn2_cfg_v2 = Config.configure_data_node(              \"dn2\",              storage_type=\"ENV[FOO]\",              validity_period=timedelta(2),              foo=\"bar\",              default_data=\"dn2\",              baz=\"ENV[QUX]\",              quux=\"ENV[QUUZ]:bool\",              corge=(\"grault\", \"ENV[GARPLY]\", \"ENV[WALDO]:int\", 3.0),          )          dn3_cfg_v2 = Config.configure_data_node(              \"dn3\",              storage_type=\"ENV[FOO]\",              foo=\"bar\",              default_data=\"dn3\",              quux=\"ENV[QUUZ]:bool\",          )          assert dn2_cfg_v2.scope == Scope.SCENARIO          t1_cfg_v2 = Config.configure_task(\"t1\", print, dn1_cfg_v2, dn2_cfg_v2, description=\"t1 description\")          Config.set_default_scenario_configuration([], [], Frequency.QUARTERLY, owner=\"Michel Platini\")          Config.configure_scenario(              \"s1\",              task_configs=[t1_cfg_v2],              additional_data_node_configs=[dn3_cfg_v2],              frequency=Frequency.QUARTERLY,              owner=\"Raymond Kopa\",              sequences={\"sequence\": [t1_cfg_v2]},          )          Config.backup(tf.filename)          actual_config = tf.read().strip()  # problem here            assert actual_config == expected_config          Config.override(tf.filename)          tf2 = NamedTemporaryFile()          Config.backup(tf2.filename)          actual_config_2 = tf2.read().strip()          assert actual_config_2 == expected_config      def test_read_configuration_file():      file_config = NamedTemporaryFile(          \"\"\"          [DATA_NODE.default]          has_header = true            [DATA_NODE.my_datanode]          path = \"/data/csv\"          validity_period = \"1d0h0m0s:timedelta\"            [DATA_NODE.my_datanode2]          path = \"/data2/csv\"            [DATA_NODE.my_datanode3]          path = \"/data3/csv\"          source = \"local\"            [TASK.my_task]          inputs = [\"my_datanode:SECTION\"]          outputs = [\"my_datanode2:SECTION\"]          description = \"task description\"            [SCENARIO.my_scenario]          tasks = [ \"my_task:SECTION\"]          additional_data_nodes = [\"my_datanode3:SECTION\"]          owner = \"John Doe\"            [SCENARIO.my_scenario.sequences]          sequence = [ \"my_task:SECTION\",]          \"\"\"      )      Config.configure_task(\"my_task\", print)      Config.override(file_config.filename)        assert len(Config.data_nodes) == 4      assert type(Config.data_nodes[\"my_datanode\"]) == DataNodeConfig      assert type(Config.data_nodes[\"my_datanode2\"]) == DataNodeConfig      assert type(Config.data_nodes[\"my_datanode3\"]) == DataNodeConfig      assert Config.data_nodes[\"my_datanode\"].path == \"/data/csv\"      assert Config.data_nodes[\"my_datanode2\"].path == \"/data2/csv\"      assert Config.data_nodes[\"my_datanode3\"].path == \"/data3/csv\"      assert Config.data_nodes[\"my_datanode\"].id == \"my_datanode\"      assert Config.data_nodes[\"my_datanode2\"].id == \"my_datanode2\"      assert Config.data_nodes[\"my_datanode3\"].id == \"my_datanode3\"      assert Config.data_nodes[\"my_datanode\"].validity_period == timedelta(1)      assert Config.data_nodes[\"my_datanode3\"].source == \"local\"        assert len(Config.tasks) == 2      assert type(Config.tasks[\"my_task\"]) == TaskConfig      assert Config.tasks[\"my_task\"].id == \"my_task\"      assert Config.tasks[\"my_task\"].description == \"task description\"      assert Config.tasks[\"my_task\"].function == print      assert len(Config.tasks[\"my_task\"].inputs) == 1      assert type(Config.tasks[\"my_task\"].inputs[0]) == DataNodeConfig      assert Config.tasks[\"my_task\"].inputs[0].path == \"/data/csv\"      assert Config.tasks[\"my_task\"].inputs[0].id == \"my_datanode\"      assert len(Config.tasks[\"my_task\"].outputs) == 1      assert type(Config.tasks[\"my_task\"].outputs[0]) == DataNodeConfig      assert Config.tasks[\"my_task\"].outputs[0].path == \"/data2/csv\"      assert Config.tasks[\"my_task\"].outputs[0].id == \"my_datanode2\"        assert len(Config.scenarios) == 2      assert type(Config.scenarios[\"my_scenario\"]) == ScenarioConfig      assert Config.scenarios[\"my_scenario\"].id == \"my_scenario\"      assert Config.scenarios[\"my_scenario\"].owner == \"John Doe\"      assert len(Config.scenarios[\"my_scenario\"].tasks) == 1      assert type(Config.scenarios[\"my_scenario\"].tasks[0]) == TaskConfig      assert len(Config.scenarios[\"my_scenario\"].additional_data_nodes) == 1      assert type(Config.scenarios[\"my_scenario\"].additional_data_nodes[0]) == DataNodeConfig      assert Config.scenarios[\"my_scenario\"].tasks[0].id == \"my_task\"      assert Config.scenarios[\"my_scenario\"].tasks[0].description == \"task description\"      assert Config.scenarios[\"my_scenario\"].additional_data_nodes[0].id == \"my_datanode3\"      assert Config.scenarios[\"my_scenario\"].additional_data_nodes[0].source == \"local\"      assert [task.id for task in Config.scenarios[\"my_scenario\"].sequences[\"sequence\"]] == [          Config.scenarios[\"my_scenario\"].tasks[0].id      ] "}
{"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": "import os  from unittest import mock    import pytest    from taipy.config.config import Config  from taipy.config.exceptions.exceptions import InconsistentEnvVariableError, MissingEnvVariableError  from tests.core.utils.named_temporary_file import NamedTemporaryFile      def test_override_default_configuration_with_code_configuration():      assert not Config.core.root_folder == \"foo\"      assert len(Config.data_nodes) == 1      assert len(Config.tasks) == 1      assert len(Config.scenarios) == 1        Config.configure_job_executions(max_nb_of_workers=-1)      Config.configure_core(root_folder=\"foo\")      foo_config = Config.configure_data_node(\"foo\", \"in_memory\")      xyz_config = Config.configure_data_node(\"xyz\")      bar_config = Config.configure_task(\"bar\", print, [foo_config], [])      qux_config = Config.configure_scenario(\"qux\", [bar_config], [xyz_config])        assert Config.job_config.max_nb_of_workers == -1      assert Config.core.root_folder == \"foo\"      assert len(Config.data_nodes) == 3      assert \"default\" in Config.data_nodes      assert foo_config.id in Config.data_nodes      assert xyz_config.id in Config.data_nodes      assert Config.data_nodes[foo_config.id].storage_type == \"in_memory\"      assert Config.data_nodes[xyz_config.id].storage_type == \"pickle\"      assert len(Config.tasks) == 2      assert \"default\" in Config.tasks      assert bar_config.id in Config.tasks      assert len(Config.tasks[bar_config.id].input_configs) == 1      assert Config.tasks[bar_config.id].input_configs[0].id == foo_config.id      assert len(Config.tasks[bar_config.id].output_configs) == 0      assert Config.tasks[bar_config.id].function == print        assert len(Config.scenarios) == 2      assert \"default\" in Config.scenarios      assert qux_config.id in Config.scenarios      assert len(Config.scenarios[qux_config.id].tasks) == 1      assert Config.scenarios[qux_config.id].tasks[0].id == bar_config.id      assert len(Config.scenarios[qux_config.id].additional_data_nodes) == 1      assert Config.scenarios[qux_config.id].additional_data_nodes[0].id == xyz_config.id      def test_override_default_config_with_code_config_including_env_variable_values():      Config.configure_core()      assert Config.core.repository_type == \"filesystem\"      Config.configure_core(repository_type=\"othertype\")      assert Config.core.repository_type == \"othertype\"        with mock.patch.dict(os.environ, {\"REPOSITORY_TYPE\": \"foo\"}):          Config.configure_core(repository_type=\"ENV[REPOSITORY_TYPE]\")          assert Config.core.repository_type == \"foo\"      def test_override_default_configuration_with_file_configuration():      tf = NamedTemporaryFile(          \"\"\"  [TAIPY]    [JOB]  max_nb_of_workers = -1    [DATA_NODE.foo]    [TASK.bar]    [SCENARIO.qux]  \"\"\"      )      assert Config.job_config.max_nb_of_workers == 1      assert len(Config.data_nodes) == 1      assert len(Config.tasks) == 1      assert len(Config.scenarios) == 1        Config.override(tf.filename)        assert Config.job_config.max_nb_of_workers == -1      assert len(Config.data_nodes) == 2      assert \"default\" in Config.data_nodes      assert \"foo\" in Config.data_nodes      assert len(Config.tasks) == 2      assert \"default\" in Config.tasks      assert \"bar\" in Config.tasks      assert \"default\" in Config.scenarios      assert len(Config.scenarios) == 2      assert \"qux\" in Config.scenarios      def test_override_default_config_with_file_config_including_env_variable_values():      tf = NamedTemporaryFile(          \"\"\"  [JOB]  max_nb_of_workers = \"ENV[FOO]:int\"  start_executor = \"ENV[BAR]\"  \"\"\"      )      assert Config.job_config.max_nb_of_workers == 1      assert not Config.job_config.start_executor        with mock.patch.dict(os.environ, {\"FOO\": \"6\", \"BAR\": \"TRUe\"}):          Config.override(tf.filename)          assert Config.job_config.max_nb_of_workers == 6          assert Config.job_config.start_executor        with mock.patch.dict(os.environ, {\"FOO\": \"foo\", \"BAR\": \"true\"}):          with pytest.raises(InconsistentEnvVariableError):              Config.override(tf.filename)        with mock.patch.dict(os.environ, {\"FOO\": \"5\"}):          with pytest.raises(MissingEnvVariableError):              Config.override(tf.filename)      def test_code_configuration_do_not_override_file_configuration():      config_from_filename = NamedTemporaryFile(          \"\"\"  [JOB]  max_nb_of_workers = 2      \"\"\"      )      Config.override(config_from_filename.filename)        Config.configure_job_executions(max_nb_of_workers=21)        assert Config.job_config.max_nb_of_workers == 2  # From file config      def test_code_configuration_do_not_override_file_configuration_including_env_variable_values():      config_from_filename = NamedTemporaryFile(          \"\"\"  [JOB]  max_nb_of_workers = 2      \"\"\"      )      Config.override(config_from_filename.filename)        with mock.patch.dict(os.environ, {\"FOO\": \"21\"}):          Config.configure_job_executions(max_nb_of_workers=\"ENV[FOO]\")          assert Config.job_config.max_nb_of_workers == 2  # From file config      def test_file_configuration_override_code_configuration():      config_from_filename = NamedTemporaryFile(          \"\"\"  [JOB]  max_nb_of_workers = 2      \"\"\"      )      Config.configure_job_executions(max_nb_of_workers=21)      Config.override(config_from_filename.filename)        assert Config.job_config.max_nb_of_workers == 2  # From file config      def test_file_configuration_override_code_configuration_including_env_variable_values():      config_from_filename = NamedTemporaryFile(          \"\"\"  [JOB]  max_nb_of_workers = \"ENV[FOO]:int\"      \"\"\"      )      Config.configure_job_executions(max_nb_of_workers=21)        with mock.patch.dict(os.environ, {\"FOO\": \"2\"}):          Config.override(config_from_filename.filename)          assert Config.job_config.max_nb_of_workers == 2  # From file config      def test_override_default_configuration_with_multiple_configurations():      file_config = NamedTemporaryFile(          \"\"\"  [DATA_NODE.default]  has_header = true  [DATA_NODE.my_datanode]  path = \"/data/csv\"    [JOB]  max_nb_of_workers = 10    [TAIPY]      \"\"\"      )        # Default config is applied      assert Config.job_config.max_nb_of_workers == 1        # Code config is applied      Config.configure_job_executions(max_nb_of_workers=-1)      assert Config.job_config.max_nb_of_workers == -1        # File config is applied      Config.override(file_config.filename)      assert Config.job_config.max_nb_of_workers == 10      assert Config.data_nodes[\"my_datanode\"].has_header      assert Config.data_nodes[\"my_datanode\"].path == \"/data/csv\"      assert Config.data_nodes[\"my_datanode\"].not_defined is None      def test_override_default_configuration_with_multiple_configurations_including_environment_variable_values():      file_config = NamedTemporaryFile(          \"\"\"  [DATA_NODE.default]  has_header = true  [DATA_NODE.my_datanode]  path = \"ENV[FOO]\"    [JOB]  max_nb_of_workers = 10    [TAIPY]      \"\"\"      )        with mock.patch.dict(os.environ, {\"FOO\": \"/data/csv\", \"BAR\": \"/baz/data/csv\"}):          # Default config is applied          assert Config.job_config.max_nb_of_workers == 1            # Code config is applied          Config.configure_job_executions(max_nb_of_workers=-1)          Config.configure_data_node(\"my_datanode\", path=\"ENV[BAR]\")          assert Config.job_config.max_nb_of_workers == -1          assert Config.data_nodes[\"my_datanode\"].path == \"/baz/data/csv\"            # File config is applied          Config.override(file_config.filename)          assert Config.job_config.max_nb_of_workers == 10          assert Config.data_nodes[\"my_datanode\"].has_header          assert Config.data_nodes[\"my_datanode\"].path == \"/data/csv\"          assert Config.data_nodes[\"my_datanode\"].not_defined is None "}
{"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": "import datetime  import os  from unittest import mock    import pytest    from src.taipy.core import MongoDefaultDocument  from src.taipy.core._orchestrator._orchestrator_factory import _OrchestratorFactory  from src.taipy.core.config import DataNodeConfig  from src.taipy.core.config.job_config import JobConfig  from taipy.config.common.scope import Scope  from taipy.config.config import Config  from taipy.config.exceptions.exceptions import ConfigurationUpdateBlocked      def test_data_node_config_default_parameter():      csv_dn_cfg = Config.configure_data_node(\"data_node_1\", \"csv\")      assert csv_dn_cfg.scope == Scope.SCENARIO      assert csv_dn_cfg.has_header is True      assert csv_dn_cfg.exposed_type == \"pandas\"      assert csv_dn_cfg.validity_period is None        json_dn_cfg = Config.configure_data_node(\"data_node_2\", \"json\")      assert json_dn_cfg.scope == Scope.SCENARIO      assert json_dn_cfg.validity_period is None        parquet_dn_cfg = Config.configure_data_node(\"data_node_3\", \"parquet\")      assert parquet_dn_cfg.scope == Scope.SCENARIO      assert parquet_dn_cfg.engine == \"pyarrow\"      assert parquet_dn_cfg.compression == \"snappy\"      assert parquet_dn_cfg.exposed_type == \"pandas\"      assert parquet_dn_cfg.validity_period is None        excel_dn_cfg = Config.configure_data_node(\"data_node_4\", \"excel\")      assert excel_dn_cfg.scope == Scope.SCENARIO      assert excel_dn_cfg.has_header is True      assert excel_dn_cfg.exposed_type == \"pandas\"      assert excel_dn_cfg.validity_period is None        generic_dn_cfg = Config.configure_data_node(\"data_node_5\", \"generic\")      assert generic_dn_cfg.scope == Scope.SCENARIO      assert generic_dn_cfg.validity_period is None        in_memory_dn_cfg = Config.configure_data_node(\"data_node_6\", \"in_memory\")      assert in_memory_dn_cfg.scope == Scope.SCENARIO      assert in_memory_dn_cfg.validity_period is None        pickle_dn_cfg = Config.configure_data_node(\"data_node_7\", \"pickle\")      assert pickle_dn_cfg.scope == Scope.SCENARIO      assert pickle_dn_cfg.validity_period is None        sql_table_dn_cfg = Config.configure_data_node(          \"data_node_8\", \"sql_table\", db_name=\"test\", db_engine=\"mssql\", table_name=\"test\"      )      assert sql_table_dn_cfg.scope == Scope.SCENARIO      assert sql_table_dn_cfg.db_host == \"localhost\"      assert sql_table_dn_cfg.db_port == 1433      assert sql_table_dn_cfg.db_driver == \"\"      assert sql_table_dn_cfg.sqlite_file_extension == \".db\"      assert sql_table_dn_cfg.exposed_type == \"pandas\"      assert sql_table_dn_cfg.validity_period is None        sql_dn_cfg = Config.configure_data_node(          \"data_node_9\", \"sql\", db_name=\"test\", db_engine=\"mssql\", read_query=\"test\", write_query_builder=print      )      assert sql_dn_cfg.scope == Scope.SCENARIO      assert sql_dn_cfg.db_host == \"localhost\"      assert sql_dn_cfg.db_port == 1433      assert sql_dn_cfg.db_driver == \"\"      assert sql_dn_cfg.sqlite_file_extension == \".db\"      assert sql_dn_cfg.exposed_type == \"pandas\"      assert sql_dn_cfg.validity_period is None        mongo_dn_cfg = Config.configure_data_node(          \"data_node_10\", \"mongo_collection\", db_name=\"test\", collection_name=\"test\"      )      assert mongo_dn_cfg.scope == Scope.SCENARIO      assert mongo_dn_cfg.db_host == \"localhost\"      assert mongo_dn_cfg.db_port == 27017      assert mongo_dn_cfg.custom_document == MongoDefaultDocument      assert mongo_dn_cfg.db_username == \"\"      assert mongo_dn_cfg.db_password == \"\"      assert mongo_dn_cfg.db_driver == \"\"      assert mongo_dn_cfg.validity_period is None      def test_data_node_config_check(caplog):      data_node_config = Config.configure_data_node(\"data_nodes1\", \"pickle\")      assert list(Config.data_nodes) == [DataNodeConfig._DEFAULT_KEY, data_node_config.id]        data_node2_config = Config.configure_data_node(\"data_nodes2\", \"pickle\")      assert list(Config.data_nodes) == [DataNodeConfig._DEFAULT_KEY, data_node_config.id, data_node2_config.id]        data_node3_config = Config.configure_data_node(\"data_nodes3\", \"csv\", has_header=True, default_path=\"\")      assert list(Config.data_nodes) == [          \"default\",          data_node_config.id,          data_node2_config.id,          data_node3_config.id,      ]        with pytest.raises(SystemExit):          Config.configure_data_node(\"data_nodes\", storage_type=\"bar\")          Config.check()      expected_error_message = (          \"`storage_type` field of DataNodeConfig `data_nodes` must be either csv, sql_table,\"          \" sql, mongo_collection, pickle, excel, generic, json, parquet, or in_memory. Current\"          ' value of property `storage_type` is \"bar\".'      )      assert expected_error_message in caplog.text        with pytest.raises(SystemExit):          Config.configure_data_node(\"data_nodes\", scope=\"bar\")          Config.check()      expected_error_message = (          \"`scope` field of DataNodeConfig `data_nodes` must be populated with a Scope value.\"          ' Current value of property `scope` is \"bar\".'      )      assert expected_error_message in caplog.text        with pytest.raises(TypeError):          Config.configure_data_node(\"data_nodes\", storage_type=\"sql\")        with pytest.raises(SystemExit):          Config.configure_data_node(\"data_nodes\", storage_type=\"generic\")          Config.check()      expected_error_message = (          \"`storage_type` field of DataNodeConfig `data_nodes` must be either csv, sql_table,\"          \" sql, mongo_collection, pickle, excel, generic, json, parquet, or in_memory.\"          ' Current value of property `storage_type` is \"bar\".'      )      assert expected_error_message in caplog.text      def test_configure_data_node_from_another_configuration():      d1_cfg = Config.configure_sql_table_data_node(          \"d1\",          db_username=\"foo\",          db_password=\"bar\",          db_name=\"db\",          db_engine=\"mssql\",          db_port=8080,          db_host=\"somewhere\",          table_name=\"foo\",          scope=Scope.GLOBAL,          foo=\"bar\",      )        d2_cfg = Config.configure_data_node_from(          source_configuration=d1_cfg,          id=\"d2\",          table_name=\"table_2\",      )        assert d2_cfg.id == \"d2\"      assert d2_cfg.storage_type == \"sql_table\"      assert d2_cfg.scope == Scope.GLOBAL      assert d2_cfg.validity_period is None      assert d2_cfg.db_username == \"foo\"      assert d2_cfg.db_password == \"bar\"      assert d2_cfg.db_name == \"db\"      assert d2_cfg.db_engine == \"mssql\"      assert d2_cfg.db_port == 8080      assert d2_cfg.db_host == \"somewhere\"      assert d2_cfg.table_name == \"table_2\"      assert d2_cfg.foo == \"bar\"        d3_cfg = Config.configure_data_node_from(          source_configuration=d1_cfg,          id=\"d3\",          scope=Scope.SCENARIO,          validity_period=datetime.timedelta(days=1),          table_name=\"table_3\",          foo=\"baz\",      )        assert d3_cfg.id == \"d3\"      assert d3_cfg.storage_type == \"sql_table\"      assert d3_cfg.scope == Scope.SCENARIO      assert d3_cfg.validity_period == datetime.timedelta(days=1)      assert d3_cfg.db_username == \"foo\"      assert d3_cfg.db_password == \"bar\"      assert d3_cfg.db_name == \"db\"      assert d3_cfg.db_engine == \"mssql\"      assert d3_cfg.db_port == 8080      assert d3_cfg.db_host == \"somewhere\"      assert d3_cfg.table_name == \"table_3\"      assert d3_cfg.foo == \"baz\"      def test_data_node_count():      Config.configure_data_node(\"data_nodes1\", \"pickle\")      assert len(Config.data_nodes) == 2        Config.configure_data_node(\"data_nodes2\", \"pickle\")      assert len(Config.data_nodes) == 3        Config.configure_data_node(\"data_nodes3\", \"pickle\")      assert len(Config.data_nodes) == 4      def test_data_node_getitem():      data_node_id = \"data_nodes1\"      data_node_config = Config.configure_data_node(data_node_id, \"pickle\", default_path=\"foo.p\")        assert Config.data_nodes[data_node_id].id == data_node_config.id      assert Config.data_nodes[data_node_id].default_path == \"foo.p\"      assert Config.data_nodes[data_node_id].storage_type == data_node_config.storage_type      assert Config.data_nodes[data_node_id].scope == data_node_config.scope      assert Config.data_nodes[data_node_id].properties == data_node_config.properties      assert Config.data_nodes[data_node_id].cacheable == data_node_config.cacheable      def test_data_node_creation_no_duplication():      Config.configure_data_node(\"data_nodes1\", \"pickle\")        assert len(Config.data_nodes) == 2        Config.configure_data_node(\"data_nodes1\", \"pickle\")      assert len(Config.data_nodes) == 2      def test_date_node_create_with_datetime():      data_node_config = Config.configure_data_node(          id=\"datetime_data\",          my_property=datetime.datetime(1991, 1, 1),          foo=\"hello\",          test=1,          test_dict={\"type\": \"Datetime\", 2: \"daw\"},      )      assert data_node_config.foo == \"hello\"      assert data_node_config.my_property == datetime.datetime(1991, 1, 1)      assert data_node_config.test == 1      assert data_node_config.test_dict.get(\"type\") == \"Datetime\"      def test_data_node_with_env_variable_value():      with mock.patch.dict(os.environ, {\"FOO\": \"pickle\", \"BAR\": \"baz\"}):          Config.configure_data_node(\"data_node\", storage_type=\"ENV[FOO]\", prop=\"ENV[BAR]\")          assert Config.data_nodes[\"data_node\"].prop == \"baz\"          assert Config.data_nodes[\"data_node\"].properties[\"prop\"] == \"baz\"          assert Config.data_nodes[\"data_node\"]._properties[\"prop\"] == \"ENV[BAR]\"          assert Config.data_nodes[\"data_node\"].storage_type == \"pickle\"          assert Config.data_nodes[\"data_node\"]._storage_type == \"ENV[FOO]\"      def test_data_node_with_env_variable_in_write_fct_args():      def read_fct():          ...        def write_fct():          ...        with mock.patch.dict(os.environ, {\"FOO\": \"bar\", \"BAZ\": \"qux\"}):          Config.configure_data_node(              \"data_node\",              storage_type=\"generic\",              read_fct=read_fct,              write_fct=write_fct,              write_fct_args=[\"ENV[FOO]\", \"my_param\", \"ENV[BAZ]\"],          )          assert Config.data_nodes[\"data_node\"].write_fct_args == [\"bar\", \"my_param\", \"qux\"]      def test_data_node_with_env_variable_in_read_fct_args():      def read_fct():          ...        def write_fct():          ...        with mock.patch.dict(os.environ, {\"FOO\": \"bar\", \"BAZ\": \"qux\"}):          Config.configure_data_node(              \"data_node\",              storage_type=\"generic\",              read_fct=read_fct,              write_fct=write_fct,              read_fct_args=[\"ENV[FOO]\", \"my_param\", \"ENV[BAZ]\"],          )          assert Config.data_nodes[\"data_node\"].read_fct_args == [\"bar\", \"my_param\", \"qux\"]      def test_block_datanode_config_update_in_development_mode():      data_node_id = \"data_node_id\"      Config.configure_job_executions(mode=JobConfig._DEVELOPMENT_MODE)      data_node_config = Config.configure_data_node(          id=data_node_id,          storage_type=\"pickle\",          default_path=\"foo.p\",          scope=Scope.SCENARIO,      )        assert Config.data_nodes[data_node_id].id == data_node_id      assert Config.data_nodes[data_node_id].default_path == \"foo.p\"      assert Config.data_nodes[data_node_id].storage_type == \"pickle\"      assert Config.data_nodes[data_node_id].scope == Scope.SCENARIO      assert Config.data_nodes[data_node_id].properties == {\"default_path\": \"foo.p\"}        _OrchestratorFactory._build_dispatcher()        with pytest.raises(ConfigurationUpdateBlocked):          data_node_config.storage_type = \"foo\"        with pytest.raises(ConfigurationUpdateBlocked):          data_node_config.scope = Scope.SCENARIO        with pytest.raises(ConfigurationUpdateBlocked):          data_node_config.cacheable = True        with pytest.raises(ConfigurationUpdateBlocked):          data_node_config.properties = {\"foo\": \"bar\"}        assert Config.data_nodes[data_node_id].id == data_node_id      assert Config.data_nodes[data_node_id].default_path == \"foo.p\"      assert Config.data_nodes[data_node_id].storage_type == \"pickle\"      assert Config.data_nodes[data_node_id].scope == Scope.SCENARIO      assert Config.data_nodes[data_node_id].properties == {\"default_path\": \"foo.p\"}      def test_block_datanode_config_update_in_standalone_mode():      data_node_id = \"data_node_id\"      Config.configure_job_executions(mode=JobConfig._STANDALONE_MODE)      data_node_config = Config.configure_data_node(          id=data_node_id,          storage_type=\"pickle\",          default_path=\"foo.p\",          scope=Scope.SCENARIO,      )        assert Config.data_nodes[data_node_id].id == data_node_id      assert Config.data_nodes[data_node_id].default_path == \"foo.p\"      assert Config.data_nodes[data_node_id].storage_type == \"pickle\"      assert Config.data_nodes[data_node_id].scope == Scope.SCENARIO      assert Config.data_nodes[data_node_id].properties == {\"default_path\": \"foo.p\"}        _OrchestratorFactory._build_dispatcher()        with pytest.raises(ConfigurationUpdateBlocked):          data_node_config.storage_type = \"foo\"        with pytest.raises(ConfigurationUpdateBlocked):          data_node_config.scope = Scope.SCENARIO        with pytest.raises(ConfigurationUpdateBlocked):          data_node_config.cacheable = True        with pytest.raises(ConfigurationUpdateBlocked):          data_node_config.properties = {\"foo\": \"bar\"}        assert Config.data_nodes[data_node_id].id == data_node_id      assert Config.data_nodes[data_node_id].default_path == \"foo.p\"      assert Config.data_nodes[data_node_id].storage_type == \"pickle\"      assert Config.data_nodes[data_node_id].scope == Scope.SCENARIO      assert Config.data_nodes[data_node_id].properties == {\"default_path\": \"foo.p\"}      def test_clean_config():      dn1_config = Config.configure_data_node(          id=\"id1\",          storage_type=\"csv\",          default_path=\"foo.p\",          scope=Scope.GLOBAL,          validity_period=datetime.timedelta(2),      )      dn2_config = Config.configure_data_node(          id=\"id2\",          storage_type=\"json\",          default_path=\"bar.json\",          scope=Scope.GLOBAL,          validity_period=datetime.timedelta(2),      )        assert Config.data_nodes[\"id1\"] is dn1_config      assert Config.data_nodes[\"id2\"] is dn2_config        dn1_config._clean()      dn2_config._clean()        # Check if the instance before and after _clean() is the same      assert Config.data_nodes[\"id1\"] is dn1_config      assert Config.data_nodes[\"id2\"] is dn2_config        # Check if the value is similar to the default_config, but with difference instances      assert dn1_config.id == \"id1\"      assert dn2_config.id == \"id2\"      assert dn1_config.storage_type == dn2_config.storage_type == \"pickle\"      assert dn1_config.scope == dn2_config.scope == Scope.SCENARIO      assert dn1_config.validity_period is dn2_config.validity_period is None      assert dn1_config.default_path is dn2_config.default_path is None      assert dn1_config.properties == dn2_config.properties == {}      def test_deprecated_cacheable_attribute_remains_compatible():      dn_1_id = \"dn_1_id\"      dn_1_config = Config.configure_data_node(          id=dn_1_id,          storage_type=\"pickle\",          cacheable=False,          scope=Scope.SCENARIO,      )      assert Config.data_nodes[dn_1_id].id == dn_1_id      assert Config.data_nodes[dn_1_id].storage_type == \"pickle\"      assert Config.data_nodes[dn_1_id].scope == Scope.SCENARIO      assert Config.data_nodes[dn_1_id].properties == {\"cacheable\": False}      assert not Config.data_nodes[dn_1_id].cacheable      dn_1_config.cacheable = True      assert Config.data_nodes[dn_1_id].properties == {\"cacheable\": True}      assert Config.data_nodes[dn_1_id].cacheable        dn_2_id = \"dn_2_id\"      dn_2_config = Config.configure_data_node(          id=dn_2_id,          storage_type=\"pickle\",          cacheable=True,          scope=Scope.SCENARIO,      )      assert Config.data_nodes[dn_2_id].id == dn_2_id      assert Config.data_nodes[dn_2_id].storage_type == \"pickle\"      assert Config.data_nodes[dn_2_id].scope == Scope.SCENARIO      assert Config.data_nodes[dn_2_id].properties == {\"cacheable\": True}      assert Config.data_nodes[dn_2_id].cacheable      dn_2_config.cacheable = False      assert Config.data_nodes[dn_1_id].properties == {\"cacheable\": False}      assert not Config.data_nodes[dn_1_id].cacheable        dn_3_id = \"dn_3_id\"      dn_3_config = Config.configure_data_node(          id=dn_3_id,          storage_type=\"pickle\",          scope=Scope.SCENARIO,      )      assert Config.data_nodes[dn_3_id].id == dn_3_id      assert Config.data_nodes[dn_3_id].storage_type == \"pickle\"      assert Config.data_nodes[dn_3_id].scope == Scope.SCENARIO      assert Config.data_nodes[dn_3_id].properties == {}      assert not Config.data_nodes[dn_3_id].cacheable      dn_3_config.cacheable = True      assert Config.data_nodes[dn_3_id].properties == {\"cacheable\": True}      assert Config.data_nodes[dn_3_id].cacheable "}
{"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 copy import copy    import pytest    from src.taipy.core.config import TaskConfig  from src.taipy.core.config.data_node_config import DataNodeConfig  from taipy.config.checker.issue_collector import IssueCollector  from taipy.config.config import Config      class TestTaskConfigChecker:      def test_check_config_id(self, caplog):          config = Config._applied_config          Config._compile_configs()          Config._collector = IssueCollector()          Config.check()          assert len(Config._collector.errors) == 0          assert len(Config._collector.warnings) == 0            config._sections[TaskConfig.name][\"new\"] = copy(config._sections[TaskConfig.name][\"default\"])          config._sections[TaskConfig.name][\"new\"].id = None          with pytest.raises(SystemExit):              Config._collector = IssueCollector()              Config.check()          assert len(Config._collector.errors) == 2          assert \"config_id of TaskConfig `None` is empty\" in caplog.text          assert \"function field of TaskConfig `new` is empty\" in caplog.text          assert len(Config._collector.warnings) == 2          assert \"inputs field of TaskConfig `new` is empty.\" in caplog.text          assert \"outputs field of TaskConfig `new` is empty.\" in caplog.text            caplog.clear()            config._sections[TaskConfig.name][\"new\"].id = \"new\"          with pytest.raises(SystemExit):              Config._collector = IssueCollector()              Config.check()          assert len(Config._collector.errors) == 1          assert len(Config._collector.warnings) == 2        def test_check_if_entity_property_key_used_is_predefined(self, caplog):          Config._collector = IssueCollector()          config = Config._applied_config          Config._compile_configs()          Config.check()          assert len(Config._collector.errors) == 0            config._sections[TaskConfig.name][\"new\"] = copy(config._sections[TaskConfig.name][\"default\"])          config._sections[TaskConfig.name][\"new\"]._properties[\"_entity_owner\"] = None          with pytest.raises(SystemExit):              Config._collector = IssueCollector()              Config.check()          assert len(Config._collector.errors) == 2          assert \"function field of TaskConfig `new` is empty\" in caplog.text          assert \"Properties of TaskConfig `default` cannot have `_entity_owner` as its property.\" in caplog.text            caplog.clear()            config._sections[TaskConfig.name][\"new\"] = copy(config._sections[TaskConfig.name][\"default\"])          config._sections[TaskConfig.name][\"new\"]._properties[\"_entity_owner\"] = \"entity_owner\"          with pytest.raises(SystemExit):              Config._collector = IssueCollector()              Config.check()          assert len(Config._collector.errors) == 2          assert \"function field of TaskConfig `new` is empty\" in caplog.text          expected_error_message = (              \"Properties of TaskConfig `default` 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_inputs(self, caplog):          config = Config._applied_config          Config._compile_configs()          Config._collector = IssueCollector()          Config.check()          assert len(Config._collector.errors) == 0          assert len(Config._collector.warnings) == 0            config._sections[TaskConfig.name][\"new\"] = config._sections[TaskConfig.name][\"default\"]          config._sections[TaskConfig.name][\"new\"].id, config._sections[TaskConfig.name][\"new\"].function = \"new\", print          Config._collector = IssueCollector()          Config.check()          assert len(Config._collector.errors) == 0          assert len(Config._collector.warnings) == 2          assert \"inputs field of TaskConfig `new` is empty.\" in caplog.text          assert \"outputs field of TaskConfig `new` is empty.\" in caplog.text            config._sections[TaskConfig.name][\"new\"]._inputs = \"bar\"          with pytest.raises(SystemExit):              Config._collector = IssueCollector()              Config.check()          assert len(Config._collector.errors) == 1          expected_error_message = (              \"inputs field of TaskConfig `new` must be populated with a list of DataNodeConfig\"              \" objects. Current value of property `inputs` is ['b', 'a', 'r'].\"          )          assert expected_error_message in caplog.text          assert len(Config._collector.warnings) == 1            config._sections[TaskConfig.name][\"new\"]._inputs = [\"bar\"]          with pytest.raises(SystemExit):              Config._collector = IssueCollector()              Config.check()          assert len(Config._collector.errors) == 1          expected_error_message = (              \"inputs field of TaskConfig `new` must be populated with a list of DataNodeConfig\"              \" objects. Current value of property `inputs` is ['bar'].\"          )          assert expected_error_message in caplog.text          assert len(Config._collector.warnings) == 1            config._sections[TaskConfig.name][\"new\"]._inputs = [DataNodeConfig(\"bar\")]          Config._collector = IssueCollector()          Config.check()          assert len(Config._collector.errors) == 0          assert len(Config._collector.warnings) == 1            config._sections[TaskConfig.name][\"new\"]._inputs = [\"bar\", DataNodeConfig(\"bar\")]          with pytest.raises(SystemExit):              Config._collector = IssueCollector()              Config.check()          assert len(Config._collector.errors) == 1          expected_error_message = (              \"inputs field of TaskConfig `new` must be populated with a list of\"              \" DataNodeConfig objects. Current value of property `inputs` is\"              \" ['bar', <src.taipy.core.config.data_node_config.DataNodeConfig object at\"          )          assert expected_error_message in caplog.text          assert len(Config._collector.warnings) == 1        def test_check_outputs(self, caplog):          config = Config._applied_config          Config._compile_configs()            config._sections[TaskConfig.name][\"default\"]._outputs = \"bar\"          Config._collector = IssueCollector()          Config.check()          assert len(Config._collector.errors) == 0          assert len(Config._collector.warnings) == 0            config._sections[TaskConfig.name][\"new\"] = config._sections[TaskConfig.name][\"default\"]          config._sections[TaskConfig.name][\"new\"].id, config._sections[TaskConfig.name][\"new\"].function = \"new\", print          with pytest.raises(SystemExit):              Config._collector = IssueCollector()              Config.check()          assert len(Config._collector.errors) == 1          expected_error_message = (              \"outputs field of TaskConfig `new` must be populated with a list of DataNodeConfig\"              \" objects. Current value of property `outputs` is ['b', 'a', 'r'].\"          )          assert expected_error_message in caplog.text          assert len(Config._collector.warnings) == 1            config._sections[TaskConfig.name][\"new\"]._outputs = [\"bar\"]          with pytest.raises(SystemExit):              Config._collector = IssueCollector()              Config.check()          assert len(Config._collector.errors) == 1          expected_error_message = (              \"outputs field of TaskConfig `new` must be populated with a list of DataNodeConfig\"              \" objects. Current value of property `outputs` is ['bar'].\"          )          assert expected_error_message in caplog.text          assert len(Config._collector.warnings) == 1            config._sections[TaskConfig.name][\"new\"]._outputs = [DataNodeConfig(\"bar\")]          Config._collector = IssueCollector()          Config.check()          assert len(Config._collector.errors) == 0          assert len(Config._collector.warnings) == 1            config._sections[TaskConfig.name][\"new\"]._outputs = [\"bar\", DataNodeConfig(\"bar\")]          with pytest.raises(SystemExit):              Config._collector = IssueCollector()              Config.check()          assert len(Config._collector.errors) == 1          expected_error_message = (              \"outputs field of TaskConfig `new` must be populated with a list of\"              \" DataNodeConfig objects. Current value of property `outputs` is\"              \" ['bar', <src.taipy.core.config.data_node_config.DataNodeConfig object at\"          )          assert expected_error_message in caplog.text          assert len(Config._collector.warnings) == 1        def test_check_function(self, caplog):          def mock_func():              pass            config = Config._applied_config          Config._compile_configs()            Config._collector = IssueCollector()          Config.check()          assert len(Config._collector.errors) == 0          assert len(Config._collector.warnings) == 0            config._sections[TaskConfig.name][\"new\"] = copy(config._sections[TaskConfig.name][\"default\"])          config._sections[TaskConfig.name][\"new\"].id = \"new\"          with pytest.raises(SystemExit):              Config._collector = IssueCollector()              Config.check()          assert len(Config._collector.errors) == 1          assert \"function field of TaskConfig `new` is empty.\" in caplog.text          assert len(Config._collector.warnings) == 2            config._sections[TaskConfig.name][\"new\"].function = None          with pytest.raises(SystemExit):              Config._collector = IssueCollector()              Config.check()          assert len(Config._collector.errors) == 1          assert \"function field of TaskConfig `new` is empty.\" in caplog.text          assert len(Config._collector.warnings) == 2            config._sections[TaskConfig.name][\"new\"].function = \"bar\"          with pytest.raises(SystemExit):              Config._collector = IssueCollector()              Config.check()          assert len(Config._collector.errors) == 1          expected_error_message = (              \"function field of TaskConfig `new` must be populated with Callable value.\"              ' Current value of property `function` is \"bar\".'          )          assert expected_error_message in caplog.text          assert len(Config._collector.warnings) == 2            config._sections[TaskConfig.name][\"new\"].function = mock_func          Config._collector = IssueCollector()          Config.check()          assert len(Config._collector.errors) == 0          assert len(Config._collector.warnings) == 2 "}
{"text": "from copy import copy  from datetime import timedelta    import pytest    from src.taipy.core.config.data_node_config import DataNodeConfig  from taipy.config import Config  from taipy.config.checker.issue_collector import IssueCollector  from taipy.config.common.scope import Scope      class MyCustomClass:      pass      class TestDataNodeConfigChecker:      def test_check_config_id(self, caplog):          Config._collector = IssueCollector()          config = Config._applied_config          Config._compile_configs()          Config.check()          assert len(Config._collector.errors) == 0            config._sections[DataNodeConfig.name][\"new\"] = copy(config._sections[DataNodeConfig.name][\"default\"])          config._sections[DataNodeConfig.name][\"new\"].id = None          with pytest.raises(SystemExit):              Config._collector = IssueCollector()              Config.check()          assert len(Config._collector.errors) == 1          assert \"config_id of DataNodeConfig `None` is empty.\" in caplog.text            config._sections[DataNodeConfig.name][\"new\"].id = \"new\"          Config._collector = IssueCollector()          Config.check()          assert len(Config._collector.errors) == 0        def test_check_if_entity_property_key_used_is_predefined(self, caplog):          Config._collector = IssueCollector()          config = Config._applied_config          Config._compile_configs()          Config.check()          assert len(Config._collector.errors) == 0            config._sections[DataNodeConfig.name][\"new\"] = copy(config._sections[DataNodeConfig.name][\"default\"])          config._sections[DataNodeConfig.name][\"new\"]._properties[\"_entity_owner\"] = None          with pytest.raises(SystemExit):              Config._collector = IssueCollector()              Config.check()          assert len(Config._collector.errors) == 1          assert \"Properties of DataNodeConfig `default` cannot have `_entity_owner` as its property.\" in caplog.text            config._sections[DataNodeConfig.name][\"new\"] = copy(config._sections[DataNodeConfig.name][\"default\"])          config._sections[DataNodeConfig.name][\"new\"]._properties[\"_entity_owner\"] = \"entity_owner\"          with pytest.raises(SystemExit):              Config._collector = IssueCollector()              Config.check()          assert len(Config._collector.errors) == 1          expected_error_message = (              \"Properties of DataNodeConfig `default` 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_storage_type(self, caplog):          Config._collector = IssueCollector()          config = Config._applied_config          Config._compile_configs()          Config.check()          assert len(Config._collector.errors) == 0            config._sections[DataNodeConfig.name][\"new\"] = copy(config._sections[DataNodeConfig.name][\"default\"])            config._sections[DataNodeConfig.name][\"new\"].storage_type = \"bar\"          with pytest.raises(SystemExit):              Config._collector = IssueCollector()              Config.check()          assert len(Config._collector.errors) == 1          expected_error_message = (              \"`storage_type` field of DataNodeConfig `new` must be either csv, sql_table,\"              \" sql, mongo_collection, pickle, excel, generic, json, parquet, or in_memory.\"              ' Current value of property `storage_type` is \"bar\".'          )          assert expected_error_message in caplog.text            config._sections[DataNodeConfig.name][\"new\"].storage_type = \"csv\"          Config._collector = IssueCollector()          Config.check()          assert len(Config._collector.errors) == 0            config._sections[DataNodeConfig.name][\"new\"].storage_type = \"excel\"          Config._collector = IssueCollector()          Config.check()          assert len(Config._collector.errors) == 0            config._sections[DataNodeConfig.name][\"new\"].storage_type = \"pickle\"          Config._collector = IssueCollector()          Config.check()          assert len(Config._collector.errors) == 0            config._sections[DataNodeConfig.name][\"new\"].storage_type = \"json\"          Config._collector = IssueCollector()          Config.check()          assert len(Config._collector.errors) == 0            config._sections[DataNodeConfig.name][\"new\"].storage_type = \"parquet\"          Config._collector = IssueCollector()          Config.check()          assert len(Config._collector.errors) == 0            config._sections[DataNodeConfig.name][\"new\"].storage_type = \"in_memory\"          Config._collector = IssueCollector()          Config.check()          assert len(Config._collector.errors) == 0            config._sections[DataNodeConfig.name][\"new\"].storage_type = \"generic\"          with pytest.raises(SystemExit):              Config._collector = IssueCollector()              Config.check()          assert len(Config._collector.errors) == 1          expected_error_messages = [              \"Either `read_fct` field or `write_fct` field of DataNodeConfig `new` \"              \"must be populated with a Callable function.\",          ]          assert all(message in caplog.text for message in expected_error_messages)            config._sections[DataNodeConfig.name][\"new\"].storage_type = \"sql_table\"          with pytest.raises(SystemExit):              Config._collector = IssueCollector()              Config.check()          assert len(Config._collector.errors) == 3          expected_error_messages = [              \"DataNodeConfig `new` is missing the required property `db_name` for type `sql_table`.\",              \"DataNodeConfig `new` is missing the required property `db_engine` for type `sql_table`.\",              \"DataNodeConfig `new` is missing the required property `table_name` for type `sql_table`.\",          ]          assert all(message in caplog.text for message in expected_error_messages)            config._sections[DataNodeConfig.name][\"new\"].storage_type = \"sql\"          with pytest.raises(SystemExit):              Config._collector = IssueCollector()              Config.check()          assert len(Config._collector.errors) == 4          expected_error_messages = [              \"DataNodeConfig `new` is missing the required property `db_name` for type `sql`.\",              \"DataNodeConfig `new` is missing the required property `db_engine` for type `sql`.\",              \"DataNodeConfig `new` is missing the required property `read_query` for type `sql`.\",              \"DataNodeConfig `new` is missing the required property `write_query_builder` for type `sql`.\",          ]          assert all(message in caplog.text for message in expected_error_messages)            config._sections[DataNodeConfig.name][\"new\"].storage_type = \"mongo_collection\"          with pytest.raises(SystemExit):              Config._collector = IssueCollector()              Config.check()          assert len(Config._collector.errors) == 2          expected_error_messages = [              \"DataNodeConfig `new` is missing the required property `db_name` for type `mongo_collection`.\",              \"DataNodeConfig `new` is missing the required property `collection_name` for type `mongo_collection`.\",          ]          assert all(message in caplog.text for message in expected_error_messages)        def test_check_properties_of_sqlite_engine(self, caplog):          config = Config._applied_config          Config._compile_configs()          config._sections[DataNodeConfig.name][\"new\"] = copy(config._sections[DataNodeConfig.name][\"default\"])            # Test SQLite engine          config._sections[DataNodeConfig.name][\"new\"].storage_type = \"sql_table\"          config._sections[DataNodeConfig.name][\"new\"].properties = {\"db_engine\": \"sqlite\"}          with pytest.raises(SystemExit):              Config._collector = IssueCollector()              Config.check()          assert len(Config._collector.errors) == 2          expected_error_messages = [              \"DataNodeConfig `new` is missing the required property `db_name` for type `sql_table`.\",              \"DataNodeConfig `new` is missing the required property `table_name` for type `sql_table`.\",          ]          assert all(message in caplog.text for message in expected_error_messages)        def test_check_properties_of_not_sqlite_engine(self, caplog):          config = Config._applied_config          Config._compile_configs()          config._sections[DataNodeConfig.name][\"new\"] = copy(config._sections[DataNodeConfig.name][\"default\"])            # Test other engines          config._sections[DataNodeConfig.name][\"new\"].storage_type = \"sql_table\"          config._sections[DataNodeConfig.name][\"new\"].properties = {\"db_engine\": \"mssql\"}          with pytest.raises(SystemExit):              Config._collector = IssueCollector()              Config.check()          assert len(Config._collector.errors) == 4            config._sections[DataNodeConfig.name][\"new\"].storage_type = \"sql_table\"          config._sections[DataNodeConfig.name][\"new\"].properties = {\"db_engine\": \"mysql\"}          with pytest.raises(SystemExit):              Config._collector = IssueCollector()              Config.check()          assert len(Config._collector.errors) == 4            config._sections[DataNodeConfig.name][\"new\"].storage_type = \"sql_table\"          config._sections[DataNodeConfig.name][\"new\"].properties = {\"db_engine\": \"postgresql\"}          with pytest.raises(SystemExit):              Config._collector = IssueCollector()              Config.check()          assert len(Config._collector.errors) == 4            expected_error_messages = [              \"DataNodeConfig `new` is missing the required property `db_username` for type `sql_table`.\",              \"DataNodeConfig `new` is missing the required property `db_password` for type `sql_table`.\",              \"DataNodeConfig `new` is missing the required property `db_name` for type `sql_table`.\",              \"DataNodeConfig `new` is missing the required property `table_name` for type `sql_table`.\",          ]          assert all(message in caplog.text for message in expected_error_messages)        def test_check_scope(self, caplog):          config = Config._applied_config          Config._compile_configs()            config._sections[DataNodeConfig.name][\"default\"].scope = \"bar\"          with pytest.raises(SystemExit):              Config._collector = IssueCollector()              Config.check()          assert len(Config._collector.errors) == 1          expected_error_message = (              \"`scope` field of DataNodeConfig `default` must be populated with a Scope\"              ' value. Current value of property `scope` is \"bar\".'          )          assert expected_error_message in caplog.text            config._sections[DataNodeConfig.name][\"default\"].scope = 1          with pytest.raises(SystemExit):              Config._collector = IssueCollector()              Config.check()          assert len(Config._collector.errors) == 1          expected_error_message = (              \"`scope` field of DataNodeConfig `default` must be populated with a Scope\"              \" value. Current value of property `scope` is 1.\"          )          assert expected_error_message in caplog.text            config._sections[DataNodeConfig.name][\"default\"].scope = Scope.GLOBAL          Config._collector = IssueCollector()          Config.check()          assert len(Config._collector.errors) == 0          assert len(Config._collector.warnings) == 0            config._sections[DataNodeConfig.name][\"default\"].scope = Scope.CYCLE          Config._collector = IssueCollector()          Config.check()          assert len(Config._collector.errors) == 0          assert len(Config._collector.warnings) == 0            config._sections[DataNodeConfig.name][\"default\"].scope = Scope.SCENARIO          Config._collector = IssueCollector()          Config.check()          assert len(Config._collector.errors) == 0          assert len(Config._collector.warnings) == 0        def test_check_validity_period(self, caplog):          config = Config._applied_config          Config._compile_configs()            config._sections[DataNodeConfig.name][\"default\"].validity_period = \"bar\"          with pytest.raises(SystemExit):              Config._collector = IssueCollector()              Config.check()          assert len(Config._collector.errors) == 1          expected_error_message = (              \"`validity_period` field of DataNodeConfig `default` must be None or populated with\"              ' a timedelta value. Current value of property `validity_period` is \"bar\".'          )          assert expected_error_message in caplog.text            config._sections[DataNodeConfig.name][\"default\"].validity_period = 1          with pytest.raises(SystemExit):              Config._collector = IssueCollector()              Config.check()          assert len(Config._collector.errors) == 1          expected_error_message = (              \"`validity_period` field of DataNodeConfig `default` must be None or populated with\"              \" a timedelta value. Current value of property `validity_period` is 1.\"          )          assert expected_error_message in caplog.text            config._sections[DataNodeConfig.name][\"default\"].validity_period = None          Config._collector = IssueCollector()          Config.check()          assert len(Config._collector.errors) == 0          assert len(Config._collector.warnings) == 0            config._sections[DataNodeConfig.name][\"default\"].validity_period = timedelta(1)          Config._collector = IssueCollector()          Config.check()          assert len(Config._collector.errors) == 0          assert len(Config._collector.warnings) == 0        def test_check_required_properties(self, caplog):          config = Config._applied_config          Config._compile_configs()          config._sections[DataNodeConfig.name][\"new\"] = copy(config._sections[DataNodeConfig.name][\"default\"])            config._sections[DataNodeConfig.name][\"new\"].storage_type = \"csv\"          Config._collector = IssueCollector()          Config.check()          assert len(Config._collector.errors) == 0            config._sections[DataNodeConfig.name][\"new\"].storage_type = \"csv\"          config._sections[DataNodeConfig.name][\"new\"].properties = {\"has_header\": True}          Config._collector = IssueCollector()          Config.check()          assert len(Config._collector.errors) == 0            config._sections[DataNodeConfig.name][\"new\"].storage_type = \"csv\"          config._sections[DataNodeConfig.name][\"new\"].properties = {\"path\": \"bar\"}          Config._collector = IssueCollector()          Config.check()          assert len(Config._collector.errors) == 0            required_properties = [\"db_username\", \"db_password\", \"db_name\", \"db_engine\", \"table_name\"]          config._sections[DataNodeConfig.name][\"new\"].storage_type = \"sql_table\"          config._sections[DataNodeConfig.name][\"new\"].properties = {key: f\"the_{key}\" for key in required_properties}          Config._collector = IssueCollector()          Config.check()          assert len(Config._collector.errors) == 0            config._sections[DataNodeConfig.name][\"new\"].storage_type = \"sql\"          config._sections[DataNodeConfig.name][\"new\"].properties = {              \"db_username\": \"foo\",              \"db_password\": \"foo\",              \"db_name\": \"foo\",              \"db_engine\": \"foo\",              \"read_query\": \"foo\",              \"write_query_builder\": print,          }          Config._collector = IssueCollector()          Config.check()          assert len(Config._collector.errors) == 0            config._sections[DataNodeConfig.name][\"new\"].storage_type = \"mongo_collection\"          config._sections[DataNodeConfig.name][\"new\"].properties = {\"db_name\": \"foo\", \"collection_name\": \"bar\"}          Config._collector = IssueCollector()          Config.check()          assert len(Config._collector.errors) == 0            config._sections[DataNodeConfig.name][\"new\"].storage_type = \"excel\"          Config._collector = IssueCollector()          Config.check()          assert len(Config._collector.errors) == 0            config._sections[DataNodeConfig.name][\"new\"].storage_type = \"excel\"          config._sections[DataNodeConfig.name][\"new\"].properties = {\"has_header\": True}          Config._collector = IssueCollector()          Config.check()          assert len(Config._collector.errors) == 0            config._sections[DataNodeConfig.name][\"new\"].storage_type = \"excel\"          config._sections[DataNodeConfig.name][\"new\"].properties = {\"path\": \"bar\"}          Config._collector = IssueCollector()          Config.check()          assert len(Config._collector.errors) == 0            config._sections[DataNodeConfig.name][\"new\"].storage_type = \"excel\"          config._sections[DataNodeConfig.name][\"new\"].properties = {              \"has_header\": True,              \"path\": \"bar\",              \"sheet_name\": [\"sheet_name_1\", \"sheet_name_2\"],          }          Config._collector = IssueCollector()          Config.check()          assert len(Config._collector.errors) == 0            config._sections[DataNodeConfig.name][\"new\"].storage_type = \"generic\"          with pytest.raises(SystemExit):              Config._collector = IssueCollector()              Config.check()          assert len(Config._collector.errors) == 1            config._sections[DataNodeConfig.name][\"new\"].storage_type = \"generic\"          config._sections[DataNodeConfig.name][\"new\"].properties = {\"read_fct\": print}          Config._collector = IssueCollector()          Config.check()          assert len(Config._collector.errors) == 0            config._sections[DataNodeConfig.name][\"new\"].storage_type = \"generic\"          config._sections[DataNodeConfig.name][\"new\"].properties = {\"write_fct\": print}          Config._collector = IssueCollector()          Config.check()          assert len(Config._collector.errors) == 0            config._sections[DataNodeConfig.name][\"new\"].storage_type = \"generic\"          config._sections[DataNodeConfig.name][\"new\"].properties = {\"write_fct\": print, \"read_fct\": print}          Config._collector = IssueCollector()          Config.check()          assert len(Config._collector.errors) == 0            config._sections[DataNodeConfig.name][\"new\"].storage_type = \"json\"          config._sections[DataNodeConfig.name][\"new\"].properties = {\"default_path\": \"bar\"}          Config._collector = IssueCollector()          Config.check()          assert len(Config._collector.errors) == 0        def test_required_properties_on_default_only_raise_warning(self):          config = Config._applied_config          Config._compile_configs()          config._sections[DataNodeConfig.name][\"new\"] = copy(config._sections[DataNodeConfig.name][\"default\"])            config._sections[DataNodeConfig.name][\"default\"].storage_type = \"generic\"          Config._collector = IssueCollector()          Config.check()          assert len(Config._collector.errors) == 0          assert len(Config._collector.warnings) == 0            config._sections[DataNodeConfig.name][\"new\"].storage_type = \"generic\"          with pytest.raises(SystemExit):              Config._collector = IssueCollector()              Config.check()          assert len(Config._collector.errors) == 1        def test_check_callable_properties(self, caplog):          config = Config._applied_config          Config._compile_configs()          config._sections[DataNodeConfig.name][\"new\"] = copy(config._sections[DataNodeConfig.name][\"default\"])            config._sections[DataNodeConfig.name][\"new\"].storage_type = \"sql\"          config._sections[DataNodeConfig.name][\"new\"].properties = {              \"db_username\": \"foo\",              \"db_password\": \"foo\",              \"db_name\": \"foo\",              \"db_engine\": \"foo\",              \"read_query\": \"foo\",              \"write_query_builder\": 1,              \"append_query_builder\": 2,          }          with pytest.raises(SystemExit):              Config._collector = IssueCollector()              Config.check()          assert len(Config._collector.errors) == 2          expected_error_message_1 = (              \"`write_query_builder` of DataNodeConfig `new` must be populated with a Callable function.\"              \" Current value of property `write_query_builder` is 1.\"          )          assert expected_error_message_1 in caplog.text          expected_error_message_2 = (              \"`append_query_builder` of DataNodeConfig `new` must be populated with a Callable function.\"              \" Current value of property `append_query_builder` is 2.\"          )          assert expected_error_message_2 in caplog.text            config._sections[DataNodeConfig.name][\"new\"].storage_type = \"generic\"          config._sections[DataNodeConfig.name][\"new\"].properties = {\"write_fct\": 12}          with pytest.raises(SystemExit):              Config._collector = IssueCollector()              Config.check()          assert len(Config._collector.errors) == 1          expected_error_messages = [              \"`write_fct` of DataNodeConfig `new` must be populated with a Callable function. Current value\"              \" of property `write_fct` is 12.\",          ]          assert all(message in caplog.text for message in expected_error_messages)            config._sections[DataNodeConfig.name][\"new\"].storage_type = \"generic\"          config._sections[DataNodeConfig.name][\"new\"].properties = {\"read_fct\": 5}          with pytest.raises(SystemExit):              Config._collector = IssueCollector()              Config.check()          assert len(Config._collector.errors) == 1          expected_error_messages = [              \"`read_fct` of DataNodeConfig `new` must be populated with a Callable function. Current value\"              \" of property `read_fct` is 5.\",          ]          assert all(message in caplog.text for message in expected_error_messages)            config._sections[DataNodeConfig.name][\"new\"].storage_type = \"generic\"          config._sections[DataNodeConfig.name][\"new\"].properties = {\"write_fct\": 9, \"read_fct\": 5}          with pytest.raises(SystemExit):              Config._collector = IssueCollector()              Config.check()          assert len(Config._collector.errors) == 2          expected_error_messages = [              \"`write_fct` of DataNodeConfig `new` must be populated with a Callable function. Current value\"              \" of property `write_fct` is 9.\",              \"`read_fct` of DataNodeConfig `new` must be populated with a Callable function. Current value\"              \" of property `read_fct` is 5.\",          ]          assert all(message in caplog.text for message in expected_error_messages)            config._sections[DataNodeConfig.name][\"new\"].storage_type = \"generic\"          config._sections[DataNodeConfig.name][\"new\"].properties = {\"write_fct\": print, \"read_fct\": 5}          with pytest.raises(SystemExit):              Config._collector = IssueCollector()              Config.check()          assert len(Config._collector.errors) == 1            config._sections[DataNodeConfig.name][\"new\"].storage_type = \"generic\"          config._sections[DataNodeConfig.name][\"new\"].properties = {\"write_fct\": 5, \"read_fct\": print}          with pytest.raises(SystemExit):              Config._collector = IssueCollector()              Config.check()          assert len(Config._collector.errors) == 1            config._sections[DataNodeConfig.name][\"new\"].storage_type = \"generic\"          config._sections[DataNodeConfig.name][\"new\"].properties = {\"write_fct\": print, \"read_fct\": print}          Config._collector = IssueCollector()          Config.check()          assert len(Config._collector.errors) == 0        def test_check_read_write_fct_args(self, caplog):          config = Config._applied_config          Config._compile_configs()            config._sections[DataNodeConfig.name][\"default\"].storage_type = \"generic\"          config._sections[DataNodeConfig.name][\"default\"].properties = {\"write_fct\": print, \"read_fct\": print}          Config._collector = IssueCollector()          Config.check()          assert len(Config._collector.errors) == 0            config._sections[DataNodeConfig.name][\"default\"].storage_type = \"generic\"          config._sections[DataNodeConfig.name][\"default\"].properties = {              \"write_fct\": print,              \"read_fct\": print,              \"write_fct_args\": \"foo\",          }          with pytest.raises(SystemExit):              Config._collector = IssueCollector()              Config.check()          assert len(Config._collector.errors) == 1          expected_error_message = (              \"`write_fct_args` field of DataNodeConfig `default` must be populated with a List value.\"              ' Current value of property `write_fct_args` is \"foo\".'          )          assert expected_error_message in caplog.text          config._sections[DataNodeConfig.name][\"default\"].storage_type = \"generic\"          config._sections[DataNodeConfig.name][\"default\"].properties = {              \"write_fct\": print,              \"read_fct\": print,              \"write_fct_args\": list(\"foo\"),          }          Config._collector = IssueCollector()          Config.check()          assert len(Config._collector.errors) == 0            config._sections[DataNodeConfig.name][\"default\"].storage_type = \"generic\"          config._sections[DataNodeConfig.name][\"default\"].properties = {              \"write_fct\": print,              \"read_fct\": print,              \"read_fct_args\": 1,          }          with pytest.raises(SystemExit):              Config._collector = IssueCollector()              Config.check()          assert len(Config._collector.errors) == 1          expected_error_message = (              \"`read_fct_args` field of DataNodeConfig `default` must be populated with a List value.\"              \" Current value of property `read_fct_args` is 1.\"          )          assert expected_error_message in caplog.text            config._sections[DataNodeConfig.name][\"default\"].storage_type = \"generic\"          config._sections[DataNodeConfig.name][\"default\"].properties = {              \"write_fct\": print,              \"read_fct\": print,              \"read_fct_args\": list(\"foo\"),          }          Config._collector = IssueCollector()          Config.check()          assert len(Config._collector.errors) == 0            config._sections[DataNodeConfig.name][\"default\"].storage_type = \"generic\"          config._sections[DataNodeConfig.name][\"default\"].properties = {              \"write_fct\": print,              \"read_fct\": print,              \"write_fct_args\": [\"foo\"],              \"read_fct_args\": [\"foo\"],          }          Config._collector = IssueCollector()          Config.check()          assert len(Config._collector.errors) == 0        def test_check_exposed_types(self, caplog):          config = Config._applied_config          Config._compile_configs()            config._sections[DataNodeConfig.name][\"default\"].storage_type = \"csv\"          config._sections[DataNodeConfig.name][\"default\"].properties = {\"exposed_type\": \"foo\"}          with pytest.raises(SystemExit):              Config._collector = IssueCollector()              Config.check()          assert len(Config._collector.errors) == 1          expected_error_message = (              'The `exposed_type` of DataNodeConfig `default` must be either \"pandas\", \"modin\"'              ', \"numpy\", or a custom type. Current value of property `exposed_type` is \"foo\".'          )          assert expected_error_message in caplog.text            config._sections[DataNodeConfig.name][\"default\"].properties = {\"exposed_type\": \"pandas\"}          Config._collector = IssueCollector()          Config.check()          assert len(Config._collector.errors) == 0            config._sections[DataNodeConfig.name][\"default\"].properties = {\"exposed_type\": \"modin\"}          Config._collector = IssueCollector()          Config.check()          assert len(Config._collector.errors) == 0            config._sections[DataNodeConfig.name][\"default\"].properties = {\"exposed_type\": \"numpy\"}          Config._collector = IssueCollector()          Config.check()          assert len(Config._collector.errors) == 0            config._sections[DataNodeConfig.name][\"default\"].properties = {\"exposed_type\": MyCustomClass}          Config.check()          assert len(Config._collector.errors) == 0 "}
{"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": "from copy import copy    import pytest    from src.taipy.core.config import ScenarioConfig  from src.taipy.core.config.data_node_config import DataNodeConfig  from src.taipy.core.config.task_config import TaskConfig  from taipy.config.checker.issue_collector import IssueCollector  from taipy.config.common.frequency import Frequency  from taipy.config.config import Config      def subtraction(n1, n2):      return n1 - n2      class TestScenarioConfigChecker:      def test_check_config_id(self, caplog):          Config._collector = IssueCollector()          config = Config._applied_config          Config._compile_configs()          Config.check()          assert len(Config._collector.errors) == 0          assert len(Config._collector.warnings) == 0          assert len(Config._collector.infos) == 0            config._sections[ScenarioConfig.name][\"new\"] = copy(config._sections[ScenarioConfig.name][\"default\"])          config._sections[ScenarioConfig.name][\"new\"].id = None          with pytest.raises(SystemExit):              Config._collector = IssueCollector()              Config.check()          assert len(Config._collector.errors) == 1          assert \"config_id of ScenarioConfig `None` is empty\" in caplog.text          assert len(Config._collector.warnings) == 1          assert \"tasks field of ScenarioConfig `new` is empty.\" in caplog.text          assert len(Config._collector.infos) == 0            caplog.clear()            config._sections[ScenarioConfig.name][\"new\"].id = \"new\"          Config._collector = IssueCollector()          Config.check()          assert len(Config._collector.errors) == 0          assert len(Config._collector.warnings) == 1          assert \"tasks field of ScenarioConfig `new` is empty.\" in caplog.text          assert len(Config._collector.infos) == 0        def test_check_if_entity_property_key_used_is_predefined(self, caplog):          Config._collector = IssueCollector()          config = Config._applied_config          Config._compile_configs()          Config.check()          assert len(Config._collector.errors) == 0            config._sections[ScenarioConfig.name][\"new\"] = copy(config._sections[ScenarioConfig.name][\"default\"])          config._sections[ScenarioConfig.name][\"new\"]._properties[\"_entity_owner\"] = None          with pytest.raises(SystemExit):              Config._collector = IssueCollector()              Config.check()          assert len(Config._collector.errors) == 1          assert \"Properties of ScenarioConfig `default` cannot have `_entity_owner` as its property.\" in caplog.text            config._sections[ScenarioConfig.name][\"new\"] = copy(config._sections[ScenarioConfig.name][\"default\"])          config._sections[ScenarioConfig.name][\"new\"]._properties[\"_entity_owner\"] = \"entity_owner\"          with pytest.raises(SystemExit):              Config._collector = IssueCollector()              Config.check()          assert len(Config._collector.errors) == 1          expected_error_message = (              \"Properties of ScenarioConfig `default` 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_task_configs(self, caplog):          Config._collector = IssueCollector()          config = Config._applied_config          Config._compile_configs()          Config.check()          assert len(Config._collector.errors) == 0          assert len(Config._collector.warnings) == 0          assert len(Config._collector.infos) == 0            config._sections[ScenarioConfig.name][\"new\"] = copy(config._sections[ScenarioConfig.name][\"default\"])          Config.check()          assert len(Config._collector.errors) == 0          assert len(Config._collector.warnings) == 1          assert \"tasks field of ScenarioConfig `new` is empty.\" in caplog.text          assert len(Config._collector.infos) == 0            config._sections[ScenarioConfig.name][\"new\"]._tasks = \"bar\"          with pytest.raises(SystemExit):              Config._collector = IssueCollector()              Config.check()          assert len(Config._collector.errors) == 1          expected_error_message = (              \"tasks field of ScenarioConfig `new` must be populated with a list of\"              ' TaskConfig objects. Current value of property `tasks` is \"bar\".'          )          assert expected_error_message in caplog.text          assert len(Config._collector.warnings) == 0          assert len(Config._collector.infos) == 0            config._sections[ScenarioConfig.name][\"new\"]._tasks = [\"bar\"]          with pytest.raises(SystemExit):              Config._collector = IssueCollector()              Config.check()          assert len(Config._collector.errors) == 1          expected_error_message = (              \"tasks field of ScenarioConfig `new` must be populated with a list of\"              \" TaskConfig objects. Current value of property `tasks` is ['bar'].\"          )          assert expected_error_message in caplog.text          assert len(Config._collector.warnings) == 0          assert len(Config._collector.infos) == 0            config._sections[ScenarioConfig.name][\"new\"]._tasks = [\"bar\", TaskConfig(\"bar\", print)]          with pytest.raises(SystemExit):              Config._collector = IssueCollector()              Config.check()          assert len(Config._collector.errors) == 1          expected_error_message = (              \"tasks field of ScenarioConfig `new` must be populated with a list of\"              \" TaskConfig objects. Current value of property `tasks` is\"              \" ['bar', <src.taipy.core.config.task_config.TaskConfig object at\"          )          assert expected_error_message in caplog.text          assert len(Config._collector.warnings) == 0          assert len(Config._collector.infos) == 0            config._sections[ScenarioConfig.name][\"new\"]._tasks = [TaskConfig(\"bar\", print)]          Config._collector = IssueCollector()          Config.check()          assert len(Config._collector.errors) == 0          assert len(Config._collector.warnings) == 0          assert len(Config._collector.infos) == 0        def test_check_additional_data_node_configs(self, caplog):          Config._collector = IssueCollector()          config = Config._applied_config          Config._compile_configs()          Config.check()          assert len(Config._collector.errors) == 0          assert len(Config._collector.warnings) == 0          assert len(Config._collector.infos) == 0            config._sections[ScenarioConfig.name][\"new\"] = copy(config._sections[ScenarioConfig.name][\"default\"])          config._sections[ScenarioConfig.name][\"new\"]._tasks = [TaskConfig(\"bar\", print)]          Config._collector = IssueCollector()          Config.check()          assert len(Config._collector.errors) == 0          assert len(Config._collector.warnings) == 0          assert len(Config._collector.infos) == 0            config._sections[ScenarioConfig.name][\"new\"]._additional_data_nodes = \"bar\"          with pytest.raises(SystemExit):              Config._collector = IssueCollector()              Config.check()          assert len(Config._collector.errors) == 1          expected_error_message = (              \"additional_data_nodes field of ScenarioConfig `new` must be populated with a list of\"              ' DataNodeConfig objects. Current value of property `additional_data_nodes` is \"bar\".'          )          assert expected_error_message in caplog.text          assert len(Config._collector.warnings) == 0          assert len(Config._collector.infos) == 0            config._sections[ScenarioConfig.name][\"new\"]._additional_data_nodes = [\"bar\"]          with pytest.raises(SystemExit):              Config._collector = IssueCollector()              Config.check()          assert len(Config._collector.errors) == 1          expected_error_message = (              \"additional_data_nodes field of ScenarioConfig `new` must be populated with a list of\"              \" DataNodeConfig objects. Current value of property `additional_data_nodes` is ['bar'].\"          )          assert expected_error_message in caplog.text          assert len(Config._collector.warnings) == 0          assert len(Config._collector.infos) == 0            config._sections[ScenarioConfig.name][\"new\"]._additional_data_nodes = [\"bar\", DataNodeConfig(\"bar\")]          with pytest.raises(SystemExit):              Config._collector = IssueCollector()              Config.check()          assert len(Config._collector.errors) == 1          expected_error_message = (              \"additional_data_nodes field of ScenarioConfig `new` must be populated with a list of\"              \" DataNodeConfig objects. Current value of property `additional_data_nodes` is\"              \" ['bar', <src.taipy.core.config.data_node_config.DataNodeConfig object at\"          )          assert expected_error_message in caplog.text          assert len(Config._collector.warnings) == 0          assert len(Config._collector.infos) == 0            config._sections[ScenarioConfig.name][\"new\"]._additional_data_nodes = [DataNodeConfig(\"bar\")]          Config._collector = IssueCollector()          Config.check()          assert len(Config._collector.errors) == 0          assert len(Config._collector.warnings) == 0          assert len(Config._collector.infos) == 0        def test_check_additional_data_node_configs_not_in_task_input_output_data_nodes(self, caplog):          Config._collector = IssueCollector()          config = Config._applied_config          Config._compile_configs()          Config.check()          assert len(Config._collector.errors) == 0          assert len(Config._collector.warnings) == 0          assert len(Config._collector.infos) == 0            input_dn_config = DataNodeConfig(\"input_dn\")          output_dn_config = DataNodeConfig(\"output_dn\")          config._sections[ScenarioConfig.name][\"new\"] = copy(config._sections[ScenarioConfig.name][\"default\"])          config._sections[ScenarioConfig.name][\"new\"]._tasks = [              TaskConfig(\"bar\", print, [input_dn_config], [output_dn_config])          ]          Config._collector = IssueCollector()          Config.check()          assert len(Config._collector.errors) == 0          assert len(Config._collector.warnings) == 0          assert len(Config._collector.infos) == 0            config._sections[ScenarioConfig.name][\"new\"]._additional_data_nodes = [input_dn_config]          Config._collector = IssueCollector()          Config.check()          assert len(Config._collector.warnings) == 1          expected_warning_message = (              \"The additional data node `input_dn` in additional_data_nodes field of ScenarioConfig \"              \"`new` has already existed as an input or output data node of ScenarioConfig `new` tasks.\"          )          assert expected_warning_message in caplog.text          assert len(Config._collector.errors) == 0          assert len(Config._collector.infos) == 0            config._sections[ScenarioConfig.name][\"new\"]._additional_data_nodes = [input_dn_config, output_dn_config]          Config._collector = IssueCollector()          Config.check()          assert len(Config._collector.warnings) == 2          expected_warning_message_1 = (              \"The additional data node `input_dn` in additional_data_nodes field of ScenarioConfig \"              \"`new` has already existed as an input or output data node of ScenarioConfig `new` tasks.\"          )          expected_warning_message_2 = (              \"The additional data node `output_dn` in additional_data_nodes field of ScenarioConfig \"              \"`new` has already existed as an input or output data node of ScenarioConfig `new` tasks.\"          )          assert expected_warning_message_1 in caplog.text          assert expected_warning_message_2 in caplog.text          assert len(Config._collector.errors) == 0          assert len(Config._collector.infos) == 0            config._sections[ScenarioConfig.name][\"new\"]._additional_data_nodes = [DataNodeConfig(\"bar\")]          Config._collector = IssueCollector()          Config.check()          assert len(Config._collector.errors) == 0          assert len(Config._collector.warnings) == 0          assert len(Config._collector.infos) == 0        def test_check_tasks_in_sequences_exist_in_scenario_tasks(self, caplog):          Config._collector = IssueCollector()          config = Config._applied_config          Config._compile_configs()          Config.check()          assert len(Config._collector.errors) == 0          assert len(Config._collector.warnings) == 0          assert len(Config._collector.infos) == 0            input_dn_config = DataNodeConfig(\"input_dn\")          output_dn_config = DataNodeConfig(\"output_dn\")          task_config_1 = TaskConfig(\"bar\", print, [input_dn_config], [output_dn_config])          task_config_2 = TaskConfig(\"baz\", print, [input_dn_config], [output_dn_config])          config._sections[ScenarioConfig.name][\"new\"] = copy(config._sections[ScenarioConfig.name][\"default\"])          config._sections[ScenarioConfig.name][\"new\"]._tasks = [task_config_1]          config._sections[ScenarioConfig.name][\"new\"].add_sequences({\"sequence_1\": [task_config_1]})          Config._collector = IssueCollector()          Config.check()          assert len(Config._collector.errors) == 0          assert len(Config._collector.warnings) == 0          assert len(Config._collector.infos) == 0            config._sections[ScenarioConfig.name][\"new\"].add_sequences({\"sequence_2\": [\"task_config\"]})          Config._collector = IssueCollector()          with pytest.raises(SystemExit):              Config.check()          assert len(Config._collector.errors) == 1          expected_error_messgae = (              \"sequences field of ScenarioConfig `new` must be populated with a list of\"              \" TaskConfig objects. Current value of property `sequences` is ['task_config'].\"          )          assert expected_error_messgae in caplog.text          assert len(Config._collector.warnings) == 0          assert len(Config._collector.infos) == 0            config._sections[ScenarioConfig.name][\"new\"].add_sequences({\"sequence_2\": [task_config_1, \"task_config_2\"]})          Config._collector = IssueCollector()          with pytest.raises(SystemExit):              Config.check()          assert len(Config._collector.errors) == 1          expected_error_messgae = (              \"sequences field of ScenarioConfig `new` must be populated with a list of\"              \" TaskConfig objects. Current value of property `sequences` is ['task_config'].\"          )          assert expected_error_messgae in caplog.text          assert len(Config._collector.warnings) == 0          assert len(Config._collector.infos) == 0            config._sections[ScenarioConfig.name][\"new\"].add_sequences({\"sequence_2\": [task_config_2]})          Config._collector = IssueCollector()          with pytest.raises(SystemExit):              Config.check()          assert len(Config._collector.errors) == 1          expected_error_messgae = (              \"The task `baz` in sequences field of ScenarioConfig\"              \" `new` must exist in tasks field of ScenarioConfig `new`.\"          )          assert expected_error_messgae in caplog.text          assert len(Config._collector.warnings) == 0          assert len(Config._collector.infos) == 0            config._sections[ScenarioConfig.name][\"new\"].add_sequences({\"sequence_2\": [task_config_1, task_config_2]})          Config._collector = IssueCollector()          with pytest.raises(SystemExit):              Config.check()          assert len(Config._collector.errors) == 1          expected_error_messgae = (              \"The task `baz` in sequences field of ScenarioConfig\"              \" `new` must exist in tasks field of ScenarioConfig `new`.\"          )          assert expected_error_messgae in caplog.text          assert len(Config._collector.warnings) == 0          assert len(Config._collector.infos) == 0            config._sections[ScenarioConfig.name][\"new\"]._tasks = [task_config_1, task_config_2]          Config._collector = IssueCollector()          Config.check()          assert len(Config._collector.errors) == 0          assert len(Config._collector.warnings) == 0          assert len(Config._collector.infos) == 0        def test_check_frequency(self, caplog):          config = Config._applied_config          Config._compile_configs()            config._sections[ScenarioConfig.name][\"default\"].frequency = \"bar\"          Config._collector = IssueCollector()          Config.check()          assert len(Config._collector.errors) == 0          assert len(Config._collector.warnings) == 0          assert len(Config._collector.infos) == 0            config._sections[ScenarioConfig.name][\"new\"] = copy(config._sections[ScenarioConfig.name][\"default\"])          with pytest.raises(SystemExit):              Config.check()          assert len(Config._collector.errors) == 1          expected_error_message = (              \"frequency field of ScenarioConfig `new` must be populated with a Frequency value.\"              ' Current value of property `frequency` is \"bar\".'          )          assert expected_error_message in caplog.text          assert len(Config._collector.warnings) == 1          assert len(Config._collector.infos) == 0            config._sections[ScenarioConfig.name][\"new\"].frequency = 1          with pytest.raises(SystemExit):              Config._collector = IssueCollector()              Config.check()          assert len(Config._collector.errors) == 1          expected_error_message = (              \"frequency field of ScenarioConfig `new` must be populated with a Frequency value.\"              \" Current value of property `frequency` is 1.\"          )          assert expected_error_message in caplog.text          assert len(Config._collector.warnings) == 1          assert len(Config._collector.infos) == 0            config._sections[ScenarioConfig.name][\"new\"].frequency = Frequency.DAILY          Config._collector = IssueCollector()          Config.check()          assert len(Config._collector.errors) == 0          assert len(Config._collector.warnings) == 1          assert len(Config._collector.infos) == 0        def test_check_comparators(self, caplog):          config = Config._applied_config          Config._compile_configs()            Config._collector = IssueCollector()          Config.check()          assert len(Config._collector.errors) == 0          assert len(Config._collector.warnings) == 0          assert len(Config._collector.infos) == 0            config._sections[ScenarioConfig.name][\"new\"] = copy(config._sections[ScenarioConfig.name][\"default\"])          Config.check()          assert len(Config._collector.errors) == 0          assert len(Config._collector.warnings) == 1          assert len(Config._collector.infos) == 0            config._sections[ScenarioConfig.name][\"new\"].comparators = [\"bar\"]          with pytest.raises(SystemExit):              Config._collector = IssueCollector()              Config.check()          assert len(Config._collector.warnings) == 1          assert len(Config._collector.infos) == 0          assert len(Config._collector.errors) == 1          expected_error_message = (              \"comparators field of ScenarioConfig `new` must be populated with a dictionary value.\"              \" Current value of property `comparators` is ['bar'].\"          )          assert expected_error_message in caplog.text            config._sections[ScenarioConfig.name][\"new\"].comparators = {\"bar\": 1}          with pytest.raises(SystemExit):              Config._collector = IssueCollector()              Config.check()          assert len(Config._collector.warnings) == 1          assert len(Config._collector.infos) == 0          assert len(Config._collector.errors) == 2          expected_data_node_id_error_message = (              \"The key `bar` in comparators field of ScenarioConfig `new` must be populated with a valid data node\"              \" configuration id. Current value of property `comparators` is {'bar': 1}.\"          )          assert expected_data_node_id_error_message in caplog.text          expected_comparator_error_message = (              \"The value of `bar` in comparators field of ScenarioConfig `new` must be populated with a list of\"              \" Callable values. Current value of property `comparators` is {'bar': 1}.\"          )          assert expected_comparator_error_message in caplog.text            Config.configure_data_node(\"foo\", \"in_memory\")          Config.configure_data_node(\"bar\", \"in_memory\")          config._sections[ScenarioConfig.name][\"new\"].comparators = {\"bar\": 1}          with pytest.raises(SystemExit):              Config._collector = IssueCollector()              Config.check()          assert len(Config._collector.warnings) == 1          assert len(Config._collector.infos) == 0          assert len(Config._collector.errors) == 1            config._sections[ScenarioConfig.name][\"new\"].comparators = {\"foo\": subtraction, \"bar\": [subtraction]}          Config._collector = IssueCollector()          Config.check()          assert len(Config._collector.warnings) == 1          assert len(Config._collector.infos) == 0          assert len(Config._collector.errors) == 0 "}
{"text": "from queue import SimpleQueue    from src.taipy.core import taipy as tp  from src.taipy.core.notification import EventEntityType, EventOperation  from src.taipy.core.notification._topic import _Topic  from src.taipy.core.notification.event import Event  from src.taipy.core.notification.notifier import Notifier  from taipy.config import Config, Frequency      def test_register():      def find_registration_and_topic(registration_id):          for topic, registrations in Notifier._topics_registrations_list.items():              for registration in registrations:                  if registration.registration_id == registration_id:                      return topic, registration        assert len(Notifier._topics_registrations_list) == 0        registration_id_0, register_queue_0 = Notifier.register()      topic_0, registration_0 = find_registration_and_topic(registration_id_0)        assert isinstance(registration_id_0, str) and registration_id_0 == registration_0.registration_id      assert isinstance(register_queue_0, SimpleQueue)      assert len(Notifier._topics_registrations_list.keys()) == 1      assert len(Notifier._topics_registrations_list[topic_0]) == 1      assert registration_0.queue == register_queue_0      assert register_queue_0 in [registration.queue for registration in Notifier._topics_registrations_list[topic_0]]        registration_id_1, register_queue_1 = Notifier.register()      topic_1, registration_1 = find_registration_and_topic(registration_id_1)        assert isinstance(registration_id_1, str) and registration_id_1 == registration_1.registration_id      assert isinstance(register_queue_1, SimpleQueue)      assert len(Notifier._topics_registrations_list.keys()) == 1      assert len(Notifier._topics_registrations_list[topic_1]) == 2      assert registration_1.queue == register_queue_1      assert register_queue_1 in [registration.queue for registration in Notifier._topics_registrations_list[topic_1]]        registration_id_2, register_queue_2 = Notifier.register(EventEntityType.SCENARIO)      topic_2, registration_2 = find_registration_and_topic(registration_id_2)        assert isinstance(registration_id_2, str) and registration_id_2 == registration_2.registration_id      assert isinstance(register_queue_2, SimpleQueue)      assert len(Notifier._topics_registrations_list.keys()) == 2      assert len(Notifier._topics_registrations_list[topic_2]) == 1      assert registration_2.queue == register_queue_2      assert register_queue_2 in [registration.queue for registration in Notifier._topics_registrations_list[topic_2]]        registration_id_3, register_queue_3 = Notifier.register(EventEntityType.SCENARIO, \"scenario_id\")      topic_3, registration_3 = find_registration_and_topic(registration_id_3)        assert isinstance(registration_id_3, str) and registration_id_3 == registration_3.registration_id      assert isinstance(register_queue_3, SimpleQueue)      assert len(Notifier._topics_registrations_list.keys()) == 3      assert len(Notifier._topics_registrations_list[topic_3]) == 1      assert registration_3.queue == register_queue_3      assert register_queue_3 in [registration.queue for registration in Notifier._topics_registrations_list[topic_3]]        registration_id_4, register_queue_4 = Notifier.register(          EventEntityType.SEQUENCE, \"sequence_id\", EventOperation.UPDATE, \"tasks\"      )      topic_4, registration_4 = find_registration_and_topic(registration_id_4)        assert isinstance(registration_id_4, str) and registration_id_4 == registration_4.registration_id      assert isinstance(register_queue_4, SimpleQueue)      assert len(Notifier._topics_registrations_list.keys()) == 4      assert len(Notifier._topics_registrations_list[topic_4]) == 1      assert registration_4.queue == register_queue_4      assert register_queue_4 in [registration.queue for registration in Notifier._topics_registrations_list[topic_4]]        registration_id_5, register_queue_5 = Notifier.register(EventEntityType.SCENARIO)      topic_5, registration_5 = find_registration_and_topic(registration_id_5)        assert isinstance(registration_id_5, str) and registration_id_5 == registration_5.registration_id      assert isinstance(register_queue_5, SimpleQueue)      assert len(Notifier._topics_registrations_list.keys()) == 4      assert len(Notifier._topics_registrations_list[topic_5]) == 2      assert registration_5.queue == register_queue_5      assert register_queue_5 in [registration.queue for registration in Notifier._topics_registrations_list[topic_5]]        registration_id_6, register_queue_6 = Notifier.register()      assert len(Notifier._topics_registrations_list.keys()) == 4      assert len(Notifier._topics_registrations_list[topic_0]) == 3        Notifier.unregister(registration_id_6)      assert len(Notifier._topics_registrations_list.keys()) == 4      assert len(Notifier._topics_registrations_list[topic_0]) == 2        Notifier.unregister(registration_id_4)      assert len(Notifier._topics_registrations_list.keys()) == 3      assert topic_4 not in Notifier._topics_registrations_list.keys()        Notifier.unregister(registration_id_0)      assert len(Notifier._topics_registrations_list.keys()) == 3      assert len(Notifier._topics_registrations_list[topic_0]) == 1        Notifier.unregister(registration_id_1)      assert len(Notifier._topics_registrations_list.keys()) == 2      assert all(topic not in Notifier._topics_registrations_list.keys() for topic in [topic_0, topic_1])        Notifier.unregister(registration_id_2)      Notifier.unregister(registration_id_3)      Notifier.unregister(registration_id_5)      assert len(Notifier._topics_registrations_list.keys()) == 0      def test_matching():      assert Notifier._is_matching(          Event(entity_type=EventEntityType.CYCLE, entity_id=\"cycle_id\", operation=EventOperation.CREATION), _Topic()      )      assert Notifier._is_matching(          Event(entity_type=EventEntityType.CYCLE, entity_id=\"cycle_id\", operation=EventOperation.CREATION),          _Topic(EventEntityType.CYCLE),      )      assert Notifier._is_matching(          Event(entity_type=EventEntityType.CYCLE, entity_id=\"cycle_id\", operation=EventOperation.CREATION),          _Topic(EventEntityType.CYCLE, \"cycle_id\"),      )      assert Notifier._is_matching(          Event(entity_type=EventEntityType.CYCLE, entity_id=\"cycle_id\", operation=EventOperation.CREATION),          _Topic(operation=EventOperation.CREATION),      )      assert Notifier._is_matching(          Event(entity_type=EventEntityType.CYCLE, entity_id=\"cycle_id\", operation=EventOperation.CREATION),          _Topic(EventEntityType.CYCLE, \"cycle_id\", EventOperation.CREATION),      )        assert Notifier._is_matching(          Event(entity_type=EventEntityType.SCENARIO, entity_id=\"scenario_id\", operation=EventOperation.SUBMISSION),          _Topic(),      )      assert Notifier._is_matching(          Event(entity_type=EventEntityType.SCENARIO, entity_id=\"scenario_id\", operation=EventOperation.SUBMISSION),          _Topic(EventEntityType.SCENARIO),      )      assert Notifier._is_matching(          Event(entity_type=EventEntityType.SCENARIO, entity_id=\"scenario_id\", operation=EventOperation.SUBMISSION),          _Topic(              EventEntityType.SCENARIO,              \"scenario_id\",          ),      )      assert Notifier._is_matching(          Event(entity_type=EventEntityType.SCENARIO, entity_id=\"scenario_id\", operation=EventOperation.SUBMISSION),          _Topic(operation=EventOperation.SUBMISSION),      )      assert Notifier._is_matching(          Event(entity_type=EventEntityType.SCENARIO, entity_id=\"scenario_id\", operation=EventOperation.SUBMISSION),          _Topic(EventEntityType.SCENARIO, \"scenario_id\", EventOperation.SUBMISSION),      )        assert Notifier._is_matching(          Event(              entity_type=EventEntityType.SEQUENCE,              entity_id=\"sequence_id\",              operation=EventOperation.UPDATE,              attribute_name=r\"tasks\",          ),          _Topic(),      )      assert Notifier._is_matching(          Event(              entity_type=EventEntityType.SEQUENCE,              entity_id=\"sequence_id\",              operation=EventOperation.UPDATE,              attribute_name=\"tasks\",          ),          _Topic(EventEntityType.SEQUENCE),      )      assert Notifier._is_matching(          Event(              entity_type=EventEntityType.SEQUENCE,              entity_id=\"sequence_id\",              operation=EventOperation.UPDATE,              attribute_name=\"tasks\",          ),          _Topic(              EventEntityType.SEQUENCE,              \"sequence_id\",          ),      )      assert Notifier._is_matching(          Event(              entity_type=EventEntityType.SEQUENCE,              entity_id=\"sequence_id\",              operation=EventOperation.UPDATE,              attribute_name=\"tasks\",          ),          _Topic(operation=EventOperation.UPDATE),      )      assert Notifier._is_matching(          Event(              entity_type=EventEntityType.SEQUENCE,              entity_id=\"sequence_id\",              operation=EventOperation.UPDATE,              attribute_name=\"tasks\",          ),          _Topic(EventEntityType.SEQUENCE, \"sequence_id\", EventOperation.UPDATE),      )      assert Notifier._is_matching(          Event(              entity_type=EventEntityType.SEQUENCE,              entity_id=\"sequence_id\",              operation=EventOperation.UPDATE,              attribute_name=\"tasks\",          ),          _Topic(attribute_name=\"tasks\"),      )      assert Notifier._is_matching(          Event(              entity_type=EventEntityType.SEQUENCE,              entity_id=\"sequence_id\",              operation=EventOperation.UPDATE,              attribute_name=\"tasks\",          ),          _Topic(EventEntityType.SEQUENCE, attribute_name=\"tasks\"),      )      assert Notifier._is_matching(          Event(              entity_type=EventEntityType.SEQUENCE,              entity_id=\"sequence_id\",              operation=EventOperation.UPDATE,              attribute_name=\"tasks\",          ),          _Topic(operation=EventOperation.UPDATE, attribute_name=\"tasks\"),      )      assert Notifier._is_matching(          Event(              entity_type=EventEntityType.SEQUENCE,              entity_id=\"sequence_id\",              operation=EventOperation.UPDATE,              attribute_name=\"tasks\",          ),          _Topic(EventEntityType.SEQUENCE, \"sequence_id\", EventOperation.UPDATE, \"tasks\"),      )      assert Notifier._is_matching(Event(EventEntityType.TASK, \"task_id\", EventOperation.DELETION), _Topic())      assert Notifier._is_matching(          Event(EventEntityType.TASK, \"task_id\", EventOperation.DELETION), _Topic(EventEntityType.TASK)      )      assert Notifier._is_matching(          Event(entity_type=EventEntityType.TASK, entity_id=\"task_id\", operation=EventOperation.DELETION),          _Topic(              EventEntityType.TASK,              \"task_id\",          ),      )      assert Notifier._is_matching(          Event(entity_type=EventEntityType.TASK, entity_id=\"task_id\", operation=EventOperation.DELETION),          _Topic(operation=EventOperation.DELETION),      )      assert Notifier._is_matching(          Event(entity_type=EventEntityType.TASK, entity_id=\"task_id\", operation=EventOperation.DELETION),          _Topic(EventEntityType.TASK, \"task_id\", EventOperation.DELETION),      )        assert not Notifier._is_matching(          Event(entity_type=EventEntityType.DATA_NODE, entity_id=\"dn_id\", operation=EventOperation.CREATION),          _Topic(EventEntityType.CYCLE),      )      assert not Notifier._is_matching(          Event(entity_type=EventEntityType.DATA_NODE, entity_id=\"dn_id\", operation=EventOperation.CREATION),          _Topic(EventEntityType.SCENARIO, \"scenario_id\"),      )      assert not Notifier._is_matching(          Event(entity_type=EventEntityType.DATA_NODE, entity_id=\"dn_id\", operation=EventOperation.CREATION),          _Topic(EventEntityType.TASK, \"task_id\", EventOperation.CREATION),      )      assert not Notifier._is_matching(          Event(entity_type=EventEntityType.JOB, entity_id=\"job_id\", operation=EventOperation.DELETION),          _Topic(EventEntityType.JOB, \"job_id\", EventOperation.CREATION),      )      assert not Notifier._is_matching(          Event(entity_type=EventEntityType.JOB, entity_id=\"job_id\", operation=EventOperation.DELETION),          _Topic(EventEntityType.JOB, \"job_id_1\", EventOperation.DELETION),      )      assert not Notifier._is_matching(          Event(              entity_type=EventEntityType.JOB,              entity_id=\"job_id\",              operation=EventOperation.UPDATE,              attribute_name=\"status\",          ),          _Topic(EventEntityType.JOB, \"job_id\", EventOperation.UPDATE, \"submit_id\"),      )      assert not Notifier._is_matching(          Event(              entity_type=EventEntityType.JOB,              entity_id=\"job_id\",              operation=EventOperation.UPDATE,              attribute_name=\"status\",          ),          _Topic(operation=EventOperation.UPDATE, attribute_name=\"submit_id\"),      )      def test_publish_creation_event():      _, registration_queue = Notifier.register()        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, flag=\"test\"      )      scenario_config.add_sequences({\"sequence_config\": [task_config]})        # Test CREATION Event        scenario = tp.create_scenario(scenario_config)      cycle = scenario.cycle      task = scenario.tasks[task_config.id]      dn = scenario.data_nodes[dn_config.id]      sequence = scenario.sequences[\"sequence_config\"]        assert registration_queue.qsize() == 5        published_events = []      while registration_queue.qsize() != 0:          published_events.append(registration_queue.get())        expected_event_types = [          EventEntityType.CYCLE,          EventEntityType.DATA_NODE,          EventEntityType.TASK,          EventEntityType.SEQUENCE,          EventEntityType.SCENARIO,      ]      expected_event_entity_id = [cycle.id, dn.id, task.id, sequence.id, scenario.id]        assert all(          [              event.entity_type == expected_event_types[i]              and event.entity_id == expected_event_entity_id[i]              and event.operation == EventOperation.CREATION              and event.attribute_name is None              for i, event in enumerate(published_events)          ]      )      def test_publish_update_event():      _, registration_queue = Notifier.register()        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, flag=\"test\"      )      scenario_config.add_sequences({\"sequence_config\": [task_config]})        scenario = tp.create_scenario(scenario_config)      cycle = scenario.cycle      task = scenario.tasks[task_config.id]      dn = scenario.data_nodes[dn_config.id]      sequence = scenario.sequences[\"sequence_config\"]        assert registration_queue.qsize() == 5      while registration_queue.qsize() > 0:          registration_queue.get()        # Test UPDATE Event        scenario.is_primary = False      assert registration_queue.qsize() == 1        tp.set_primary(scenario)      assert registration_queue.qsize() == 2        tp.subscribe_scenario(print, None, scenario=scenario)      assert registration_queue.qsize() == 3        tp.unsubscribe_scenario(print, None, scenario=scenario)      assert registration_queue.qsize() == 4        tp.tag(scenario, \"testing\")      assert registration_queue.qsize() == 5        tp.untag(scenario, \"testing\")      assert registration_queue.qsize() == 6        scenario.properties[\"flag\"] = \"production\"      assert registration_queue.qsize() == 7        scenario.properties.update({\"description\": \"a scenario\", \"test_mult\": True})      assert registration_queue.qsize() == 9        scenario.properties.pop(\"test_mult\")      assert registration_queue.qsize() == 10        scenario.name = \"my_scenario\"      assert registration_queue.qsize() == 11        cycle.name = \"new cycle name\"      assert registration_queue.qsize() == 12        cycle.properties[\"valid\"] = True      assert registration_queue.qsize() == 13        cycle.properties.update({\"re_run_periodically\": True})      assert registration_queue.qsize() == 14        cycle.properties.pop(\"re_run_periodically\")      assert registration_queue.qsize() == 15        sequence.properties[\"name\"] = \"weather_forecast\"      assert registration_queue.qsize() == 16        tp.subscribe_sequence(print, None, sequence)      assert registration_queue.qsize() == 17        tp.unsubscribe_sequence(print, None, sequence)      assert registration_queue.qsize() == 18        task.skippable = True      assert registration_queue.qsize() == 19        task.properties[\"number_of_run\"] = 2      assert registration_queue.qsize() == 20        task.properties.update({\"debug\": True})      assert registration_queue.qsize() == 21        task.properties.pop(\"debug\")      assert registration_queue.qsize() == 22        dn.editor_id = \"new editor id\"      assert registration_queue.qsize() == 23        dn.properties[\"sorted\"] = True      assert registration_queue.qsize() == 24        dn.properties.update({\"only_fetch_first_100\": True})      assert registration_queue.qsize() == 25        dn.properties.pop(\"only_fetch_first_100\")      assert registration_queue.qsize() == 26        published_events = []      while registration_queue.qsize() != 0:          published_events.append(registration_queue.get())        expected_event_types = [          EventEntityType.SCENARIO,          EventEntityType.SCENARIO,          EventEntityType.SCENARIO,          EventEntityType.SCENARIO,          EventEntityType.SCENARIO,          EventEntityType.SCENARIO,          EventEntityType.SCENARIO,          EventEntityType.SCENARIO,          EventEntityType.SCENARIO,          EventEntityType.SCENARIO,          EventEntityType.SCENARIO,          EventEntityType.CYCLE,          EventEntityType.CYCLE,          EventEntityType.CYCLE,          EventEntityType.CYCLE,          EventEntityType.SEQUENCE,          EventEntityType.SEQUENCE,          EventEntityType.SEQUENCE,          EventEntityType.TASK,          EventEntityType.TASK,          EventEntityType.TASK,          EventEntityType.TASK,          EventEntityType.DATA_NODE,          EventEntityType.DATA_NODE,          EventEntityType.DATA_NODE,          EventEntityType.DATA_NODE,      ]      expected_attribute_names = [          \"is_primary\",          \"is_primary\",          \"subscribers\",          \"subscribers\",          \"tags\",          \"tags\",          \"properties\",          \"properties\",          \"properties\",          \"properties\",          \"properties\",          \"name\",          \"properties\",          \"properties\",          \"properties\",          \"properties\",          \"subscribers\",          \"subscribers\",          \"skippable\",          \"properties\",          \"properties\",          \"properties\",          \"editor_id\",          \"properties\",          \"properties\",          \"properties\",      ]      expected_event_entity_id = [          scenario.id,          scenario.id,          scenario.id,          scenario.id,          scenario.id,          scenario.id,          scenario.id,          scenario.id,          scenario.id,          scenario.id,          scenario.id,          cycle.id,          cycle.id,          cycle.id,          cycle.id,          sequence.id,          sequence.id,          sequence.id,          task.id,          task.id,          task.id,          task.id,          dn.id,          dn.id,          dn.id,          dn.id,      ]        expected_event_operation_type = [EventOperation.UPDATE] * len(expected_event_types)        assert all(          [              event.entity_type == expected_event_types[i]              and event.entity_id == expected_event_entity_id[i]              and event.operation == expected_event_operation_type[i]              and event.attribute_name == expected_attribute_names[i]              for i, event in enumerate(published_events)          ]      )      def test_publish_update_event_in_context_manager():      _, registration_queue = Notifier.register()        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, flag=\"test\"      )      scenario_config.add_sequences({\"sequence_config\": [task_config]})        scenario = tp.create_scenario(scenario_config)      cycle = scenario.cycle      task = scenario.tasks[task_config.id]      dn = scenario.data_nodes[dn_config.id]      sequence = scenario.sequences[\"sequence_config\"]      scenario.properties.update({\"description\": \"a scenario\"})        assert registration_queue.qsize() == 6      while registration_queue.qsize() > 0:          registration_queue.get()        # Test UPDATE Event in Context Manager        assert registration_queue.qsize() == 0        # If multiple entities is in context, the last to enter will be the first to exit      # So the published event will have the order starting with scenario first and ending with dn      with dn as d, task as t, sequence as s, cycle as c, scenario as sc:          sc.is_primary = True          assert registration_queue.qsize() == 0            tp.set_primary(sc)          assert registration_queue.qsize() == 0            sc.properties[\"flag\"] = \"production\"          assert registration_queue.qsize() == 0            sc.properties.update({\"description\": \"a scenario\"})          assert registration_queue.qsize() == 0            sc.properties.pop(\"description\")          assert registration_queue.qsize() == 0            sc.name = \"my_scenario\"          assert registration_queue.qsize() == 0            c.name = \"another new cycle name\"          assert registration_queue.qsize() == 0            c.properties[\"valid\"] = True          assert registration_queue.qsize() == 0            c.properties.update({\"re_run_periodically\": True})          assert registration_queue.qsize() == 0            s.properties[\"name\"] = \"weather_forecast\"          assert registration_queue.qsize() == 0            t.skippable = True          assert registration_queue.qsize() == 0            t.properties[\"number_of_run\"] = 2          assert registration_queue.qsize() == 0            t.properties.update({\"debug\": True})          assert registration_queue.qsize() == 0            d.editor_id = \"another new editor id\"          assert registration_queue.qsize() == 0            d.properties[\"sorted\"] = True          assert registration_queue.qsize() == 0            d.properties.update({\"only_fetch_first_100\": True})          assert registration_queue.qsize() == 0        published_events = []        assert registration_queue.qsize() == 16      while registration_queue.qsize() != 0:          published_events.append(registration_queue.get())        expected_event_types = [          EventEntityType.SCENARIO,          EventEntityType.SCENARIO,          EventEntityType.SCENARIO,          EventEntityType.SCENARIO,          EventEntityType.SCENARIO,          EventEntityType.SCENARIO,          EventEntityType.CYCLE,          EventEntityType.CYCLE,          EventEntityType.CYCLE,          EventEntityType.SEQUENCE,          EventEntityType.TASK,          EventEntityType.TASK,          EventEntityType.TASK,          EventEntityType.DATA_NODE,          EventEntityType.DATA_NODE,          EventEntityType.DATA_NODE,      ]      expected_attribute_names = [          \"is_primary\",          \"is_primary\",          \"properties\",          \"properties\",          \"properties\",          \"properties\",          \"name\",          \"properties\",          \"properties\",          \"properties\",          \"skippable\",          \"properties\",          \"properties\",          \"editor_id\",          \"properties\",          \"properties\",      ]      expected_event_entity_id = [          scenario.id,          scenario.id,          scenario.id,          scenario.id,          scenario.id,          scenario.id,          cycle.id,          cycle.id,          cycle.id,          sequence.id,          task.id,          task.id,          task.id,          dn.id,          dn.id,          dn.id,      ]        assert all(          [              event.entity_type == expected_event_types[i]              and event.entity_id == expected_event_entity_id[i]              and event.operation == EventOperation.UPDATE              and event.attribute_name == expected_attribute_names[i]              for i, event in enumerate(published_events)          ]      )      def test_publish_submission_event():      _, registration_queue = Notifier.register()        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, flag=\"test\"      )      scenario_config.add_sequences({\"sequence_config\": [task_config]})      scenario = tp.create_scenario(scenario_config)        assert registration_queue.qsize() == 5      while registration_queue.qsize() > 0:          registration_queue.get()        # Test SUBMISSION Event        job = scenario.submit()[0]        assert registration_queue.qsize() == 6      published_events = []      while registration_queue.qsize() != 0:          published_events.append(registration_queue.get())        expected_operations = [          EventOperation.CREATION,          EventOperation.CREATION,          EventOperation.UPDATE,          EventOperation.UPDATE,          EventOperation.UPDATE,          EventOperation.SUBMISSION,      ]      expected_attribute_names = [None, None, \"jobs\", \"status\", \"submission_status\", None]      expected_event_types = [          EventEntityType.SUBMISSION,          EventEntityType.JOB,          EventEntityType.SUBMISSION,          EventEntityType.JOB,          EventEntityType.SUBMISSION,          EventEntityType.SCENARIO,      ]      expected_event_entity_id = [job.submit_id, job.id, job.submit_id, job.id, job.submit_id, scenario.id]      assert all(          [              event.entity_type == expected_event_types[i]              and event.entity_id == expected_event_entity_id[i]              and event.operation == expected_operations[i]              and event.attribute_name == expected_attribute_names[i]              for i, event in enumerate(published_events)          ]      )      def test_publish_deletion_event():      _, registration_queue = Notifier.register()        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, flag=\"test\"      )      scenario_config.add_sequences({\"sequence_config\": [task_config]})      scenario = tp.create_scenario(scenario_config)      cycle = scenario.cycle      task = scenario.tasks[task_config.id]      dn = scenario.data_nodes[dn_config.id]      sequence = scenario.sequences[\"sequence_config\"]      job = scenario.submit()[0]        assert registration_queue.qsize() == 11      while registration_queue.qsize() > 0:          registration_queue.get()        # Test DELETION Event        tp.delete(scenario.id)      assert registration_queue.qsize() == 7        published_events = []      while registration_queue.qsize() != 0:          published_events.append(registration_queue.get())        expected_event_types = [          EventEntityType.CYCLE,          EventEntityType.SEQUENCE,          EventEntityType.SCENARIO,          EventEntityType.TASK,          EventEntityType.JOB,          EventEntityType.DATA_NODE,          EventEntityType.SUBMISSION,      ]        expected_event_entity_id = [cycle.id, sequence.id, scenario.id, task.id, job.id, dn.id, job.submit_id]      expected_event_operation_type = [EventOperation.DELETION] * len(expected_event_types)        assert all(          [              event.entity_type == expected_event_types[i]              and event.entity_id == expected_event_entity_id[i]              and event.operation == expected_event_operation_type[i]              and event.attribute_name is None              for i, event in enumerate(published_events)          ]      )        scenario = tp.create_scenario(scenario_config)      cycle = scenario.cycle      assert registration_queue.qsize() == 5        # only to clear the queue      while registration_queue.qsize() != 0:          registration_queue.get()        tp.clean_all_entities_by_version()      assert registration_queue.qsize() == 5        published_events = []      while registration_queue.qsize() != 0:          published_events.append(registration_queue.get())        expected_event_types = [          EventEntityType.JOB,          EventEntityType.CYCLE,          EventEntityType.SCENARIO,          EventEntityType.TASK,          EventEntityType.DATA_NODE,      ]      expected_event_entity_id = [None, cycle.id, scenario.id, None, None]        assert all(          [              event.entity_type == expected_event_types[i]              and event.entity_id == expected_event_entity_id[i]              and event.operation == EventOperation.DELETION              and event.attribute_name is None              for i, event in enumerate(published_events)          ]      ) "}
{"text": "import pytest    from src.taipy.core.exceptions.exceptions import InvalidEventOperation  from src.taipy.core.notification._topic import _Topic  from src.taipy.core.notification.event import EventEntityType, EventOperation      def test_general_topic_creation():      topic_1 = _Topic(None, None, None, None)      assert topic_1.entity_type is None      assert topic_1.entity_id is None      assert topic_1.operation is None      assert topic_1.attribute_name is None        topic_2 = _Topic(EventEntityType.SCENARIO, \"scenario_id\")      assert topic_2.entity_type == EventEntityType.SCENARIO      assert topic_2.entity_id == \"scenario_id\"      assert topic_2.operation is None      assert topic_2.attribute_name is None        topic_3 = _Topic(None, None, EventOperation.CREATION)      assert topic_3.entity_type is None      assert topic_3.entity_id is None      assert topic_3.operation == EventOperation.CREATION      assert topic_3.attribute_name is None        topic_4 = _Topic(None, None, EventOperation.UPDATE, \"properties\")      assert topic_4.entity_type is None      assert topic_4.entity_id is None      assert topic_4.operation == EventOperation.UPDATE      assert topic_4.attribute_name == \"properties\"        topic_5 = _Topic(entity_type=EventEntityType.JOB, operation=EventOperation.DELETION)      assert topic_5.entity_type == EventEntityType.JOB      assert topic_5.entity_id is None      assert topic_5.operation == EventOperation.DELETION      assert topic_5.attribute_name is None        topic_6 = _Topic(entity_type=EventEntityType.SEQUENCE)      assert topic_6.entity_type == EventEntityType.SEQUENCE      assert topic_6.entity_id is None      assert topic_6.operation is None      assert topic_6.attribute_name is None      def test_topic_creation_cycle():      topic_1 = _Topic(EventEntityType.CYCLE, \"cycle_id\", EventOperation.CREATION)      assert topic_1.entity_type == EventEntityType.CYCLE      assert topic_1.entity_id == \"cycle_id\"      assert topic_1.operation == EventOperation.CREATION      assert topic_1.attribute_name is None        topic_2 = _Topic(EventEntityType.CYCLE, \"cycle_id\", EventOperation.UPDATE, \"frequency\")      assert topic_2.entity_type == EventEntityType.CYCLE      assert topic_2.entity_id == \"cycle_id\"      assert topic_2.operation == EventOperation.UPDATE      assert topic_2.attribute_name == \"frequency\"        topic_3 = _Topic(EventEntityType.CYCLE, \"cycle_id\", EventOperation.DELETION)      assert topic_3.entity_type == EventEntityType.CYCLE      assert topic_3.entity_id == \"cycle_id\"      assert topic_3.operation == EventOperation.DELETION      assert topic_3.attribute_name is None        topic_4 = _Topic(EventEntityType.CYCLE, \"cycle_id\", EventOperation.CREATION)      assert topic_4.entity_type == EventEntityType.CYCLE      assert topic_4.entity_id == \"cycle_id\"      assert topic_4.operation == EventOperation.CREATION      assert topic_4.attribute_name is None        # with pytest.raises(InvalidEventAttributeName):      #     _ = Topic(EventEntityType.CYCLE, \"cycle_id\", EventOperation.CREATION, \"frequency\")        # with pytest.raises(InvalidEventAttributeName):      #     _ = Topic(EventEntityType.CYCLE, \"cycle_id\", EventOperation.DELETION, \"frequency\")        # with pytest.raises(InvalidEventAttributeName):      #     _ = Topic(EventEntityType.CYCLE, \"cycle_id\", attribute_name=\"frequency\")        with pytest.raises(InvalidEventOperation):          _ = _Topic(EventEntityType.CYCLE, \"cycle_id\", EventOperation.SUBMISSION)        with pytest.raises(InvalidEventOperation):          _ = _Topic(EventEntityType.CYCLE, \"cycle_id\", EventOperation.SUBMISSION, \"frequency\")      def test_topic_creation_scenario():      topic_1 = _Topic(EventEntityType.SCENARIO, \"scenario_id\", EventOperation.CREATION)      assert topic_1.entity_type == EventEntityType.SCENARIO      assert topic_1.entity_id == \"scenario_id\"      assert topic_1.operation == EventOperation.CREATION      assert topic_1.attribute_name is None        topic_2 = _Topic(EventEntityType.SCENARIO, \"scenario_id\", EventOperation.UPDATE, \"is_primary\")      assert topic_2.entity_type == EventEntityType.SCENARIO      assert topic_2.entity_id == \"scenario_id\"      assert topic_2.operation == EventOperation.UPDATE      assert topic_2.attribute_name == \"is_primary\"        topic_3 = _Topic(EventEntityType.SCENARIO, \"scenario_id\", EventOperation.DELETION)      assert topic_3.entity_type == EventEntityType.SCENARIO      assert topic_3.entity_id == \"scenario_id\"      assert topic_3.operation == EventOperation.DELETION      assert topic_3.attribute_name is None        topic_4 = _Topic(EventEntityType.SCENARIO, \"scenario_id\", EventOperation.SUBMISSION)      assert topic_4.entity_type == EventEntityType.SCENARIO      assert topic_4.entity_id == \"scenario_id\"      assert topic_4.operation == EventOperation.SUBMISSION      assert topic_4.attribute_name is None        topic_5 = _Topic(EventEntityType.SCENARIO, \"scenario_id\", EventOperation.UPDATE, \"properties\")      assert topic_5.entity_type == EventEntityType.SCENARIO      assert topic_5.entity_id == \"scenario_id\"      assert topic_5.operation == EventOperation.UPDATE      assert topic_5.attribute_name == \"properties\"        # with pytest.raises(InvalidEventAttributeName):      #     _ = Topic(EventEntityType.SCENARIO, \"scenario_id\", EventOperation.CREATION, \"is_primary\")        # with pytest.raises(InvalidEventAttributeName):      #     _ = Topic(EventEntityType.SCENARIO, \"scenario_id\", EventOperation.DELETION, \"is_primary\")        # with pytest.raises(InvalidEventAttributeName):      #     _ = Topic(EventEntityType.SCENARIO, \"scenario_id\", EventOperation.SUBMISSION, \"is_primary\")        # with pytest.raises(InvalidEventAttributeName):      #     _ = Topic(EventEntityType.SCENARIO, \"scenario_id\", attribute_name=\"is_primary\")      def test_topic_creation_sequence():      topic_1 = _Topic(EventEntityType.SEQUENCE, \"sequence_id\", EventOperation.CREATION)      assert topic_1.entity_type == EventEntityType.SEQUENCE      assert topic_1.entity_id == \"sequence_id\"      assert topic_1.operation == EventOperation.CREATION      assert topic_1.attribute_name is None        topic_2 = _Topic(EventEntityType.SEQUENCE, \"sequence_id\", EventOperation.UPDATE, \"subscribers\")      assert topic_2.entity_type == EventEntityType.SEQUENCE      assert topic_2.entity_id == \"sequence_id\"      assert topic_2.operation == EventOperation.UPDATE      assert topic_2.attribute_name == \"subscribers\"        topic_3 = _Topic(EventEntityType.SEQUENCE, \"sequence_id\", EventOperation.DELETION)      assert topic_3.entity_type == EventEntityType.SEQUENCE      assert topic_3.entity_id == \"sequence_id\"      assert topic_3.operation == EventOperation.DELETION      assert topic_3.attribute_name is None        topic_4 = _Topic(EventEntityType.SEQUENCE, \"sequence_id\", EventOperation.SUBMISSION)      assert topic_4.entity_type == EventEntityType.SEQUENCE      assert topic_4.entity_id == \"sequence_id\"      assert topic_4.operation == EventOperation.SUBMISSION      assert topic_4.attribute_name is None        topic_5 = _Topic(EventEntityType.SEQUENCE, \"sequence_id\", EventOperation.DELETION)      assert topic_5.entity_type == EventEntityType.SEQUENCE      assert topic_5.entity_id == \"sequence_id\"      assert topic_5.operation == EventOperation.DELETION      assert topic_5.attribute_name is None        # with pytest.raises(InvalidEventAttributeName):      #     _ = Topic(EventEntityType.SEQUENCE, \"sequence_id\", EventOperation.CREATION, \"subscribers\")        # with pytest.raises(InvalidEventAttributeName):      #     _ = Topic(EventEntityType.SEQUENCE, \"sequence_id\", EventOperation.DELETION, \"subscribers\")        # with pytest.raises(InvalidEventAttributeName):      #     _ = Topic(EventEntityType.SEQUENCE, \"sequence_id\", EventOperation.SUBMISSION, \"subscribers\")        # with pytest.raises(InvalidEventAttributeName):      #     _ = Topic(EventEntityType.SEQUENCE, \"sequence_id\", attribute_name=\"subscribers\")      def test_topic_creation_task():      topic_1 = _Topic(EventEntityType.TASK, \"task_id\", EventOperation.CREATION)      assert topic_1.entity_type == EventEntityType.TASK      assert topic_1.entity_id == \"task_id\"      assert topic_1.operation == EventOperation.CREATION      assert topic_1.attribute_name is None        topic_2 = _Topic(EventEntityType.TASK, \"task_id\", EventOperation.UPDATE, \"function\")      assert topic_2.entity_type == EventEntityType.TASK      assert topic_2.entity_id == \"task_id\"      assert topic_2.operation == EventOperation.UPDATE      assert topic_2.attribute_name == \"function\"        topic_3 = _Topic(EventEntityType.TASK, \"task_id\", EventOperation.DELETION)      assert topic_3.entity_type == EventEntityType.TASK      assert topic_3.entity_id == \"task_id\"      assert topic_3.operation == EventOperation.DELETION      assert topic_3.attribute_name is None        topic_4 = _Topic(EventEntityType.TASK, \"task_id\", EventOperation.SUBMISSION)      assert topic_4.entity_type == EventEntityType.TASK      assert topic_4.entity_id == \"task_id\"      assert topic_4.operation == EventOperation.SUBMISSION      assert topic_4.attribute_name is None        topic_5 = _Topic(EventEntityType.TASK, \"task_id\", EventOperation.SUBMISSION)      assert topic_5.entity_type == EventEntityType.TASK      assert topic_5.entity_id == \"task_id\"      assert topic_5.operation == EventOperation.SUBMISSION      assert topic_5.attribute_name is None        # with pytest.raises(InvalidEventAttributeName):      #     _ = Topic(EventEntityType.TASK, \"task_id\", EventOperation.CREATION, \"function\")        # with pytest.raises(InvalidEventAttributeName):      #     _ = Topic(EventEntityType.TASK, \"task_id\", EventOperation.DELETION, \"function\")        # with pytest.raises(InvalidEventAttributeName):      #     _ = Topic(EventEntityType.TASK, \"task_id\", EventOperation.SUBMISSION, \"function\")        # with pytest.raises(InvalidEventAttributeName):      #     _ = Topic(EventEntityType.TASK, \"task_id\", attribute_name=\"function\")      def test_topic_creation_datanode():      topic_1 = _Topic(EventEntityType.DATA_NODE, \"dn_id\", EventOperation.CREATION)      assert topic_1.entity_type == EventEntityType.DATA_NODE      assert topic_1.entity_id == \"dn_id\"      assert topic_1.operation == EventOperation.CREATION      assert topic_1.attribute_name is None        topic_2 = _Topic(EventEntityType.DATA_NODE, \"dn_id\", EventOperation.UPDATE, \"properties\")      assert topic_2.entity_type == EventEntityType.DATA_NODE      assert topic_2.entity_id == \"dn_id\"      assert topic_2.operation == EventOperation.UPDATE      assert topic_2.attribute_name == \"properties\"        topic_3 = _Topic(EventEntityType.DATA_NODE, \"dn_id\", EventOperation.DELETION)      assert topic_3.entity_type == EventEntityType.DATA_NODE      assert topic_3.entity_id == \"dn_id\"      assert topic_3.operation == EventOperation.DELETION      assert topic_3.attribute_name is None        topic_4 = _Topic(None, \"dn_id\", EventOperation.UPDATE, \"scope\")      assert topic_4.entity_type is None      assert topic_4.entity_id == \"dn_id\"      assert topic_4.operation == EventOperation.UPDATE      assert topic_4.attribute_name == \"scope\"        # with pytest.raises(InvalidEventAttributeName):      #     _ = Topic(EventEntityType.DATA_NODE, \"dn_id\", EventOperation.CREATION, \"properties\")        # with pytest.raises(InvalidEventAttributeName):      #     _ = Topic(EventEntityType.DATA_NODE, \"dn_id\", EventOperation.DELETION, \"properties\")        # with pytest.raises(InvalidEventAttributeName):      #     _ = Topic(EventEntityType.DATA_NODE, \"dn_id\", attribute_name=\"properties\")        with pytest.raises(InvalidEventOperation):          _ = _Topic(EventEntityType.DATA_NODE, \"dn_id\", EventOperation.SUBMISSION)        # with pytest.raises(InvalidEventOperation):      #     _ = Topic(EventEntityType.DATA_NODE, \"dn_id\", EventOperation.SUBMISSION, \"properties\")      def test_topic_creation_job():      topic_1 = _Topic(EventEntityType.JOB, \"job_id\", EventOperation.CREATION)      assert topic_1.entity_type == EventEntityType.JOB      assert topic_1.entity_id == \"job_id\"      assert topic_1.operation == EventOperation.CREATION      assert topic_1.attribute_name is None        topic_2 = _Topic(EventEntityType.JOB, \"job_id\", EventOperation.UPDATE, \"force\")      assert topic_2.entity_type == EventEntityType.JOB      assert topic_2.entity_id == \"job_id\"      assert topic_2.operation == EventOperation.UPDATE      assert topic_2.attribute_name == \"force\"        topic_3 = _Topic(EventEntityType.JOB, \"job_id\", EventOperation.DELETION)      assert topic_3.entity_type == EventEntityType.JOB      assert topic_3.entity_id == \"job_id\"      assert topic_3.operation == EventOperation.DELETION      assert topic_3.attribute_name is None        topic_4 = _Topic(EventEntityType.JOB, \"job_id\", EventOperation.CREATION)      assert topic_4.entity_type == EventEntityType.JOB      assert topic_4.entity_id == \"job_id\"      assert topic_4.operation == EventOperation.CREATION      assert topic_4.attribute_name is None        # with pytest.raises(InvalidEventAttributeName):      #     _ = Topic(EventEntityType.JOB, \"job_id\", EventOperation.CREATION, \"force\")        # with pytest.raises(InvalidEventAttributeName):      #     _ = Topic(EventEntityType.JOB, \"job_id\", EventOperation.DELETION, \"force\")        # with pytest.raises(InvalidEventAttributeName):      #     _ = Topic(EventEntityType.JOB, \"job_id\", attribute_name=\"force\")        with pytest.raises(InvalidEventOperation):          _ = _Topic(EventEntityType.JOB, \"job_id\", EventOperation.SUBMISSION)        # with pytest.raises(InvalidEventOperation):      #     _ = Topic(EventEntityType.JOB, \"job_id\", EventOperation.SUBMISSION, \"force\")      def test_topic_equal():      assert _Topic() == _Topic()      assert _Topic(EventEntityType.SCENARIO) == _Topic(EventEntityType.SCENARIO)      assert _Topic(entity_id=\"sequence_id\") == _Topic(entity_id=\"sequence_id\")      assert _Topic(operation=EventOperation.SUBMISSION) == _Topic(operation=EventOperation.SUBMISSION)      assert _Topic(EventEntityType.JOB, \"JOB_id\", EventOperation.UPDATE, \"status\") == _Topic(          EventEntityType.JOB, \"JOB_id\", EventOperation.UPDATE, \"status\"      ) "}
{"text": "#  # Licensed under the Apache License, Version 2.0 (the \"License\"); you may not use this file except in compliance with  # the License. You may obtain a copy of the License at  #  #        http://www.apache.org/licenses/LICENSE-2.0  #  # Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on  # an \"AS IS\" BASIS, WITHOUT 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.exceptions.exceptions import InvalidEventAttributeName, InvalidEventOperation  from src.taipy.core.notification.event import Event, EventEntityType, EventOperation  from taipy.config.common.frequency import Frequency      def test_event_creation_cycle():      event_1 = Event(          entity_type=EventEntityType.CYCLE,          operation=EventOperation.CREATION,          entity_id=\"cycle_id\",      )      assert event_1.creation_date is not None      assert event_1.entity_type == EventEntityType.CYCLE      assert event_1.entity_id == \"cycle_id\"      assert event_1.operation == EventOperation.CREATION      assert event_1.attribute_name is None        event_2 = Event(          entity_type=EventEntityType.CYCLE,          operation=EventOperation.UPDATE,          entity_id=\"cycle_id\",          attribute_name=\"frequency\",          attribute_value=Frequency.DAILY,      )      assert event_2.creation_date is not None      assert event_2.entity_type == EventEntityType.CYCLE      assert event_2.entity_id == \"cycle_id\"      assert event_2.operation == EventOperation.UPDATE      assert event_2.attribute_name == \"frequency\"        event_3 = Event(entity_type=EventEntityType.CYCLE, entity_id=\"cycle_id\", operation=EventOperation.DELETION)      assert event_3.creation_date is not None      assert event_3.entity_type == EventEntityType.CYCLE      assert event_3.entity_id == \"cycle_id\"      assert event_3.operation == EventOperation.DELETION      assert event_3.attribute_name is None        with pytest.raises(InvalidEventAttributeName):          _ = Event(              entity_type=EventEntityType.CYCLE,              operation=EventOperation.CREATION,              entity_id=\"cycle_id\",              attribute_name=\"frequency\",          )        with pytest.raises(InvalidEventAttributeName):          _ = Event(EventEntityType.CYCLE, EventOperation.DELETION, entity_id=\"cycle_id\", attribute_name=\"frequency\")        with pytest.raises(InvalidEventOperation):          _ = Event(              entity_type=EventEntityType.CYCLE,              operation=EventOperation.SUBMISSION,              entity_id=\"cycle_id\",          )        with pytest.raises(InvalidEventOperation):          _ = Event(              entity_type=EventEntityType.CYCLE,              operation=EventOperation.SUBMISSION,              entity_id=\"cycle_id\",              attribute_name=\"frequency\",          )      def test_event_creation_scenario():      event_1 = Event(entity_type=EventEntityType.SCENARIO, entity_id=\"scenario_id\", operation=EventOperation.CREATION)      assert event_1.creation_date is not None      assert event_1.entity_type == EventEntityType.SCENARIO      assert event_1.entity_id == \"scenario_id\"      assert event_1.operation == EventOperation.CREATION      assert event_1.attribute_name is None        event_2 = Event(          entity_type=EventEntityType.SCENARIO,          entity_id=\"scenario_id\",          operation=EventOperation.UPDATE,          attribute_name=\"is_primary\",          attribute_value=True,      )      assert event_2.creation_date is not None      assert event_2.entity_type == EventEntityType.SCENARIO      assert event_2.entity_id == \"scenario_id\"      assert event_2.operation == EventOperation.UPDATE      assert event_2.attribute_name == \"is_primary\"      assert event_2.attribute_value is True        event_3 = Event(entity_type=EventEntityType.SCENARIO, entity_id=\"scenario_id\", operation=EventOperation.DELETION)      assert event_3.creation_date is not None      assert event_3.entity_type == EventEntityType.SCENARIO      assert event_3.entity_id == \"scenario_id\"      assert event_3.operation == EventOperation.DELETION      assert event_3.attribute_name is None        event_4 = Event(entity_type=EventEntityType.SCENARIO, entity_id=\"scenario_id\", operation=EventOperation.SUBMISSION)      assert event_4.creation_date is not None      assert event_4.entity_type == EventEntityType.SCENARIO      assert event_4.entity_id == \"scenario_id\"      assert event_4.operation == EventOperation.SUBMISSION      assert event_4.attribute_name is None        with pytest.raises(InvalidEventAttributeName):          _ = Event(              entity_type=EventEntityType.SCENARIO,              entity_id=\"scenario_id\",              operation=EventOperation.CREATION,              attribute_name=\"is_primary\",          )        with pytest.raises(InvalidEventAttributeName):          _ = Event(              entity_type=EventEntityType.SCENARIO,              entity_id=\"scenario_id\",              operation=EventOperation.DELETION,              attribute_name=\"is_primary\",          )        with pytest.raises(InvalidEventAttributeName):          _ = Event(              entity_type=EventEntityType.SCENARIO,              entity_id=\"scenario_id\",              operation=EventOperation.SUBMISSION,              attribute_name=\"is_primary\",          )      def test_event_creation_sequence():      event_1 = Event(entity_type=EventEntityType.SEQUENCE, entity_id=\"sequence_id\", operation=EventOperation.CREATION)      assert event_1.creation_date is not None      assert event_1.entity_type == EventEntityType.SEQUENCE      assert event_1.entity_id == \"sequence_id\"      assert event_1.operation == EventOperation.CREATION      assert event_1.attribute_name is None        event_2 = Event(          entity_type=EventEntityType.SEQUENCE,          entity_id=\"sequence_id\",          operation=EventOperation.UPDATE,          attribute_name=\"subscribers\",          attribute_value=object(),      )      assert event_2.creation_date is not None      assert event_2.entity_type == EventEntityType.SEQUENCE      assert event_2.entity_id == \"sequence_id\"      assert event_2.operation == EventOperation.UPDATE      assert event_2.attribute_name == \"subscribers\"        event_3 = Event(entity_type=EventEntityType.SEQUENCE, entity_id=\"sequence_id\", operation=EventOperation.DELETION)      assert event_3.creation_date is not None      assert event_3.entity_type == EventEntityType.SEQUENCE      assert event_3.entity_id == \"sequence_id\"      assert event_3.operation == EventOperation.DELETION      assert event_3.attribute_name is None        event_4 = Event(entity_type=EventEntityType.SEQUENCE, entity_id=\"sequence_id\", operation=EventOperation.SUBMISSION)      assert event_4.creation_date is not None      assert event_4.entity_type == EventEntityType.SEQUENCE      assert event_4.entity_id == \"sequence_id\"      assert event_4.operation == EventOperation.SUBMISSION      assert event_4.attribute_name is None        with pytest.raises(InvalidEventAttributeName):          _ = Event(              entity_type=EventEntityType.SEQUENCE,              entity_id=\"sequence_id\",              operation=EventOperation.CREATION,              attribute_name=\"subscribers\",          )        with pytest.raises(InvalidEventAttributeName):          _ = Event(              entity_type=EventEntityType.SEQUENCE,              entity_id=\"sequence_id\",              operation=EventOperation.DELETION,              attribute_name=\"subscribers\",          )        with pytest.raises(InvalidEventAttributeName):          _ = Event(              entity_type=EventEntityType.SEQUENCE,              entity_id=\"sequence_id\",              operation=EventOperation.SUBMISSION,              attribute_name=\"subscribers\",          )      def test_event_creation_task():      event_1 = Event(entity_type=EventEntityType.TASK, entity_id=\"task_id\", operation=EventOperation.CREATION)      assert event_1.creation_date is not None      assert event_1.entity_type == EventEntityType.TASK      assert event_1.entity_id == \"task_id\"      assert event_1.operation == EventOperation.CREATION      assert event_1.attribute_name is None        event_2 = Event(          entity_type=EventEntityType.TASK,          entity_id=\"task_id\",          operation=EventOperation.UPDATE,          attribute_name=\"function\",      )      assert event_2.creation_date is not None      assert event_2.entity_type == EventEntityType.TASK      assert event_2.entity_id == \"task_id\"      assert event_2.operation == EventOperation.UPDATE      assert event_2.attribute_name == \"function\"        event_3 = Event(entity_type=EventEntityType.TASK, entity_id=\"task_id\", operation=EventOperation.DELETION)      assert event_3.creation_date is not None      assert event_3.entity_type == EventEntityType.TASK      assert event_3.entity_id == \"task_id\"      assert event_3.operation == EventOperation.DELETION      assert event_3.attribute_name is None        event_4 = Event(entity_type=EventEntityType.TASK, entity_id=\"task_id\", operation=EventOperation.SUBMISSION)      assert event_4.creation_date is not None      assert event_4.entity_type == EventEntityType.TASK      assert event_4.entity_id == \"task_id\"      assert event_4.operation == EventOperation.SUBMISSION      assert event_4.attribute_name is None        with pytest.raises(InvalidEventAttributeName):          _ = Event(              entity_type=EventEntityType.TASK,              entity_id=\"task_id\",              operation=EventOperation.CREATION,              attribute_name=\"function\",          )        with pytest.raises(InvalidEventAttributeName):          _ = Event(              entity_type=EventEntityType.TASK,              entity_id=\"task_id\",              operation=EventOperation.DELETION,              attribute_name=\"function\",          )        with pytest.raises(InvalidEventAttributeName):          _ = Event(              entity_type=EventEntityType.TASK,              entity_id=\"task_id\",              operation=EventOperation.SUBMISSION,              attribute_name=\"function\",          )      def test_event_creation_datanode():      event_1 = Event(entity_type=EventEntityType.DATA_NODE, entity_id=\"dn_id\", operation=EventOperation.CREATION)      assert event_1.creation_date is not None      assert event_1.entity_type == EventEntityType.DATA_NODE      assert event_1.entity_id == \"dn_id\"      assert event_1.operation == EventOperation.CREATION      assert event_1.attribute_name is None        event_2 = Event(          entity_type=EventEntityType.DATA_NODE,          entity_id=\"dn_id\",          operation=EventOperation.UPDATE,          attribute_name=\"properties\",      )      assert event_2.creation_date is not None      assert event_2.entity_type == EventEntityType.DATA_NODE      assert event_2.entity_id == \"dn_id\"      assert event_2.operation == EventOperation.UPDATE      assert event_2.attribute_name == \"properties\"        event_3 = Event(entity_type=EventEntityType.DATA_NODE, entity_id=\"dn_id\", operation=EventOperation.DELETION)      assert event_3.creation_date is not None      assert event_3.entity_type == EventEntityType.DATA_NODE      assert event_3.entity_id == \"dn_id\"      assert event_3.operation == EventOperation.DELETION      assert event_3.attribute_name is None        with pytest.raises(InvalidEventAttributeName):          _ = Event(              entity_type=EventEntityType.DATA_NODE,              entity_id=\"dn_id\",              operation=EventOperation.CREATION,              attribute_name=\"properties\",          )        with pytest.raises(InvalidEventAttributeName):          _ = Event(              entity_type=EventEntityType.DATA_NODE,              entity_id=\"dn_id\",              operation=EventOperation.DELETION,              attribute_name=\"properties\",          )        with pytest.raises(InvalidEventOperation):          _ = Event(entity_type=EventEntityType.DATA_NODE, entity_id=\"dn_id\", operation=EventOperation.SUBMISSION)        with pytest.raises(InvalidEventOperation):          _ = Event(              entity_type=EventEntityType.DATA_NODE,              entity_id=\"dn_id\",              operation=EventOperation.SUBMISSION,              attribute_name=\"properties\",          )      def test_event_creation_job():      event_1 = Event(entity_type=EventEntityType.JOB, entity_id=\"job_id\", operation=EventOperation.CREATION)      assert event_1.creation_date is not None      assert event_1.entity_type == EventEntityType.JOB      assert event_1.entity_id == \"job_id\"      assert event_1.operation == EventOperation.CREATION      assert event_1.attribute_name is None        event_2 = Event(          entity_type=EventEntityType.JOB, entity_id=\"job_id\", operation=EventOperation.UPDATE, attribute_name=\"force\"      )      assert event_2.creation_date is not None      assert event_2.entity_type == EventEntityType.JOB      assert event_2.entity_id == \"job_id\"      assert event_2.operation == EventOperation.UPDATE      assert event_2.attribute_name == \"force\"        event_3 = Event(entity_type=EventEntityType.JOB, entity_id=\"job_id\", operation=EventOperation.DELETION)      assert event_3.creation_date is not None      assert event_3.entity_type == EventEntityType.JOB      assert event_3.entity_id == \"job_id\"      assert event_3.operation == EventOperation.DELETION      assert event_3.attribute_name is None        with pytest.raises(InvalidEventAttributeName):          _ = Event(              entity_type=EventEntityType.JOB,              entity_id=\"job_id\",              operation=EventOperation.CREATION,              attribute_name=\"force\",          )        with pytest.raises(InvalidEventAttributeName):          _ = Event(              entity_type=EventEntityType.JOB,              entity_id=\"job_id\",              operation=EventOperation.DELETION,              attribute_name=\"force\",          )        with pytest.raises(InvalidEventOperation):          _ = Event(entity_type=EventEntityType.JOB, entity_id=\"job_id\", operation=EventOperation.SUBMISSION)        with pytest.raises(InvalidEventOperation):          _ = Event(              entity_type=EventEntityType.JOB,              entity_id=\"job_id\",              operation=EventOperation.SUBMISSION,              attribute_name=\"force\",          ) "}
{"text": "from dataclasses import dataclass, field  from math import exp  from queue import SimpleQueue    from colorama import init    from src.taipy.core import taipy as tp  from src.taipy.core.config import scenario_config  from src.taipy.core.job.status import Status  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 Snapshot:      \"\"\"      A captured snapshot of the recording core events consumer.      \"\"\"        def __init__(self):          self.collected_events = []          self.entity_type_collected = {}          self.operation_collected = {}          self.attr_name_collected = {}        def capture_event(self, event):          self.collected_events.append(event)          self.entity_type_collected[event.entity_type] = self.entity_type_collected.get(event.entity_type, 0) + 1          self.operation_collected[event.operation] = self.operation_collected.get(event.operation, 0) + 1          if event.attribute_name:              self.attr_name_collected[event.attribute_name] = self.attr_name_collected.get(event.attribute_name, 0) + 1      class RecordingConsumer(CoreEventConsumerBase):      \"\"\"      A straightforward and no-thread core events consumer that allows to      capture snapshots of received events.      \"\"\"        def __init__(self, registration_id: str, queue: SimpleQueue):          super().__init__(registration_id, queue)        def capture(self) -> Snapshot:          \"\"\"          Capture a snapshot of events received between the previous snapshot          (or from the start of this consumer).          \"\"\"          snapshot = Snapshot()          while not self.queue.empty():              event = self.queue.get()              snapshot.capture_event(event)          return snapshot        def process_event(self, event: Event):          # Nothing todo          pass        def start(self):          # Nothing to do here          pass        def stop(self):          # Nothing to do here either          pass      def identity(x):      return x      def test_events_published_for_scenario_creation():      input_config = Config.configure_data_node(\"the_input\")      output_config = Config.configure_data_node(\"the_output\")      task_config = Config.configure_task(\"the_task\", identity, input=input_config, output=output_config)      sc_config = Config.configure_scenario(          \"the_scenario\", task_configs=[task_config], frequency=Frequency.DAILY, sequences={\"the_seq\": [task_config]}      )      register_id_0, register_queue_0 = Notifier.register()      all_evts = RecordingConsumer(register_id_0, register_queue_0)      all_evts.start()      # Create a scenario only trigger 6 creation events (for cycle, data node(x2), task, sequence and scenario)      tp.create_scenario(sc_config)      snapshot = all_evts.capture()        assert len(snapshot.collected_events) == 6      assert snapshot.entity_type_collected.get(EventEntityType.CYCLE, 0) == 1      assert snapshot.entity_type_collected.get(EventEntityType.DATA_NODE, 0) == 2      assert snapshot.entity_type_collected.get(EventEntityType.TASK, 0) == 1      assert snapshot.entity_type_collected.get(EventEntityType.SEQUENCE, 0) == 1      assert snapshot.entity_type_collected.get(EventEntityType.SCENARIO, 0) == 1      assert snapshot.operation_collected.get(EventOperation.CREATION, 0) == 6      all_evts.stop()      def test_no_event_published_for_getting_scenario():      input_config = Config.configure_data_node(\"the_input\")      output_config = Config.configure_data_node(\"the_output\")      task_config = Config.configure_task(\"the_task\", identity, input=input_config, output=output_config)      sc_config = Config.configure_scenario(          \"the_scenario\", task_configs=[task_config], frequency=Frequency.DAILY, sequences={\"the_seq\": [task_config]}      )      scenario = tp.create_scenario(sc_config)        register_id_0, register_queue_0 = Notifier.register()      all_evts = RecordingConsumer(register_id_0, register_queue_0)      all_evts.start()      # Get all scenarios does not trigger any event      tp.get_scenarios()      snapshot = all_evts.capture()        assert len(snapshot.collected_events) == 0        # Get one scenario does not trigger any event      tp.get(scenario.id)      snapshot = all_evts.capture()      assert len(snapshot.collected_events) == 0        all_evts.stop()      def test_events_published_for_writing_dn():      input_config = Config.configure_data_node(\"the_input\")      output_config = Config.configure_data_node(\"the_output\")      task_config = Config.configure_task(\"the_task\", identity, input=input_config, output=output_config)      sc_config = Config.configure_scenario(          \"the_scenario\", task_configs=[task_config], frequency=Frequency.DAILY, sequences={\"the_seq\": [task_config]}      )      scenario = tp.create_scenario(sc_config)      register_id_0, register_queue_0 = Notifier.register()      all_evts = RecordingConsumer(register_id_0, register_queue_0)      all_evts.start()        # Write input manually trigger 4 data node update events      # for last_edit_date, editor_id, editor_expiration_date and edit_in_progress      scenario.the_input.write(\"test\")      snapshot = all_evts.capture()      assert len(snapshot.collected_events) == 4      assert snapshot.entity_type_collected.get(EventEntityType.CYCLE, 0) == 0      assert snapshot.entity_type_collected.get(EventEntityType.DATA_NODE, 0) == 4      assert snapshot.entity_type_collected.get(EventEntityType.TASK, 0) == 0      assert snapshot.entity_type_collected.get(EventEntityType.SEQUENCE, 0) == 0      assert snapshot.entity_type_collected.get(EventEntityType.SCENARIO, 0) == 0      assert snapshot.operation_collected.get(EventOperation.CREATION, 0) == 0      assert snapshot.operation_collected.get(EventOperation.UPDATE, 0) == 4      all_evts.stop()      def test_events_published_for_scenario_submission():      input_config = Config.configure_data_node(\"the_input\")      output_config = Config.configure_data_node(\"the_output\")      task_config = Config.configure_task(\"the_task\", identity, input=input_config, output=output_config)      sc_config = Config.configure_scenario(          \"the_scenario\", task_configs=[task_config], frequency=Frequency.DAILY, sequences={\"the_seq\": [task_config]}      )      scenario = tp.create_scenario(sc_config)      scenario.the_input.write(\"test\")      register_id_0, register_queue_0 = Notifier.register()      all_evts = RecordingConsumer(register_id_0, register_queue_0)      all_evts.start()      # Submit a scenario triggers:      # 1 scenario submission event      # 7 dn update events (for last_edit_date, editor_id(x2), editor_expiration_date(x2) and edit_in_progress(x2))      # 1 job creation event      # 3 job update events (for status: PENDING, RUNNING and COMPLETED)      # 1 submission creation event      # 1 submission update event for jobs      # 3 submission update events (for status: PENDING, RUNNING and COMPLETED)      scenario.submit()      snapshot = all_evts.capture()      assert len(snapshot.collected_events) == 17      assert snapshot.entity_type_collected.get(EventEntityType.CYCLE, 0) == 0      assert snapshot.entity_type_collected.get(EventEntityType.DATA_NODE, 0) == 7      assert snapshot.entity_type_collected.get(EventEntityType.TASK, 0) == 0      assert snapshot.entity_type_collected.get(EventEntityType.SEQUENCE, 0) == 0      assert snapshot.entity_type_collected.get(EventEntityType.SCENARIO, 0) == 1      assert snapshot.entity_type_collected.get(EventEntityType.JOB, 0) == 4      assert snapshot.entity_type_collected.get(EventEntityType.SUBMISSION, 0) == 5      assert snapshot.operation_collected.get(EventOperation.CREATION, 0) == 2      assert snapshot.operation_collected.get(EventOperation.UPDATE, 0) == 14      assert snapshot.operation_collected.get(EventOperation.SUBMISSION, 0) == 1        assert snapshot.attr_name_collected[\"last_edit_date\"] == 1      assert snapshot.attr_name_collected[\"editor_id\"] == 2      assert snapshot.attr_name_collected[\"editor_expiration_date\"] == 2      assert snapshot.attr_name_collected[\"edit_in_progress\"] == 2      assert snapshot.attr_name_collected[\"status\"] == 3      assert snapshot.attr_name_collected[\"jobs\"] == 1      assert snapshot.attr_name_collected[\"submission_status\"] == 3        all_evts.stop()      def test_events_published_for_scenario_deletion():      input_config = Config.configure_data_node(\"the_input\")      output_config = Config.configure_data_node(\"the_output\")      task_config = Config.configure_task(\"the_task\", identity, input=input_config, output=output_config)      sc_config = Config.configure_scenario(          \"the_scenario\", task_configs=[task_config], frequency=Frequency.DAILY, sequences={\"the_seq\": [task_config]}      )      scenario = tp.create_scenario(sc_config)      scenario.the_input.write(\"test\")      scenario.submit()      register_id_0, register_queue_0 = Notifier.register()      all_evts = RecordingConsumer(register_id_0, register_queue_0)      all_evts.start()      # Delete a scenario trigger 8 deletion events      # 1 scenario deletion event      # 1 cycle deletion event      # 2 dn deletion events (for input and output)      # 1 task deletion event      # 1 sequence deletion event      # 1 job deletion event      # 1 submission deletion event      tp.delete(scenario.id)      snapshot = all_evts.capture()        assert len(snapshot.collected_events) == 8      assert snapshot.entity_type_collected.get(EventEntityType.CYCLE, 0) == 1      assert snapshot.entity_type_collected.get(EventEntityType.DATA_NODE, 0) == 2      assert snapshot.entity_type_collected.get(EventEntityType.TASK, 0) == 1      assert snapshot.entity_type_collected.get(EventEntityType.SEQUENCE, 0) == 1      assert snapshot.entity_type_collected.get(EventEntityType.SCENARIO, 0) == 1      assert snapshot.entity_type_collected.get(EventEntityType.SUBMISSION, 0) == 1      assert snapshot.entity_type_collected.get(EventEntityType.JOB, 0) == 1      assert snapshot.operation_collected.get(EventOperation.UPDATE, 0) == 0      assert snapshot.operation_collected.get(EventOperation.SUBMISSION, 0) == 0      assert snapshot.operation_collected.get(EventOperation.DELETION, 0) == 8        all_evts.stop()      def test_job_events():      input_config = Config.configure_data_node(\"the_input\")      output_config = Config.configure_data_node(\"the_output\")      task_config = Config.configure_task(\"the_task\", identity, input=input_config, output=output_config)      sc_config = Config.configure_scenario(          \"the_scenario\", task_configs=[task_config], frequency=Frequency.DAILY, sequences={\"the_seq\": [task_config]}      )      register_id, register_queue = Notifier.register(entity_type=EventEntityType.JOB)      consumer = RecordingConsumer(register_id, register_queue)      consumer.start()        # Create scenario      scenario = tp.create_scenario(sc_config)      snapshot = consumer.capture()      assert len(snapshot.collected_events) == 0        # Submit scenario      scenario.submit()      snapshot = consumer.capture()        # 2 events expected: one for creation, another for status update      assert len(snapshot.collected_events) == 2      assert snapshot.collected_events[0].operation == EventOperation.CREATION      assert snapshot.collected_events[0].entity_type == EventEntityType.JOB      assert snapshot.collected_events[0].metadata.get(\"task_config_id\") == task_config.id        assert snapshot.collected_events[1].operation == EventOperation.UPDATE      assert snapshot.collected_events[1].entity_type == EventEntityType.JOB      assert snapshot.collected_events[1].metadata.get(\"task_config_id\") == task_config.id      assert snapshot.collected_events[1].attribute_name == \"status\"      assert snapshot.collected_events[1].attribute_value == Status.BLOCKED        job = tp.get_jobs()[0]        tp.cancel_job(job)      snapshot = consumer.capture()      assert len(snapshot.collected_events) == 1      event = snapshot.collected_events[0]      assert event.metadata.get(\"task_config_id\") == task_config.id      assert event.attribute_name == \"status\"      assert event.attribute_value == Status.CANCELED        consumer.stop()      def test_scenario_events():      input_config = Config.configure_data_node(\"the_input\")      output_config = Config.configure_data_node(\"the_output\")      task_config = Config.configure_task(\"the_task\", identity, input=input_config, output=output_config)      sc_config = Config.configure_scenario(          \"the_scenario\", task_configs=[task_config], frequency=Frequency.DAILY, sequences={\"the_seq\": [task_config]}      )      register_id, register_queue = Notifier.register(entity_type=EventEntityType.SCENARIO)      consumer = RecordingConsumer(register_id, register_queue)      consumer.start()      scenario = tp.create_scenario(sc_config)        snapshot = consumer.capture()      assert len(snapshot.collected_events) == 1      assert snapshot.collected_events[0].operation == EventOperation.CREATION      assert snapshot.collected_events[0].entity_type == EventEntityType.SCENARIO      assert snapshot.collected_events[0].metadata.get(\"config_id\") == scenario.config_id        scenario.submit()      snapshot = consumer.capture()      assert len(snapshot.collected_events) == 1      assert snapshot.collected_events[0].operation == EventOperation.SUBMISSION      assert snapshot.collected_events[0].entity_type == EventEntityType.SCENARIO      assert snapshot.collected_events[0].metadata.get(\"config_id\") == scenario.config_id        # Delete scenario      tp.delete(scenario.id)      snapshot = consumer.capture()      assert len(snapshot.collected_events) == 1        assert snapshot.collected_events[0].operation == EventOperation.DELETION      assert snapshot.collected_events[0].entity_type == EventEntityType.SCENARIO        consumer.stop()      def test_data_node_events():      input_config = Config.configure_data_node(\"the_input\")      output_config = Config.configure_data_node(\"the_output\")      task_config = Config.configure_task(\"the_task\", identity, input=input_config, output=output_config)      sc_config = Config.configure_scenario(          \"the_scenario\", task_configs=[task_config], frequency=Frequency.DAILY, sequences={\"the_seq\": [task_config]}      )      register_id, register_queue = Notifier.register(entity_type=EventEntityType.DATA_NODE)      consumer = RecordingConsumer(register_id, register_queue)      consumer.start()        scenario = tp.create_scenario(sc_config)        snapshot = consumer.capture()      # We expect two creation events since we have two data nodes:      assert len(snapshot.collected_events) == 2        assert snapshot.collected_events[0].operation == EventOperation.CREATION      assert snapshot.collected_events[0].entity_type == EventEntityType.DATA_NODE      assert snapshot.collected_events[0].metadata.get(\"config_id\") in [output_config.id, input_config.id]        assert snapshot.collected_events[1].operation == EventOperation.CREATION      assert snapshot.collected_events[1].entity_type == EventEntityType.DATA_NODE      assert snapshot.collected_events[1].metadata.get(\"config_id\") in [output_config.id, input_config.id]        # Delete scenario      tp.delete(scenario.id)      snapshot = consumer.capture()      assert len(snapshot.collected_events) == 2        assert snapshot.collected_events[0].operation == EventOperation.DELETION      assert snapshot.collected_events[0].entity_type == EventEntityType.DATA_NODE        assert snapshot.collected_events[1].operation == EventOperation.DELETION      assert snapshot.collected_events[1].entity_type == EventEntityType.DATA_NODE        consumer.stop() "}
{"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": "#  # Licensed under the Apache License, Version 2.0 (the \"License\"); you may not use this file except in compliance with  # the License. You may obtain a copy of the License at  #  #        http://www.apache.org/licenses/LICENSE-2.0  #  # Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on  # an \"AS IS\" BASIS, WITHOUT 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 datetime  from datetime import timedelta    from src.taipy.core import CycleId  from src.taipy.core.cycle._cycle_manager import _CycleManager  from src.taipy.core.cycle.cycle import Cycle  from taipy.config.common.frequency import Frequency      def test_create_cycle_entity(current_datetime):      cycle_1 = Cycle(          Frequency.DAILY,          {\"key\": \"value\"},          creation_date=current_datetime,          start_date=current_datetime,          end_date=current_datetime,          name=\"foo\",      )      assert cycle_1.id is not None      assert cycle_1.name == \"foo\"      assert cycle_1.properties == {\"key\": \"value\"}      assert cycle_1.creation_date == current_datetime      assert cycle_1.start_date == current_datetime      assert cycle_1.end_date == current_datetime      assert cycle_1.key == \"value\"      assert cycle_1.frequency == Frequency.DAILY        cycle_2 = Cycle(Frequency.YEARLY, {}, current_datetime, current_datetime, current_datetime)      assert cycle_2.name == current_datetime.strftime(\"%Y\")      assert cycle_2.frequency == Frequency.YEARLY        cycle_3 = Cycle(Frequency.MONTHLY, {}, current_datetime, current_datetime, current_datetime)      assert cycle_3.name == current_datetime.strftime(\"%B %Y\")      assert cycle_3.frequency == Frequency.MONTHLY        cycle_4 = Cycle(Frequency.WEEKLY, {}, current_datetime, current_datetime, current_datetime)      assert cycle_4.name == current_datetime.strftime(\"Week %W %Y, from %d. %B\")      assert cycle_4.frequency == Frequency.WEEKLY        cycle_5 = Cycle(Frequency.DAILY, {}, current_datetime, current_datetime, current_datetime)      assert cycle_5.name == current_datetime.strftime(\"%A, %d. %B %Y\")      assert cycle_5.frequency == Frequency.DAILY      def test_cycle_name(current_datetime):      start_date = datetime.datetime(2023, 1, 2)      cycle = Cycle(Frequency.DAILY, {}, current_datetime, start_date, start_date, \"name\", CycleId(\"id\"))      assert cycle.name == \"name\"      cycle = Cycle(Frequency.DAILY, {}, current_datetime, start_date, start_date, None, CycleId(\"id\"))      assert cycle.name == \"Monday, 02. January 2023\"      cycle = Cycle(Frequency.WEEKLY, {}, current_datetime, start_date, start_date, None, CycleId(\"id\"))      assert cycle.name == \"Week 01 2023, from 02. January\"      cycle = Cycle(Frequency.MONTHLY, {}, current_datetime, start_date, start_date, None, CycleId(\"id\"))      assert cycle.name == \"January 2023\"      cycle = Cycle(Frequency.QUARTERLY, {}, current_datetime, start_date, start_date, None, CycleId(\"id\"))      assert cycle.name == \"2023 Q1\"      cycle = Cycle(Frequency.YEARLY, {}, current_datetime, start_date, start_date, None, CycleId(\"id\"))      assert cycle.name == \"2023\"      def test_cycle_label(current_datetime):      cycle = Cycle(          Frequency.DAILY,          {\"key\": \"value\"},          creation_date=current_datetime,          start_date=current_datetime,          end_date=current_datetime,      )      assert cycle.get_label() == cycle.name      assert cycle.get_simple_label() == cycle.name        cycle._properties[\"label\"] = \"label\"      assert cycle.get_label() == \"label\"      assert cycle.get_simple_label() == \"label\"      def test_add_property_to_scenario(current_datetime):      cycle = Cycle(          Frequency.WEEKLY,          {\"key\": \"value\"},          current_datetime,          current_datetime,          current_datetime,          name=\"foo\",      )      assert cycle.properties == {\"key\": \"value\"}      assert cycle.key == \"value\"        cycle.properties[\"new_key\"] = \"new_value\"        assert cycle.properties == {\"key\": \"value\", \"new_key\": \"new_value\"}      assert cycle.key == \"value\"      assert cycle.new_key == \"new_value\"      def test_auto_set_and_reload(current_datetime):      cycle_1 = Cycle(          Frequency.WEEKLY,          {\"key\": \"value\"},          current_datetime,          current_datetime,          current_datetime,          name=\"foo\",      )        _CycleManager._set(cycle_1)      cycle_2 = _CycleManager._get(cycle_1)        # auto set & reload on frequency attribute      assert cycle_1.frequency == Frequency.WEEKLY      cycle_1.frequency = Frequency.YEARLY      assert cycle_1.frequency == Frequency.YEARLY      assert cycle_2.frequency == Frequency.YEARLY      cycle_2.frequency = Frequency.MONTHLY      assert cycle_1.frequency == Frequency.MONTHLY      assert cycle_2.frequency == Frequency.MONTHLY        new_datetime_1 = current_datetime + timedelta(1)      new_datetime_2 = current_datetime + timedelta(2)        # auto set & reload on creation_date attribute      assert cycle_1.creation_date == current_datetime      assert cycle_2.creation_date == current_datetime      cycle_1.creation_date = new_datetime_1      assert cycle_1.creation_date == new_datetime_1      assert cycle_2.creation_date == new_datetime_1      cycle_2.creation_date = new_datetime_2      assert cycle_1.creation_date == new_datetime_2      assert cycle_2.creation_date == new_datetime_2        # auto set & reload on start_date attribute      assert cycle_1.start_date == current_datetime      assert cycle_2.start_date == current_datetime      cycle_1.start_date = new_datetime_1      assert cycle_1.start_date == new_datetime_1      assert cycle_2.start_date == new_datetime_1      cycle_2.start_date = new_datetime_2      assert cycle_1.start_date == new_datetime_2      assert cycle_2.start_date == new_datetime_2        # auto set & reload on end_date attribute      assert cycle_1.end_date == current_datetime      assert cycle_2.end_date == current_datetime      cycle_1.end_date = new_datetime_1      assert cycle_1.end_date == new_datetime_1      assert cycle_2.end_date == new_datetime_1      cycle_2.end_date = new_datetime_2      assert cycle_1.end_date == new_datetime_2      assert cycle_2.end_date == new_datetime_2        # auto set & reload on names attribute      assert cycle_1.name == \"foo\"      assert cycle_2.name == \"foo\"      cycle_1.name = \"fed\"      assert cycle_1.name == \"fed\"      assert cycle_2.name == \"fed\"      cycle_2.name = \"def\"      assert cycle_1.name == \"def\"      assert cycle_2.name == \"def\"        # auto set & reload on properties attribute      assert cycle_1.properties == {\"key\": \"value\"}      assert cycle_2.properties == {\"key\": \"value\"}      cycle_1._properties[\"qux\"] = 4      assert cycle_1.properties[\"qux\"] == 4      assert cycle_2.properties[\"qux\"] == 4        assert cycle_1.properties == {\"key\": \"value\", \"qux\": 4}      assert cycle_2.properties == {\"key\": \"value\", \"qux\": 4}      cycle_2._properties[\"qux\"] = 5      assert cycle_1.properties[\"qux\"] == 5      assert cycle_2.properties[\"qux\"] == 5        cycle_1.properties[\"temp_key_1\"] = \"temp_value_1\"      cycle_1.properties[\"temp_key_2\"] = \"temp_value_2\"      assert cycle_1.properties == {          \"qux\": 5,          \"key\": \"value\",          \"temp_key_1\": \"temp_value_1\",          \"temp_key_2\": \"temp_value_2\",      }      assert cycle_2.properties == {          \"qux\": 5,          \"key\": \"value\",          \"temp_key_1\": \"temp_value_1\",          \"temp_key_2\": \"temp_value_2\",      }      cycle_1.properties.pop(\"temp_key_1\")      assert \"temp_key_1\" not in cycle_1.properties.keys()      assert \"temp_key_1\" not in cycle_1.properties.keys()      assert cycle_1.properties == {          \"key\": \"value\",          \"qux\": 5,          \"temp_key_2\": \"temp_value_2\",      }      assert cycle_2.properties == {          \"key\": \"value\",          \"qux\": 5,          \"temp_key_2\": \"temp_value_2\",      }      cycle_2.properties.pop(\"temp_key_2\")      assert cycle_1.properties == {\"key\": \"value\", \"qux\": 5}      assert cycle_2.properties == {\"key\": \"value\", \"qux\": 5}      assert \"temp_key_2\" not in cycle_1.properties.keys()      assert \"temp_key_2\" not in cycle_2.properties.keys()        cycle_1.properties[\"temp_key_3\"] = 0      assert cycle_1.properties == {\"key\": \"value\", \"qux\": 5, \"temp_key_3\": 0}      assert cycle_2.properties == {\"key\": \"value\", \"qux\": 5, \"temp_key_3\": 0}      cycle_1.properties.update({\"temp_key_3\": 1})      assert cycle_1.properties == {\"key\": \"value\", \"qux\": 5, \"temp_key_3\": 1}      assert cycle_2.properties == {\"key\": \"value\", \"qux\": 5, \"temp_key_3\": 1}      cycle_1.properties.update(dict())      assert cycle_1.properties == {\"key\": \"value\", \"qux\": 5, \"temp_key_3\": 1}      assert cycle_2.properties == {\"key\": \"value\", \"qux\": 5, \"temp_key_3\": 1}      cycle_1.properties.pop(\"key\")      cycle_1.properties[\"temp_key_4\"] = 0      cycle_1.properties[\"temp_key_5\"] = 0        new_datetime_3 = new_datetime_1 + timedelta(5)      with cycle_1 as cycle:          assert cycle.frequency == Frequency.MONTHLY          assert cycle.creation_date == new_datetime_2          assert cycle.start_date == new_datetime_2          assert cycle.end_date == new_datetime_2          assert cycle.name == \"def\"          assert cycle._is_in_context          assert cycle.properties[\"qux\"] == 5          assert cycle.properties[\"temp_key_3\"] == 1          assert cycle.properties[\"temp_key_4\"] == 0          assert cycle.properties[\"temp_key_5\"] == 0            cycle.frequency = Frequency.YEARLY          cycle.creation_date = new_datetime_3          cycle.start_date = new_datetime_3          cycle.end_date = new_datetime_3          cycle.name = \"abc\"          assert cycle.name == \"def\"          assert cycle._name == \"abc\"          cycle.properties[\"qux\"] = 9          cycle.properties.pop(\"temp_key_3\")          cycle.properties.pop(\"temp_key_4\")          cycle.properties.update({\"temp_key_4\": 1})          cycle.properties.update({\"temp_key_5\": 2})          cycle.properties.pop(\"temp_key_5\")          cycle.properties.update(dict())            assert cycle.frequency == Frequency.MONTHLY          assert cycle.creation_date == new_datetime_2          assert cycle.start_date == new_datetime_2          assert cycle.end_date == new_datetime_2          assert cycle._is_in_context          assert cycle.properties[\"qux\"] == 5          assert cycle.name == \"def\"          assert cycle.properties[\"temp_key_3\"] == 1          assert cycle.properties[\"temp_key_4\"] == 0          assert cycle.properties[\"temp_key_5\"] == 0        assert cycle_1.frequency == Frequency.YEARLY      assert cycle_1.creation_date == new_datetime_3      assert cycle_1.start_date == new_datetime_3      assert cycle_1.end_date == new_datetime_3      assert cycle_1.name == \"abc\"      assert cycle_1.properties[\"qux\"] == 9      assert \"temp_key_3\" not in cycle_1.properties.keys()      assert cycle_1.properties[\"temp_key_4\"] == 1      assert \"temp_key_5\" not in cycle_1.properties.keys() "}
{"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": "from datetime import datetime    from src.taipy.core._orchestrator._orchestrator_factory import _OrchestratorFactory  from src.taipy.core.config.job_config import JobConfig  from src.taipy.core.cycle._cycle_manager import _CycleManager  from src.taipy.core.cycle.cycle import Cycle  from src.taipy.core.cycle.cycle_id import CycleId  from src.taipy.core.data._data_manager import _DataManager  from src.taipy.core.job._job_manager import _JobManager  from src.taipy.core.scenario._scenario_manager import _ScenarioManager  from src.taipy.core.sequence._sequence_manager import _SequenceManager  from src.taipy.core.task._task_manager import _TaskManager  from taipy.config.common.frequency import Frequency  from taipy.config.common.scope import Scope  from taipy.config.config import Config      def test_save_and_get_cycle_entity(tmpdir, cycle, current_datetime):      _CycleManager._repository.base_path = tmpdir        assert len(_CycleManager._get_all()) == 0        _CycleManager._set(cycle)      assert _CycleManager._exists(cycle.id)        cycle_1 = _CycleManager._get(cycle.id)        assert cycle_1.id == cycle.id      assert cycle_1.name == cycle.name      assert cycle_1.properties == cycle.properties      assert cycle_1.creation_date == cycle.creation_date      assert cycle_1.start_date == cycle.start_date      assert cycle_1.end_date == cycle.end_date      assert cycle_1.frequency == cycle.frequency        assert len(_CycleManager._get_all()) == 1      assert _CycleManager._get(cycle.id) == cycle      assert _CycleManager._get(cycle.id).name == cycle.name      assert isinstance(_CycleManager._get(cycle.id).creation_date, datetime)      assert _CycleManager._get(cycle.id).creation_date == cycle.creation_date      assert _CycleManager._get(cycle.id).frequency == Frequency.DAILY        cycle_2_id = CycleId(\"cycle_2\")      assert _CycleManager._get(cycle_2_id) is None      assert not _CycleManager._exists(cycle_2_id)        cycle_3 = Cycle(          Frequency.MONTHLY,          {},          creation_date=current_datetime,          start_date=current_datetime,          end_date=current_datetime,          name=\"bar\",          id=cycle_1.id,      )      _CycleManager._set(cycle_3)        cycle_3 = _CycleManager._get(cycle_1.id)        assert _CycleManager._exists(cycle_1.id)      assert len(_CycleManager._get_all()) == 1      assert cycle_3.id == cycle_1.id      assert cycle_3.name == cycle_3.name      assert cycle_3.properties == cycle_3.properties      assert cycle_3.creation_date == current_datetime      assert cycle_3.start_date == current_datetime      assert cycle_3.end_date == current_datetime      assert cycle_3.frequency == cycle_3.frequency      def test_create_and_delete_cycle_entity(tmpdir):      _CycleManager._repository.base_path = tmpdir        assert len(_CycleManager._get_all()) == 0        cycle_1 = _CycleManager._create(Frequency.DAILY, name=\"foo\", key=\"value\")        assert cycle_1.id is not None      assert cycle_1.name == \"foo\"      assert cycle_1.properties == {\"key\": \"value\"}      assert cycle_1.creation_date is not None      assert cycle_1.start_date is not None      assert cycle_1.end_date is not None      assert cycle_1.start_date < cycle_1.creation_date < cycle_1.end_date      assert cycle_1.key == \"value\"      assert cycle_1.frequency == Frequency.DAILY        cycle_1_id = cycle_1.id        assert _CycleManager._exists(cycle_1.id)      assert len(_CycleManager._get_all()) == 1      assert _CycleManager._get(cycle_1_id) == cycle_1      assert _CycleManager._get(cycle_1_id).name == \"foo\"      assert isinstance(_CycleManager._get(cycle_1_id).creation_date, datetime)      assert _CycleManager._get(cycle_1_id).frequency == Frequency.DAILY        cycle_2_id = CycleId(\"cycle_2\")      assert _CycleManager._get(cycle_2_id) is None      assert not _CycleManager._exists(cycle_2_id)        cycle_3 = _CycleManager._create(Frequency.MONTHLY, \"bar\")        assert cycle_3.id is not None      assert cycle_3.name == \"bar\"      assert isinstance(cycle_3.creation_date, datetime)      assert cycle_3.frequency == Frequency.MONTHLY        cycle_3_id = cycle_3.id        assert _CycleManager._exists(cycle_3_id)      assert len(_CycleManager._get_all()) == 2      assert _CycleManager._get(cycle_3_id).name == \"bar\"        cycle_4 = _CycleManager._create(Frequency.YEARLY, \"baz\")      cycle_4_id = cycle_4.id        assert _CycleManager._exists(cycle_4_id)      assert len(_CycleManager._get_all()) == 3        _CycleManager._delete(cycle_4_id)        assert len(_CycleManager._get_all()) == 2      assert not _CycleManager._exists(cycle_4_id)      assert _CycleManager._get(cycle_4_id) is None        _CycleManager._delete_all()      assert len(_CycleManager._get_all()) == 0      assert not any(_CycleManager._exists(cycle_id) for cycle_id in [cycle_1_id, cycle_3_id, cycle_4_id])      def test_get_cycle_start_date_and_end_date():      creation_date_1 = datetime.fromisoformat(\"2021-11-11T11:11:01.000001\")        daily_start_date_1 = _CycleManager._get_start_date_of_cycle(Frequency.DAILY, creation_date=creation_date_1)      weekly_start_date_1 = _CycleManager._get_start_date_of_cycle(Frequency.WEEKLY, creation_date=creation_date_1)      monthly_start_date_1 = _CycleManager._get_start_date_of_cycle(Frequency.MONTHLY, creation_date=creation_date_1)      yearly_start_date_1 = _CycleManager._get_start_date_of_cycle(Frequency.YEARLY, creation_date=creation_date_1)        assert daily_start_date_1 == datetime.fromisoformat(\"2021-11-11T00:00:00.000000\")      assert weekly_start_date_1 == datetime.fromisoformat(\"2021-11-08T00:00:00.000000\")      assert monthly_start_date_1 == datetime.fromisoformat(\"2021-11-01T00:00:00.000000\")      assert yearly_start_date_1 == datetime.fromisoformat(\"2021-01-01T00:00:00.000000\")        daily_end_date_1 = _CycleManager._get_end_date_of_cycle(Frequency.DAILY, start_date=daily_start_date_1)      weekly_end_date_1 = _CycleManager._get_end_date_of_cycle(Frequency.WEEKLY, start_date=weekly_start_date_1)      monthly_end_date_1 = _CycleManager._get_end_date_of_cycle(Frequency.MONTHLY, start_date=monthly_start_date_1)      yearly_end_date_1 = _CycleManager._get_end_date_of_cycle(Frequency.YEARLY, start_date=yearly_start_date_1)        assert daily_end_date_1 == datetime.fromisoformat(\"2021-11-11T23:59:59.999999\")      assert weekly_end_date_1 == datetime.fromisoformat(\"2021-11-14T23:59:59.999999\")      assert monthly_end_date_1 == datetime.fromisoformat(\"2021-11-30T23:59:59.999999\")      assert yearly_end_date_1 == datetime.fromisoformat(\"2021-12-31T23:59:59.999999\")        creation_date_2 = datetime.now()        daily_start_date_2 = _CycleManager._get_start_date_of_cycle(Frequency.DAILY, creation_date=creation_date_2)      daily_end_date_2 = _CycleManager._get_end_date_of_cycle(Frequency.DAILY, daily_start_date_2)      assert daily_start_date_2.date() == creation_date_2.date()      assert daily_end_date_2.date() == creation_date_2.date()      assert daily_start_date_2 < creation_date_2 < daily_end_date_2        weekly_start_date_2 = _CycleManager._get_start_date_of_cycle(Frequency.WEEKLY, creation_date=creation_date_2)      weekly_end_date_2 = _CycleManager._get_end_date_of_cycle(Frequency.WEEKLY, weekly_start_date_2)      assert weekly_start_date_2 < creation_date_2 < weekly_end_date_2        monthly_start_date_2 = _CycleManager._get_start_date_of_cycle(Frequency.MONTHLY, creation_date=creation_date_2)      monthly_end_date_2 = _CycleManager._get_end_date_of_cycle(Frequency.MONTHLY, monthly_start_date_2)      assert monthly_start_date_2.month == creation_date_2.month and monthly_start_date_2.day == 1      assert monthly_end_date_2.month == creation_date_2.month      assert monthly_start_date_2 < creation_date_2 < monthly_end_date_2        yearly_start_date_2 = _CycleManager._get_start_date_of_cycle(Frequency.YEARLY, creation_date=creation_date_2)      yearly_end_date_2 = _CycleManager._get_end_date_of_cycle(Frequency.YEARLY, yearly_start_date_2)      assert yearly_start_date_2.year == creation_date_2.year      assert yearly_start_date_2 == datetime(creation_date_2.year, 1, 1)      assert yearly_end_date_2.year == creation_date_2.year      assert yearly_end_date_2.date() == datetime(creation_date_2.year, 12, 31).date()      assert yearly_start_date_2 < creation_date_2 < yearly_end_date_2      def test_hard_delete_shared_entities():      Config.configure_job_executions(mode=JobConfig._DEVELOPMENT_MODE)        dn_config_1 = Config.configure_data_node(\"my_input_1\", \"in_memory\", scope=Scope.SCENARIO, default_data=\"testing\")      dn_config_2 = Config.configure_data_node(\"my_input_2\", \"in_memory\", scope=Scope.SCENARIO, default_data=\"testing\")      dn_config_3 = Config.configure_data_node(\"my_input_3\", \"in_memory\", scope=Scope.CYCLE, default_data=\"testing\")      dn_config_4 = Config.configure_data_node(\"my_input_4\", \"in_memory\", scope=Scope.GLOBAL, default_data=\"testing\")      task_config_1 = Config.configure_task(\"task_config_1\", print, dn_config_1, dn_config_2)      task_config_2 = Config.configure_task(\"task_config_2\", print, dn_config_2, dn_config_3)      task_config_3 = Config.configure_task(\"task_config_3\", print, dn_config_3, dn_config_4)  # scope = global      creation_date = datetime.now()      scenario_config_1 = Config.configure_scenario(          \"scenario_config_1\",          [task_config_1, task_config_2, task_config_3],          creation_date=creation_date,          frequency=Frequency.DAILY,      )      scenario_config_1.add_sequences(          {              \"sequence_1\": [task_config_1, task_config_2],              \"sequence_2\": [task_config_1, task_config_2],              \"sequence_3\": [task_config_3],          }      )      scenario_config_2 = Config.configure_scenario(          \"scenario_config_2\", [task_config_2, task_config_3]      )  # No Frequency so cycle attached to scenarios      scenario_config_2.add_sequences({\"sequence_3\": [task_config_3]})        _OrchestratorFactory._build_dispatcher()        scenario_1 = _ScenarioManager._create(scenario_config_1)      scenario_2 = _ScenarioManager._create(scenario_config_1)      scenario_3 = _ScenarioManager._create(scenario_config_2)      scenario_1.submit()      scenario_2.submit()      scenario_3.submit()        assert len(_ScenarioManager._get_all()) == 3      assert len(_SequenceManager._get_all()) == 7      assert len(_TaskManager._get_all()) == 7      assert len(_DataManager._get_all()) == 8      assert len(_JobManager._get_all()) == 8      assert len(_CycleManager._get_all()) == 1      _CycleManager._hard_delete(scenario_1.cycle.id)      assert len(_CycleManager._get_all()) == 0      assert len(_ScenarioManager._get_all()) == 1      assert len(_SequenceManager._get_all()) == 1      assert len(_TaskManager._get_all()) == 2      assert len(_JobManager._get_all()) == 2      assert len(_DataManager._get_all()) == 3      def test_get_primary(tmpdir, cycle, current_datetime):      _CycleManager._repository.base_path = tmpdir        assert len(_CycleManager._get_all()) == 0        _CycleManager._set(cycle)      cycle_1 = _CycleManager._get(cycle.id)      cycle_2 = Cycle(Frequency.MONTHLY, {}, current_datetime, current_datetime, current_datetime, name=\"foo\")      _CycleManager._set(cycle_2)      cycle_2 = _CycleManager._get(cycle_2.id)      cycles = _CycleManager._get_all()      assert len(_CycleManager._get_all()) == 2      assert (          len(_CycleManager._get_cycles_by_frequency_and_start_date(cycle_1.frequency, cycle_1.start_date, cycles)) == 1      )      assert (          len(_CycleManager._get_cycles_by_frequency_and_start_date(cycle_2.frequency, cycle_2.start_date, cycles)) == 1      )      assert (          len(              _CycleManager._get_cycles_by_frequency_and_start_date(                  Frequency.WEEKLY, datetime(2000, 1, 1, 1, 0, 0, 0), cycles              )          )          == 0      )        assert (          len(              _CycleManager._get_cycles_by_frequency_and_overlapping_date(                  cycle_1.frequency, cycle_1.creation_date, cycles              )          )          == 1      )      assert (          _CycleManager._get_cycles_by_frequency_and_overlapping_date(cycle_1.frequency, cycle_1.creation_date, cycles)[0]          == cycle_1      )      assert (          len(              _CycleManager._get_cycles_by_frequency_and_overlapping_date(                  Frequency.WEEKLY, datetime(2000, 1, 1, 1, 0, 0, 0), cycles              )          )          == 0      ) "}
{"text": "from datetime import datetime    from src.taipy.core._orchestrator._orchestrator_factory import _OrchestratorFactory  from src.taipy.core.config.job_config import JobConfig  from src.taipy.core.cycle._cycle_manager import _CycleManager  from src.taipy.core.cycle._cycle_manager_factory import _CycleManagerFactory  from src.taipy.core.cycle.cycle import Cycle  from src.taipy.core.cycle.cycle_id import CycleId  from src.taipy.core.data._data_manager import _DataManager  from src.taipy.core.job._job_manager import _JobManager  from src.taipy.core.scenario._scenario_manager import _ScenarioManager  from src.taipy.core.scenario._scenario_manager_factory import _ScenarioManagerFactory  from src.taipy.core.sequence._sequence_manager import _SequenceManager  from src.taipy.core.task._task_manager import _TaskManager  from taipy.config.common.frequency import Frequency  from taipy.config.common.scope import Scope  from taipy.config.config import Config      def test_save_and_get_cycle_entity(init_sql_repo, cycle, current_datetime):      _CycleManager._repository = _CycleManagerFactory._build_repository()        _CycleManager._delete_all()      assert len(_CycleManager._get_all()) == 0        _CycleManager._set(cycle)      assert _CycleManager._exists(cycle.id)        cycle_1 = _CycleManager._get(cycle.id)        assert cycle_1.id == cycle.id      assert cycle_1.name == cycle.name      assert cycle_1.properties == cycle.properties      assert cycle_1.creation_date == cycle.creation_date      assert cycle_1.start_date == cycle.start_date      assert cycle_1.end_date == cycle.end_date      assert cycle_1.frequency == cycle.frequency        assert len(_CycleManager._get_all()) == 1      assert _CycleManager._get(cycle.id) == cycle      assert _CycleManager._get(cycle.id).name == cycle.name      assert isinstance(_CycleManager._get(cycle.id).creation_date, datetime)      assert _CycleManager._get(cycle.id).creation_date == cycle.creation_date      assert _CycleManager._get(cycle.id).frequency == Frequency.DAILY        cycle_2_id = CycleId(\"cycle_2\")      assert _CycleManager._get(cycle_2_id) is None      assert not _CycleManager._exists(cycle_2_id)        cycle_3 = Cycle(          Frequency.MONTHLY,          {},          creation_date=current_datetime,          start_date=current_datetime,          end_date=current_datetime,          name=\"bar\",          id=cycle_1.id,      )        _CycleManager._set(cycle_3)        cycle_3 = _CycleManager._get(cycle_1.id)        assert _CycleManager._exists(cycle_1.id)      assert len(_CycleManager._get_all()) == 1      assert cycle_3.id == cycle_1.id      assert cycle_3.name == cycle_3.name      assert cycle_3.properties == cycle_3.properties      assert cycle_3.creation_date == current_datetime      assert cycle_3.start_date == current_datetime      assert cycle_3.end_date == current_datetime      assert cycle_3.frequency == cycle_3.frequency      def test_create_and_delete_cycle_entity(init_sql_repo):      _CycleManager._repository = _CycleManagerFactory._build_repository()        _CycleManager._delete_all()      assert len(_CycleManager._get_all()) == 0        cycle_1 = _CycleManager._create(Frequency.DAILY, name=\"foo\", key=\"value\", display_name=\"foo\")        assert cycle_1.id is not None      assert cycle_1.name == \"foo\"      assert cycle_1.properties == {\"key\": \"value\", \"display_name\": \"foo\"}      assert cycle_1.creation_date is not None      assert cycle_1.start_date is not None      assert cycle_1.end_date is not None      assert cycle_1.start_date < cycle_1.creation_date < cycle_1.end_date      assert cycle_1.key == \"value\"      assert cycle_1.frequency == Frequency.DAILY        cycle_1_id = cycle_1.id        assert _CycleManager._exists(cycle_1.id)      assert len(_CycleManager._get_all()) == 1      assert _CycleManager._get(cycle_1_id) == cycle_1      assert _CycleManager._get(cycle_1_id).name == \"foo\"      assert isinstance(_CycleManager._get(cycle_1_id).creation_date, datetime)      assert _CycleManager._get(cycle_1_id).frequency == Frequency.DAILY        cycle_2_id = CycleId(\"cycle_2\")      assert _CycleManager._get(cycle_2_id) is None      assert not _CycleManager._exists(cycle_2_id)        cycle_3 = _CycleManager._create(Frequency.MONTHLY, \"bar\")        assert cycle_3.id is not None      assert cycle_3.name == \"bar\"      assert isinstance(cycle_3.creation_date, datetime)      assert cycle_3.frequency == Frequency.MONTHLY        cycle_3_id = cycle_3.id        assert _CycleManager._exists(cycle_3_id)      assert len(_CycleManager._get_all()) == 2      assert _CycleManager._get(cycle_3_id).name == \"bar\"        cycle_4 = _CycleManager._create(Frequency.YEARLY, \"baz\")      cycle_4_id = cycle_4.id        assert _CycleManager._exists(cycle_4_id)      assert len(_CycleManager._get_all()) == 3        _CycleManager._delete(cycle_4_id)        assert len(_CycleManager._get_all()) == 2      assert not _CycleManager._exists(cycle_4_id)      assert _CycleManager._get(cycle_4_id) is None        _CycleManager._delete_all()      assert len(_CycleManager._get_all()) == 0      assert not any(_CycleManager._exists(cycle_id) for cycle_id in [cycle_1_id, cycle_3_id, cycle_4_id])      def test_get_cycle_start_date_and_end_date(init_sql_repo):      _CycleManager._repository = _CycleManagerFactory._build_repository()        _CycleManager._delete_all()        creation_date_1 = datetime.fromisoformat(\"2021-11-11T11:11:01.000001\")        daily_start_date_1 = _CycleManager._get_start_date_of_cycle(Frequency.DAILY, creation_date=creation_date_1)      weekly_start_date_1 = _CycleManager._get_start_date_of_cycle(Frequency.WEEKLY, creation_date=creation_date_1)      monthly_start_date_1 = _CycleManager._get_start_date_of_cycle(Frequency.MONTHLY, creation_date=creation_date_1)      yearly_start_date_1 = _CycleManager._get_start_date_of_cycle(Frequency.YEARLY, creation_date=creation_date_1)        assert daily_start_date_1 == datetime.fromisoformat(\"2021-11-11T00:00:00.000000\")      assert weekly_start_date_1 == datetime.fromisoformat(\"2021-11-08T00:00:00.000000\")      assert monthly_start_date_1 == datetime.fromisoformat(\"2021-11-01T00:00:00.000000\")      assert yearly_start_date_1 == datetime.fromisoformat(\"2021-01-01T00:00:00.000000\")        daily_end_date_1 = _CycleManager._get_end_date_of_cycle(Frequency.DAILY, start_date=daily_start_date_1)      weekly_end_date_1 = _CycleManager._get_end_date_of_cycle(Frequency.WEEKLY, start_date=weekly_start_date_1)      monthly_end_date_1 = _CycleManager._get_end_date_of_cycle(Frequency.MONTHLY, start_date=monthly_start_date_1)      yearly_end_date_1 = _CycleManager._get_end_date_of_cycle(Frequency.YEARLY, start_date=yearly_start_date_1)        assert daily_end_date_1 == datetime.fromisoformat(\"2021-11-11T23:59:59.999999\")      assert weekly_end_date_1 == datetime.fromisoformat(\"2021-11-14T23:59:59.999999\")      assert monthly_end_date_1 == datetime.fromisoformat(\"2021-11-30T23:59:59.999999\")      assert yearly_end_date_1 == datetime.fromisoformat(\"2021-12-31T23:59:59.999999\")        creation_date_2 = datetime.now()        daily_start_date_2 = _CycleManager._get_start_date_of_cycle(Frequency.DAILY, creation_date=creation_date_2)      daily_end_date_2 = _CycleManager._get_end_date_of_cycle(Frequency.DAILY, daily_start_date_2)      assert daily_start_date_2.date() == creation_date_2.date()      assert daily_end_date_2.date() == creation_date_2.date()      assert daily_start_date_2 < creation_date_2 < daily_end_date_2        weekly_start_date_2 = _CycleManager._get_start_date_of_cycle(Frequency.WEEKLY, creation_date=creation_date_2)      weekly_end_date_2 = _CycleManager._get_end_date_of_cycle(Frequency.WEEKLY, weekly_start_date_2)      assert weekly_start_date_2 < creation_date_2 < weekly_end_date_2        monthly_start_date_2 = _CycleManager._get_start_date_of_cycle(Frequency.MONTHLY, creation_date=creation_date_2)      monthly_end_date_2 = _CycleManager._get_end_date_of_cycle(Frequency.MONTHLY, monthly_start_date_2)      assert monthly_start_date_2.month == creation_date_2.month and monthly_start_date_2.day == 1      assert monthly_end_date_2.month == creation_date_2.month      assert monthly_start_date_2 < creation_date_2 < monthly_end_date_2        yearly_start_date_2 = _CycleManager._get_start_date_of_cycle(Frequency.YEARLY, creation_date=creation_date_2)      yearly_end_date_2 = _CycleManager._get_end_date_of_cycle(Frequency.YEARLY, yearly_start_date_2)      assert yearly_start_date_2.year == creation_date_2.year      assert yearly_start_date_2 == datetime(creation_date_2.year, 1, 1)      assert yearly_end_date_2.year == creation_date_2.year      assert yearly_end_date_2.date() == datetime(creation_date_2.year, 12, 31).date()      assert yearly_start_date_2 < creation_date_2 < yearly_end_date_2      def test_hard_delete_shared_entities(init_sql_repo):      Config.configure_job_executions(mode=JobConfig._DEVELOPMENT_MODE)      _ScenarioManager._repository = _ScenarioManagerFactory._build_repository()        dn_config_1 = Config.configure_data_node(\"my_input_1\", \"in_memory\", scope=Scope.SCENARIO, default_data=\"testing\")      dn_config_2 = Config.configure_data_node(\"my_input_2\", \"in_memory\", scope=Scope.SCENARIO, default_data=\"testing\")      dn_config_3 = Config.configure_data_node(\"my_input_3\", \"in_memory\", scope=Scope.CYCLE, default_data=\"testing\")      dn_config_4 = Config.configure_data_node(\"my_input_4\", \"in_memory\", scope=Scope.GLOBAL, default_data=\"testing\")      task_config_1 = Config.configure_task(\"task_config_1\", print, dn_config_1, dn_config_2)      task_config_2 = Config.configure_task(\"task_config_2\", print, dn_config_2, dn_config_3)      task_config_3 = Config.configure_task(\"task_config_3\", print, dn_config_3, dn_config_4)  # scope = global      creation_date = datetime.now()      scenario_config_1 = Config.configure_scenario(          \"scenario_config_1\",          [task_config_1, task_config_2, task_config_3],          creation_date=creation_date,          frequency=Frequency.DAILY,      )      scenario_config_1.add_sequences(          {              \"sequence_1\": [task_config_1, task_config_2],              \"sequence_2\": [task_config_1, task_config_2],              \"sequence_3\": [task_config_3],          }      )      scenario_config_2 = Config.configure_scenario(          \"scenario_config_2\", [task_config_2, task_config_3]      )  # No Frequency so cycle attached to scenarios      scenario_config_2.add_sequences({\"sequence_3\": [task_config_3]})        _OrchestratorFactory._build_dispatcher()        scenario_1 = _ScenarioManager._create(scenario_config_1)      scenario_2 = _ScenarioManager._create(scenario_config_1)      scenario_3 = _ScenarioManager._create(scenario_config_2)      scenario_1.submit()      scenario_2.submit()      scenario_3.submit()        assert len(_ScenarioManager._get_all()) == 3      assert len(_SequenceManager._get_all()) == 7      assert len(_TaskManager._get_all()) == 7      assert len(_DataManager._get_all()) == 8      assert len(_JobManager._get_all()) == 8      assert len(_CycleManager._get_all()) == 1      _CycleManager._hard_delete(scenario_1.cycle.id)      assert len(_CycleManager._get_all()) == 0      assert len(_ScenarioManager._get_all()) == 1      assert len(_SequenceManager._get_all()) == 1      assert len(_TaskManager._get_all()) == 2      assert len(_JobManager._get_all()) == 2      assert len(_DataManager._get_all()) == 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 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": "#  # Licensed under the Apache License, Version 2.0 (the \"License\"); you may not use this file except in compliance with  # the License. You may obtain a copy of the License at  #  #        http://www.apache.org/licenses/LICENSE-2.0  #  # Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on  # an \"AS IS\" BASIS, WITHOUT 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 List    from src.taipy.core import DataNode, Sequence, SequenceId, Task, TaskId  from src.taipy.core._entity._dag import _DAG  from taipy.config.common.scope import Scope      def assert_x(x: int, *nodes):      for node in nodes:          assert node.x == x      def assert_y(y: List[int], *nodes):      for node in nodes:          assert node.y in y          y.remove(node.y)      def assert_x_y(x: int, y: List[int], *nodes):      assert_x(x, *nodes)      for node in nodes:          assert node.y in y          y.remove(node.y)      def assert_edge_exists(src, dest, dag: _DAG):      list_of_tuples = [(edge.src.entity.id, edge.dest.entity.id) for edge in dag.edges]      assert (src, dest) in list_of_tuples      class TestDAG:      def test_get_dag_1(self):          data_node_1 = DataNode(\"foo\", Scope.SCENARIO, \"s1\")          data_node_2 = DataNode(\"bar\", Scope.SCENARIO, \"s2\")          data_node_3 = DataNode(\"baz\", Scope.SCENARIO, \"s3\")          data_node_4 = DataNode(\"qux\", Scope.SCENARIO, \"s4\")          data_node_5 = DataNode(\"quux\", Scope.SCENARIO, \"s5\")          data_node_6 = DataNode(\"quuz\", Scope.SCENARIO, \"s6\")          data_node_7 = DataNode(\"corge\", Scope.SCENARIO, \"s7\")          task_1 = Task(\"grault\", {}, print, [data_node_1, data_node_2], [data_node_3, data_node_4], TaskId(\"t1\"))          task_2 = Task(\"garply\", {}, print, [data_node_3], [data_node_5], TaskId(\"t2\"))          task_3 = Task(\"waldo\", {}, print, [data_node_5, data_node_4], [data_node_6], TaskId(\"t3\"))          task_4 = Task(\"fred\", {}, print, [data_node_4], [data_node_7], TaskId(\"t4\"))          sequence = Sequence({}, [task_4, task_2, task_1, task_3], SequenceId(\"p1\"))            dag = sequence._get_dag()          # s1 ---             ---> s3 ---> t2 ---> s5 ----          #       |           |                           |          #       |---> t1 ---|      -------------------------> t3 ---> s6          #       |           |      |          # s2 ---             ---> s4 ---> t4 ---> s7            assert dag.length == 7          assert dag.width == 2          assert dag._grid_length == 7          assert dag._grid_width == 3          assert len(dag.nodes) == 11          assert_x_y(0, [0, 2], dag.nodes[\"s1\"], dag.nodes[\"s2\"])          assert_x_y(1, [1], dag.nodes[\"t1\"])          assert_x_y(2, [0, 2], dag.nodes[\"s3\"], dag.nodes[\"s4\"])          assert_x_y(3, [0, 2], dag.nodes[\"t2\"], dag.nodes[\"t4\"])          assert_x_y(4, [0, 2], dag.nodes[\"s5\"], dag.nodes[\"s7\"])          assert_x_y(5, [1], dag.nodes[\"t3\"])          assert_x_y(6, [1], dag.nodes[\"s6\"])          assert len(dag.edges) == 11          assert_edge_exists(\"s1\", \"t1\", dag)          assert_edge_exists(\"s2\", \"t1\", dag)          assert_edge_exists(\"t1\", \"s3\", dag)          assert_edge_exists(\"t1\", \"s4\", dag)          assert_edge_exists(\"s3\", \"t2\", dag)          assert_edge_exists(\"t2\", \"s5\", dag)          assert_edge_exists(\"s5\", \"t3\", dag)          assert_edge_exists(\"s4\", \"t3\", dag)          assert_edge_exists(\"t3\", \"s6\", dag)          assert_edge_exists(\"s4\", \"t4\", dag)          assert_edge_exists(\"t4\", \"s7\", dag)        def test_get_dag_2(self):          data_node_1 = DataNode(\"foo\", Scope.SCENARIO, \"s1\")          data_node_2 = DataNode(\"bar\", Scope.SCENARIO, \"s2\")          data_node_4 = DataNode(\"qux\", Scope.SCENARIO, \"s4\")          data_node_5 = DataNode(\"quux\", Scope.SCENARIO, \"s5\")          data_node_6 = DataNode(\"quuz\", Scope.SCENARIO, \"s6\")          data_node_7 = DataNode(\"corge\", Scope.SCENARIO, \"s7\")          task_1 = Task(\"grault\", {}, print, [data_node_1, data_node_2], [data_node_4], TaskId(\"t1\"))          task_2 = Task(\"garply\", {}, print, None, [data_node_5], TaskId(\"t2\"))          task_3 = Task(\"waldo\", {}, print, [data_node_5, data_node_4], [data_node_6], TaskId(\"t3\"))          task_4 = Task(\"fred\", {}, print, [data_node_4], [data_node_7], TaskId(\"t4\"))          sequence = Sequence({}, [task_4, task_2, task_1, task_3], SequenceId(\"p1\"))            #  6  |   t2 _____          #  5  |           \\          #  4  |            s5 _________________ t3 _______ s6          #  3  |   s1 __            _ s4 _____/          #  2  |        \\ _ t1 ____/          \\_ t4 _______ s7          #  1  |        /          #  0  |   s2 --          #     |________________________________________________          #         0        1         2          3          4            dag = sequence._get_dag()            assert dag.length == 5          assert dag.width == 3          assert dag._grid_length == 5          assert dag._grid_width == 7          assert len(dag.nodes) == 10          assert_x_y(0, [0, 3, 6], dag.nodes[\"s1\"], dag.nodes[\"s2\"], dag.nodes[\"t2\"])          assert_x_y(1, [2, 4], dag.nodes[\"t1\"], dag.nodes[\"s5\"])          assert_x_y(2, [3], dag.nodes[\"s4\"])          assert_x_y(3, [2, 4], dag.nodes[\"t3\"], dag.nodes[\"t4\"])          assert_x_y(4, [2, 4], dag.nodes[\"s6\"], dag.nodes[\"s7\"])          assert len(dag.edges) == 9          assert_edge_exists(\"s1\", \"t1\", dag)          assert_edge_exists(\"s2\", \"t1\", dag)          assert_edge_exists(\"t1\", \"s4\", dag)          assert_edge_exists(\"t2\", \"s5\", dag)          assert_edge_exists(\"s5\", \"t3\", dag)          assert_edge_exists(\"s4\", \"t3\", dag)          assert_edge_exists(\"t3\", \"s6\", dag)          assert_edge_exists(\"s4\", \"t4\", dag)          assert_edge_exists(\"t4\", \"s7\", dag)        def test_get_dag_3(self):          data_node_1 = DataNode(\"foo\", Scope.SCENARIO, \"s1\")          data_node_2 = DataNode(\"bar\", Scope.SCENARIO, \"s2\")          data_node_3 = DataNode(\"quuz\", Scope.SCENARIO, \"s3\")          data_node_4 = DataNode(\"qux\", Scope.SCENARIO, \"s4\")          data_node_5 = DataNode(\"quux\", Scope.SCENARIO, \"s5\")          data_node_6 = DataNode(\"corge\", Scope.SCENARIO, \"s6\")          data_node_7 = DataNode(\"hugh\", Scope.SCENARIO, \"s7\")            task_1 = Task(\"grault\", {}, print, [data_node_1, data_node_2, data_node_3], [data_node_4], TaskId(\"t1\"))          task_2 = Task(\"waldo\", {}, print, [data_node_4], None, id=TaskId(\"t2\"))          task_3 = Task(\"fred\", {}, print, [data_node_4], [data_node_5], TaskId(\"t3\"))          task_4 = Task(\"garply\", {}, print, output=[data_node_6], id=TaskId(\"t4\"))          task_5 = Task(\"bob\", {}, print, [data_node_7], None, TaskId(\"t5\"))          sequence = Sequence({}, [task_5, task_3, task_4, task_1, task_2], SequenceId(\"p1\"))            #  12 |  s7 __          #  11 |       \\          #  10 |        \\          #  9  |  t4 _   \\_ t5          #  8  |      \\                     ____ t3 ___          #  7  |       \\                   /           \\          #  6  |  s3 _  \\__ s6      _ s4 _/             \\___ s5          #  5  |      \\            /      \\          #  4  |       \\          /        \\____ t2          #  3  |  s2 ___\\__ t1 __/          #  2  |        /          #  1  |       /          #  0  |  s1 _/          #     |________________________________________________          #         0         1         2          3          4          dag = sequence._get_dag()            assert dag.length == 5          assert dag.width == 5          assert dag._grid_length == 5          assert dag._grid_width == 13          assert len(dag.nodes) == 12            assert_x_y(              0, [0, 3, 6, 9, 12], dag.nodes[\"s1\"], dag.nodes[\"s2\"], dag.nodes[\"s3\"], dag.nodes[\"s7\"], dag.nodes[\"t4\"]          )          assert_x_y(1, [3, 6, 9], dag.nodes[\"t1\"], dag.nodes[\"t5\"], dag.nodes[\"s6\"])          assert_x_y(2, [6], dag.nodes[\"s4\"])          assert_x_y(3, [4, 8], dag.nodes[\"t2\"], dag.nodes[\"t3\"])          assert_x_y(4, [6], dag.nodes[\"s5\"])          assert len(dag.edges) == 9          assert_edge_exists(\"s1\", \"t1\", dag)          assert_edge_exists(\"s2\", \"t1\", dag)          assert_edge_exists(\"s3\", \"t1\", dag)          assert_edge_exists(\"t1\", \"s4\", dag)          assert_edge_exists(\"s4\", \"t2\", dag)          assert_edge_exists(\"s4\", \"t3\", dag)          assert_edge_exists(\"t3\", \"s5\", dag)          assert_edge_exists(\"t4\", \"s6\", dag)          assert_edge_exists(\"s7\", \"t5\", dag)        def test_get_dag_4(self):          data_node_1 = DataNode(\"foo\", Scope.SCENARIO, \"s1\")          data_node_2 = DataNode(\"bar\", Scope.SCENARIO, \"s2\")          data_node_3 = DataNode(\"quuz\", Scope.SCENARIO, \"s3\")          data_node_4 = DataNode(\"qux\", Scope.SCENARIO, \"s4\")          data_node_5 = DataNode(\"quux\", Scope.SCENARIO, \"s5\")          data_node_6 = DataNode(\"corge\", Scope.SCENARIO, \"s6\")            task_1 = Task(\"grault\", {}, print, [data_node_1, data_node_2, data_node_3], [data_node_4], TaskId(\"t1\"))          task_2 = Task(\"waldo\", {}, print, [data_node_4], None, id=TaskId(\"t2\"))          task_3 = Task(\"fred\", {}, print, [data_node_4], [data_node_5], TaskId(\"t3\"))          task_4 = Task(\"garply\", {}, print, output=[data_node_6], id=TaskId(\"t4\"))          sequence = Sequence({}, [task_3, task_4, task_1, task_2], SequenceId(\"p1\"))            #  6  |  t4 __          #  5  |       \\          #  4  |  s3 _  \\__ s6            ______ t3 ___          #  3  |      \\          ___ s4 _/             \\___ s5          #  2  |  s2 __\\__ t1 __/        \\______ t2          #  1  |       /          #  0  |  s1 _/          #     |________________________________________________          #         0         1         2          3          4          dag = sequence._get_dag()            assert dag.length == 5          assert dag.width == 4          assert dag._grid_length == 5          assert dag._grid_width == 7          assert len(dag.nodes) == 10            assert_x_y(0, [0, 2, 4, 6], dag.nodes[\"s1\"], dag.nodes[\"s2\"], dag.nodes[\"s3\"], dag.nodes[\"t4\"])          assert_x_y(1, [2, 4], dag.nodes[\"t1\"], dag.nodes[\"s6\"])          assert_x_y(2, [3], dag.nodes[\"s4\"])          assert_x_y(3, [2, 4], dag.nodes[\"t2\"], dag.nodes[\"t3\"])          assert_x_y(4, [3], dag.nodes[\"s5\"])          assert len(dag.edges) == 8          assert_edge_exists(\"s1\", \"t1\", dag)          assert_edge_exists(\"s2\", \"t1\", dag)          assert_edge_exists(\"s3\", \"t1\", dag)          assert_edge_exists(\"t1\", \"s4\", dag)          assert_edge_exists(\"s4\", \"t2\", dag)          assert_edge_exists(\"s4\", \"t3\", dag)          assert_edge_exists(\"t3\", \"s5\", dag)          assert_edge_exists(\"t4\", \"s6\", dag)        def test_get_dag_5(self):          data_node_1 = DataNode(\"foo\", Scope.SCENARIO, \"s1\")          data_node_2 = DataNode(\"bar\", Scope.SCENARIO, \"s2\")          task_1 = Task(\"baz\", {}, print, [data_node_1], [data_node_2], TaskId(\"t1\"))          sequence = Sequence({}, [task_1], SequenceId(\"p1\"))            #  1  |          #  0  |  s1 __ t1 __ s2          #     |_________________          #         0    1     2          dag = sequence._get_dag()            assert dag.length == 3          assert dag.width == 1          assert dag._grid_length == 3          assert dag._grid_width == 1          assert len(dag.nodes) == 3            assert_x_y(0, [0], dag.nodes[\"s1\"])          assert_x_y(1, [0], dag.nodes[\"t1\"])          assert_x_y(2, [0], dag.nodes[\"s2\"])          assert len(dag.edges) == 2          assert_edge_exists(\"s1\", \"t1\", dag)          assert_edge_exists(\"t1\", \"s2\", dag)        def test_get_dag_6(self):          data_node_1 = DataNode(\"foo\", Scope.SCENARIO, \"s1\")          data_node_2 = DataNode(\"bar\", Scope.SCENARIO, \"s2\")          data_node_3 = DataNode(\"baz\", Scope.SCENARIO, \"s3\")          data_node_4 = DataNode(\"qux\", Scope.SCENARIO, \"s4\")          task_1 = Task(\"quux\", {}, print, [data_node_1, data_node_2], [data_node_3], TaskId(\"t1\"))          task_2 = Task(\"quuz\", {}, print, [data_node_2], [data_node_4], TaskId(\"t2\"))          sequence = Sequence({}, [task_1, task_2], SequenceId(\"p1\"))            #  2  |          #     |          #  1  |  s1 ___ t1 __ s3          #     |      /          #  0  |  s2 /__ t2 __ s4          #     |_________________          #         0     1     2          dag = sequence._get_dag()            assert dag.length == 3          assert dag.width == 2          assert dag._grid_length == 3          assert dag._grid_width == 2          assert len(dag.nodes) == 6            assert_x_y(0, [0, 1], dag.nodes[\"s1\"], dag.nodes[\"s2\"])          assert_x_y(1, [0, 1], dag.nodes[\"t1\"], dag.nodes[\"t2\"])          assert_x_y(2, [0, 1], dag.nodes[\"s3\"], dag.nodes[\"s4\"])          assert len(dag.edges) == 5          assert_edge_exists(\"s1\", \"t1\", dag)          assert_edge_exists(\"s2\", \"t1\", dag)          assert_edge_exists(\"t1\", \"s3\", dag)          assert_edge_exists(\"s2\", \"t2\", dag)          assert_edge_exists(\"t2\", \"s4\", dag) "}
{"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 filecmp  import os  import shutil  import sys  from unittest.mock import patch    import mongomock  import pytest    from src.taipy.core._entity._migrate_cli import _MigrateCLI      @pytest.fixture(scope=\"function\", autouse=True)  def clean_data_folder():      if os.path.exists(\"tests/core/_entity/.data\"):          shutil.rmtree(\"tests/core/_entity/.data\")      yield      def test_migrate_fs_default(caplog):      _MigrateCLI.create_parser()        # Test migrate with default .data folder      with pytest.raises(SystemExit):          with patch(\"sys.argv\", [\"prog\", \"migrate\", \"--repository-type\", \"filesystem\", \"--skip-backup\"]):              _MigrateCLI.parse_arguments()      assert \"Starting entity migration from '.data' folder\" in caplog.text      def test_migrate_fs_specified_folder(caplog):      _MigrateCLI.create_parser()        # Copy data_sample to .data folder for testing      data_sample_path = \"tests/core/_entity/data_sample\"      data_path = \"tests/core/_entity/.data\"      shutil.copytree(data_sample_path, data_path)        # Run with --skip-backup to only test the migration      with pytest.raises(SystemExit):          with patch(\"sys.argv\", [\"prog\", \"migrate\", \"--repository-type\", \"filesystem\", data_path, \"--skip-backup\"]):              _MigrateCLI.parse_arguments()      assert f\"Starting entity migration from '{data_path}' folder\" in caplog.text        # Compare migrated .data folder with data_sample_migrated      dircmp_result = filecmp.dircmp(data_path, \"tests/core/_entity/data_sample_migrated\")      assert not dircmp_result.diff_files and not dircmp_result.left_only and not dircmp_result.right_only      for subdir in dircmp_result.subdirs.values():          assert not subdir.diff_files and not subdir.left_only and not subdir.right_only      def test_migrate_fs_backup_and_remove(caplog):      _MigrateCLI.create_parser()        # Copy data_sample to .data folder for testing      data_sample_path = \"tests/core/_entity/data_sample\"      data_path = \"tests/core/_entity/.data\"      backup_path = \"tests/core/_entity/.data_backup\"      shutil.copytree(data_sample_path, data_path)        # Remove backup when it does not exist should raise an error      with pytest.raises(SystemExit) as err:          with patch(\"sys.argv\", [\"prog\", \"migrate\", \"--repository-type\", \"filesystem\", data_path, \"--remove-backup\"]):              _MigrateCLI.parse_arguments()      assert err.value.code == 1      assert f\"The backup folder '{backup_path}' does not exist.\" in caplog.text      assert not os.path.exists(backup_path)        # Run without --skip-backup to create the backup folder      with pytest.raises(SystemExit):          with patch(\"sys.argv\", [\"prog\", \"migrate\", \"--repository-type\", \"filesystem\", data_path]):              _MigrateCLI.parse_arguments()      assert f\"Backed up entities from '{data_path}' to '{backup_path}' folder before migration.\" in caplog.text        assert os.path.exists(backup_path)        # Remove backup      with pytest.raises(SystemExit):          with patch(\"sys.argv\", [\"prog\", \"migrate\", \"--repository-type\", \"filesystem\", data_path, \"--remove-backup\"]):              _MigrateCLI.parse_arguments()      assert f\"Removed backup entities from the backup folder '{backup_path}'.\" in caplog.text      assert not os.path.exists(backup_path)      def test_migrate_fs_backup_and_restore(caplog):      _MigrateCLI.create_parser()        # Copy data_sample to .data folder for testing      data_sample_path = \"tests/core/_entity/data_sample\"      data_path = \"tests/core/_entity/.data\"      backup_path = \"tests/core/_entity/.data_backup\"      shutil.copytree(data_sample_path, data_path)        # Restore backup when it does not exist should raise an error      with pytest.raises(SystemExit) as err:          with patch(\"sys.argv\", [\"prog\", \"migrate\", \"--repository-type\", \"filesystem\", data_path, \"--restore\"]):              _MigrateCLI.parse_arguments()      assert err.value.code == 1      assert f\"The backup folder '{backup_path}' does not exist.\" in caplog.text      assert not os.path.exists(backup_path)        # Run without --skip-backup to create the backup folder      with pytest.raises(SystemExit):          with patch(\"sys.argv\", [\"prog\", \"migrate\", \"--repository-type\", \"filesystem\", data_path]):              _MigrateCLI.parse_arguments()        assert os.path.exists(backup_path)        # restore the backup      with pytest.raises(SystemExit):          with patch(\"sys.argv\", [\"prog\", \"migrate\", \"--repository-type\", \"filesystem\", data_path, \"--restore\"]):              _MigrateCLI.parse_arguments()      assert f\"Restored entities from the backup folder '{backup_path}' to '{data_path}'.\" in caplog.text      assert not os.path.exists(backup_path)        # Compare migrated .data folder with data_sample to ensure restoreing the backup worked      dircmp_result = filecmp.dircmp(data_path, \"tests/core/_entity/data_sample\")      assert not dircmp_result.diff_files and not dircmp_result.left_only and not dircmp_result.right_only      for subdir in dircmp_result.subdirs.values():          assert not subdir.diff_files and not subdir.left_only and not subdir.right_only      def test_migrate_fs_non_existing_folder(caplog):      _MigrateCLI.create_parser()        # Test migrate with a non-existing folder      with pytest.raises(SystemExit) as err:          with patch(\"sys.argv\", [\"prog\", \"migrate\", \"--repository-type\", \"filesystem\", \"non-existing-folder\"]):              _MigrateCLI.parse_arguments()      assert err.value.code == 1      assert \"Folder 'non-existing-folder' does not exist.\" in caplog.text      @patch(\"src.taipy.core._entity._migrate_cli._migrate_sql_entities\")  def test_migrate_sql_specified_path(_migrate_sql_entities_mock, tmp_sqlite):      _MigrateCLI.create_parser()        # Test the _migrate_sql_entities is called once with the correct path      with pytest.raises(SystemExit):          with patch(\"sys.argv\", [\"prog\", \"migrate\", \"--repository-type\", \"sql\", tmp_sqlite, \"--skip-backup\"]):              _MigrateCLI.parse_arguments()              assert _migrate_sql_entities_mock.assert_called_once_with(path=tmp_sqlite)      def test_migrate_sql_backup_and_remove(caplog, tmp_sqlite):      _MigrateCLI.create_parser()        # Create the .sqlite file to test      with open(tmp_sqlite, \"w\") as f:          f.write(\"\")        file_name, file_extension = tmp_sqlite.rsplit(\".\", 1)      backup_sqlite = f\"{file_name}_backup.{file_extension}\"        # Remove backup when it does not exist should raise an error      with pytest.raises(SystemExit) as err:          with patch(\"sys.argv\", [\"prog\", \"migrate\", \"--repository-type\", \"sql\", tmp_sqlite, \"--remove-backup\"]):              _MigrateCLI.parse_arguments()      assert err.value.code == 1      assert f\"The backup database '{backup_sqlite}' does not exist.\" in caplog.text      assert not os.path.exists(backup_sqlite)        # Run without --skip-backup to create the backup database      with pytest.raises(Exception):          with patch(\"sys.argv\", [\"prog\", \"migrate\", \"--repository-type\", \"sql\", tmp_sqlite]):              _MigrateCLI.parse_arguments()        assert os.path.exists(backup_sqlite)        # Remove backup      with pytest.raises(SystemExit):          with patch(\"sys.argv\", [\"prog\", \"migrate\", \"--repository-type\", \"sql\", tmp_sqlite, \"--remove-backup\"]):              _MigrateCLI.parse_arguments()      assert f\"Removed backup entities from the backup database '{backup_sqlite}'.\" in caplog.text      assert not os.path.exists(backup_sqlite)      @pytest.mark.skipif(sys.platform == \"win32\", reason=\"Does not run on windows due to PermissionError: [WinError 32]\")  def test_migrate_sql_backup_and_restore(caplog, tmp_sqlite):      _MigrateCLI.create_parser()        # Create the .sqlite file to test      with open(tmp_sqlite, \"w\") as f:          f.write(\"\")        file_name, file_extension = tmp_sqlite.rsplit(\".\", 1)      backup_sqlite = f\"{file_name}_backup.{file_extension}\"        # Restore backup when it does not exist should raise an error      with pytest.raises(SystemExit) as err:          with patch(\"sys.argv\", [\"prog\", \"migrate\", \"--repository-type\", \"sql\", tmp_sqlite, \"--restore\"]):              _MigrateCLI.parse_arguments()      assert err.value.code == 1      assert f\"The backup database '{backup_sqlite}' does not exist.\" in caplog.text      assert not os.path.exists(backup_sqlite)        # Run without --skip-backup to create the backup database      with pytest.raises(Exception):          with patch(\"sys.argv\", [\"prog\", \"migrate\", \"--repository-type\", \"sql\", tmp_sqlite]):              _MigrateCLI.parse_arguments()        assert os.path.exists(backup_sqlite)        # Restore the backup      with pytest.raises(SystemExit):          with patch(\"sys.argv\", [\"prog\", \"migrate\", \"--repository-type\", \"sql\", tmp_sqlite, \"--restore\"]):              _MigrateCLI.parse_arguments()      assert f\"Restored entities from the backup database '{backup_sqlite}' to '{tmp_sqlite}'.\" in caplog.text      assert not os.path.exists(backup_sqlite)      def test_migrate_sql_non_existing_path(caplog):      _MigrateCLI.create_parser()        # Test migrate without providing a path      with pytest.raises(SystemExit) as err:          with patch(\"sys.argv\", [\"prog\", \"migrate\", \"--repository-type\", \"sql\"]):              _MigrateCLI.parse_arguments()        assert err.value.code == 1      assert \"Missing the required sqlite path.\" in caplog.text        caplog.clear()        # Test migrate with a non-existing-path.sqlite file      with pytest.raises(SystemExit) as err:          with patch(\"sys.argv\", [\"prog\", \"migrate\", \"--repository-type\", \"sql\", \"non-existing-path.sqlite\"]):              _MigrateCLI.parse_arguments()      assert err.value.code == 1      assert \"File 'non-existing-path.sqlite' does not exist.\" in caplog.text      @patch(\"src.taipy.core._entity._migrate_cli._migrate_mongo_entities\")  def test_call_to_migrate_mongo(_migrate_mongo_entities_mock):      _MigrateCLI.create_parser()        with pytest.raises(SystemExit):          with patch(\"sys.argv\", [\"prog\", \"migrate\", \"--repository-type\", \"mongo\"]):              _MigrateCLI.parse_arguments()              assert _migrate_mongo_entities_mock.assert_called_once_with()        with pytest.raises(SystemExit):          with patch(\"sys.argv\", [\"prog\", \"migrate\", \"--repository-type\", \"mongo\", \"host\", \"port\", \"user\", \"password\"]):              _MigrateCLI.parse_arguments()              assert _migrate_mongo_entities_mock.assert_called_once_with(\"host\", \"port\", \"user\", \"password\")      @mongomock.patch(servers=((\"localhost\", 27017),))  def test_migrate_mongo_backup_and_remove(caplog):      _MigrateCLI.create_parser()        mongo_backup_path = \".mongo_backup\"        # Remove backup when it does not exist should raise an error      with pytest.raises(SystemExit) as err:          with patch(\"sys.argv\", [\"prog\", \"migrate\", \"--repository-type\", \"mongo\", \"--remove-backup\"]):              _MigrateCLI.parse_arguments()      assert err.value.code == 1      assert f\"The backup folder '{mongo_backup_path}' does not exist.\" in caplog.text      assert not os.path.exists(mongo_backup_path)        # Run without --skip-backup to create the backup database      with pytest.raises(Exception):          with patch(\"sys.argv\", [\"prog\", \"migrate\", \"--repository-type\", \"mongo\"]):              _MigrateCLI.parse_arguments()        assert os.path.exists(mongo_backup_path)        # Remove backup      with pytest.raises(SystemExit):          with patch(\"sys.argv\", [\"prog\", \"migrate\", \"--repository-type\", \"mongo\", \"--remove-backup\"]):              _MigrateCLI.parse_arguments()      assert f\"Removed backup entities from the backup folder '{mongo_backup_path}'.\" in caplog.text      assert not os.path.exists(mongo_backup_path)      @mongomock.patch(servers=((\"localhost\", 27017),))  def test_migrate_mongo_backup_and_restore(caplog):      _MigrateCLI.create_parser()        mongo_backup_path = \".mongo_backup\"        # Restore backup when it does not exist should raise an error      with pytest.raises(SystemExit) as err:          with patch(\"sys.argv\", [\"prog\", \"migrate\", \"--repository-type\", \"mongo\", \"--restore\"]):              _MigrateCLI.parse_arguments()      assert err.value.code == 1      assert f\"The backup folder '{mongo_backup_path}' does not exist.\" in caplog.text      assert not os.path.exists(mongo_backup_path)        # Run without --skip-backup to create the backup database      with pytest.raises(Exception):          with patch(\"sys.argv\", [\"prog\", \"migrate\", \"--repository-type\", \"mongo\"]):              _MigrateCLI.parse_arguments()        assert os.path.exists(mongo_backup_path)        # Restore the backup      with pytest.raises(SystemExit):          with patch(\"sys.argv\", [\"prog\", \"migrate\", \"--repository-type\", \"mongo\", \"--restore\"]):              _MigrateCLI.parse_arguments()      assert f\"Restored entities from the backup folder '{mongo_backup_path}'.\" in caplog.text      assert not os.path.exists(mongo_backup_path)      def test_not_provide_valid_repository_type(caplog):      _MigrateCLI.create_parser()        with pytest.raises(SystemExit):          with patch(\"sys.argv\", [\"prog\", \"migrate\"]):              _MigrateCLI.parse_arguments()              assert \"the following arguments are required: --repository-type\" in caplog.text        with pytest.raises(SystemExit):          with patch(\"sys.argv\", [\"prog\", \"migrate\", \"--repository-type\"]):              _MigrateCLI.parse_arguments()              assert \"argument --repository-type: expected at least one argument\" in caplog.text        with pytest.raises(SystemExit):          with patch(\"sys.argv\", [\"prog\", \"migrate\", \"--repository-type\", \"invalid-repository-type\"]):              _MigrateCLI.parse_arguments()              assert \"Unknown repository type invalid-repository-type\" in caplog.text "}
{"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": "from datetime import datetime, timedelta  from typing import Callable, Iterable, Optional  from unittest.mock import ANY, patch    import pytest    from src.taipy.core import Job  from src.taipy.core._orchestrator._orchestrator import _Orchestrator  from src.taipy.core._orchestrator._orchestrator_factory import _OrchestratorFactory  from src.taipy.core._version._version_manager import _VersionManager  from src.taipy.core.common import _utils  from src.taipy.core.common._utils import _Subscriber  from src.taipy.core.config.job_config import JobConfig  from src.taipy.core.cycle._cycle_manager import _CycleManager  from src.taipy.core.data._data_manager import _DataManager  from src.taipy.core.data.in_memory import InMemoryDataNode  from src.taipy.core.exceptions.exceptions import (      DeletingPrimaryScenario,      DifferentScenarioConfigs,      InsufficientScenarioToCompare,      NonExistingComparator,      NonExistingScenario,      NonExistingScenarioConfig,      NonExistingTask,      SequenceTaskConfigDoesNotExistInSameScenarioConfig,      UnauthorizedTagError,  )  from src.taipy.core.job._job_manager import _JobManager  from src.taipy.core.scenario._scenario_manager import _ScenarioManager  from src.taipy.core.scenario._scenario_manager_factory import _ScenarioManagerFactory  from src.taipy.core.scenario.scenario import Scenario  from src.taipy.core.scenario.scenario_id import ScenarioId  from src.taipy.core.sequence._sequence_manager import _SequenceManager  from src.taipy.core.sequence.sequence import Sequence  from src.taipy.core.sequence.sequence_id import SequenceId  from src.taipy.core.task._task_manager import _TaskManager  from src.taipy.core.task.task import Task  from src.taipy.core.task.task_id import TaskId  from taipy.config.common.frequency import Frequency  from taipy.config.common.scope import Scope  from taipy.config.config import Config  from tests.core.utils import assert_true_after_time  from tests.core.utils.NotifyMock import NotifyMock      def test_set_and_get_scenario(cycle):      Config.configure_job_executions(mode=JobConfig._DEVELOPMENT_MODE)      _OrchestratorFactory._build_dispatcher()        scenario_id_1 = ScenarioId(\"scenario_id_1\")      scenario_1 = Scenario(\"scenario_name_1\", [], {}, [], scenario_id_1)        input_dn_2 = InMemoryDataNode(\"foo\", Scope.SCENARIO)      output_dn_2 = InMemoryDataNode(\"bar\", Scope.SCENARIO)      additional_dn_2 = InMemoryDataNode(\"zyx\", Scope.SCENARIO)      task_name_2 = \"task_2\"      task_2 = Task(task_name_2, {}, print, [input_dn_2], [output_dn_2], TaskId(\"task_id_2\"))      scenario_id_2 = ScenarioId(\"scenario_id_2\")      scenario_2 = Scenario(          \"scenario_name_2\",          [task_2],          {},          [additional_dn_2],          scenario_id_2,          datetime.now(),          True,          cycle,          sequences={\"sequence_2\": {\"tasks\": [task_2]}},      )        additional_dn_3 = InMemoryDataNode(\"baz\", Scope.SCENARIO)      task_name_3 = \"task_3\"      task_3 = Task(task_name_3, {}, print, id=TaskId(\"task_id_3\"))      scenario_3_with_same_id = Scenario(          \"scenario_name_3\",          [task_3],          {},          [additional_dn_3],          scenario_id_1,          datetime.now(),          False,          cycle,          sequences={\"sequence_3\": {}},      )        # No existing scenario      assert len(_ScenarioManager._get_all()) == 0      assert _ScenarioManager._get(scenario_id_1) is None      assert _ScenarioManager._get(scenario_1) is None      assert _ScenarioManager._get(scenario_id_2) is None      assert _ScenarioManager._get(scenario_2) is None        # Save one scenario. We expect to have only one scenario stored      _ScenarioManager._set(scenario_1)      assert len(_ScenarioManager._get_all()) == 1      assert _ScenarioManager._get(scenario_id_1).id == scenario_1.id      assert _ScenarioManager._get(scenario_id_1).config_id == scenario_1.config_id      assert len(_ScenarioManager._get(scenario_id_1).tasks) == 0      assert len(_ScenarioManager._get(scenario_id_1).additional_data_nodes) == 0      assert len(_ScenarioManager._get(scenario_id_1).data_nodes) == 0      assert len(_ScenarioManager._get(scenario_id_1).sequences) == 0      assert _ScenarioManager._get(scenario_1).id == scenario_1.id      assert _ScenarioManager._get(scenario_1).config_id == scenario_1.config_id      assert len(_ScenarioManager._get(scenario_1).tasks) == 0      assert len(_ScenarioManager._get(scenario_1).additional_data_nodes) == 0      assert len(_ScenarioManager._get(scenario_1).data_nodes) == 0      assert len(_ScenarioManager._get(scenario_1).sequences) == 0      assert _ScenarioManager._get(scenario_id_2) is None      assert _ScenarioManager._get(scenario_2) is None        # Save a second scenario. Now, we expect to have a total of two scenarios stored      _TaskManager._set(task_2)      _CycleManager._set(cycle)      _ScenarioManager._set(scenario_2)      _DataManager._set(additional_dn_2)      assert len(_ScenarioManager._get_all()) == 2      assert _ScenarioManager._get(scenario_id_1).id == scenario_1.id      assert _ScenarioManager._get(scenario_id_1).config_id == scenario_1.config_id      assert len(_ScenarioManager._get(scenario_id_1).tasks) == 0      assert len(_ScenarioManager._get(scenario_id_1).additional_data_nodes) == 0      assert len(_ScenarioManager._get(scenario_id_1).data_nodes) == 0      assert len(_ScenarioManager._get(scenario_id_1).sequences) == 0      assert _ScenarioManager._get(scenario_1).id == scenario_1.id      assert _ScenarioManager._get(scenario_1).config_id == scenario_1.config_id      assert len(_ScenarioManager._get(scenario_1).tasks) == 0      assert len(_ScenarioManager._get(scenario_1).additional_data_nodes) == 0      assert len(_ScenarioManager._get(scenario_1).data_nodes) == 0      assert len(_ScenarioManager._get(scenario_1).sequences) == 0      assert _ScenarioManager._get(scenario_id_2).id == scenario_2.id      assert _ScenarioManager._get(scenario_id_2).config_id == scenario_2.config_id      assert len(_ScenarioManager._get(scenario_id_2).tasks) == 1      assert len(_ScenarioManager._get(scenario_id_2).additional_data_nodes) == 1      assert len(_ScenarioManager._get(scenario_id_2).data_nodes) == 3      assert len(_ScenarioManager._get(scenario_id_2).sequences) == 1      assert _ScenarioManager._get(scenario_2).id == scenario_2.id      assert _ScenarioManager._get(scenario_2).config_id == scenario_2.config_id      assert len(_ScenarioManager._get(scenario_2).tasks) == 1      assert len(_ScenarioManager._get(scenario_2).additional_data_nodes) == 1      assert len(_ScenarioManager._get(scenario_2).data_nodes) == 3      assert len(_ScenarioManager._get(scenario_2).sequences) == 1      assert _TaskManager._get(task_2.id).id == task_2.id      assert _ScenarioManager._get(scenario_id_2).cycle == cycle      assert _ScenarioManager._get(scenario_2).cycle == cycle      assert _CycleManager._get(cycle.id).id == cycle.id        # We save the first scenario again. We expect nothing to change      _ScenarioManager._set(scenario_1)      assert len(_ScenarioManager._get_all()) == 2      assert _ScenarioManager._get(scenario_id_1).id == scenario_1.id      assert _ScenarioManager._get(scenario_id_1).config_id == scenario_1.config_id      assert len(_ScenarioManager._get(scenario_id_1).tasks) == 0      assert len(_ScenarioManager._get(scenario_id_1).additional_data_nodes) == 0      assert len(_ScenarioManager._get(scenario_id_1).data_nodes) == 0      assert len(_ScenarioManager._get(scenario_id_1).sequences) == 0      assert _ScenarioManager._get(scenario_1).id == scenario_1.id      assert _ScenarioManager._get(scenario_1).config_id == scenario_1.config_id      assert len(_ScenarioManager._get(scenario_1).tasks) == 0      assert len(_ScenarioManager._get(scenario_1).additional_data_nodes) == 0      assert len(_ScenarioManager._get(scenario_1).data_nodes) == 0      assert len(_ScenarioManager._get(scenario_1).sequences) == 0      assert _ScenarioManager._get(scenario_id_2).id == scenario_2.id      assert _ScenarioManager._get(scenario_id_2).config_id == scenario_2.config_id      assert len(_ScenarioManager._get(scenario_id_2).tasks) == 1      assert len(_ScenarioManager._get(scenario_id_2).additional_data_nodes) == 1      assert len(_ScenarioManager._get(scenario_id_2).data_nodes) == 3      assert len(_ScenarioManager._get(scenario_id_2).sequences) == 1      assert _ScenarioManager._get(scenario_2).id == scenario_2.id      assert _ScenarioManager._get(scenario_2).config_id == scenario_2.config_id      assert len(_ScenarioManager._get(scenario_2).tasks) == 1      assert len(_ScenarioManager._get(scenario_2).additional_data_nodes) == 1      assert len(_ScenarioManager._get(scenario_2).data_nodes) == 3      assert len(_ScenarioManager._get(scenario_2).sequences) == 1      assert _TaskManager._get(task_2.id).id == task_2.id      assert _CycleManager._get(cycle.id).id == cycle.id        # We save a third scenario with same id as the first one.      # We expect the first scenario to be updated      _DataManager._set(additional_dn_3)      _TaskManager._set(task_3)      _TaskManager._set(scenario_2.tasks[task_name_2])      _ScenarioManager._set(scenario_3_with_same_id)      assert len(_ScenarioManager._get_all()) == 2      assert _ScenarioManager._get(scenario_id_1).id == scenario_1.id      assert _ScenarioManager._get(scenario_id_1).config_id == scenario_3_with_same_id.config_id      assert len(_ScenarioManager._get(scenario_id_1).tasks) == 1      assert len(_ScenarioManager._get(scenario_id_1).additional_data_nodes) == 1      assert len(_ScenarioManager._get(scenario_id_1).data_nodes) == 1      assert len(_ScenarioManager._get(scenario_id_1).sequences) == 1      assert _ScenarioManager._get(scenario_id_1).cycle == cycle      assert _ScenarioManager._get(scenario_1).id == scenario_1.id      assert _ScenarioManager._get(scenario_1).config_id == scenario_3_with_same_id.config_id      assert len(_ScenarioManager._get(scenario_1).tasks) == 1      assert len(_ScenarioManager._get(scenario_1).additional_data_nodes) == 1      assert len(_ScenarioManager._get(scenario_1).data_nodes) == 1      assert len(_ScenarioManager._get(scenario_1).sequences) == 1      assert _ScenarioManager._get(scenario_1).cycle == cycle      assert _ScenarioManager._get(scenario_id_2).id == scenario_2.id      assert _ScenarioManager._get(scenario_id_2).config_id == scenario_2.config_id      assert len(_ScenarioManager._get(scenario_id_2).tasks) == 1      assert len(_ScenarioManager._get(scenario_id_2).additional_data_nodes) == 1      assert len(_ScenarioManager._get(scenario_id_2).data_nodes) == 3      assert len(_ScenarioManager._get(scenario_id_2).sequences) == 1      assert _ScenarioManager._get(scenario_2).id == scenario_2.id      assert _ScenarioManager._get(scenario_2).config_id == scenario_2.config_id      assert len(_ScenarioManager._get(scenario_2).tasks) == 1      assert len(_ScenarioManager._get(scenario_2).additional_data_nodes) == 1      assert len(_ScenarioManager._get(scenario_2).data_nodes) == 3      assert len(_ScenarioManager._get(scenario_2).sequences) == 1      assert _TaskManager._get(task_2.id).id == task_2.id      def test_raise_sequence_task_configs_not_in_scenario_config():      data_node = Config.configure_pickle_data_node(\"temp\")      task_config_1 = Config.configure_task(\"task_1\", print, output=[data_node])      task_config_2 = Config.configure_task(\"task_2\", print, input=[data_node])      scenario_config_1 = Config.configure_scenario(\"scenario_1\")      scenario_config_1.add_sequences({\"sequence_0\": []})        _ScenarioManager._create(scenario_config_1)        scenario_config_1.add_sequences({\"sequence_1\": [task_config_1]})      with pytest.raises(SequenceTaskConfigDoesNotExistInSameScenarioConfig) as err:          _ScenarioManager._create(scenario_config_1)      assert err.value.args == ([task_config_1.id], \"sequence_1\", scenario_config_1.id)        scenario_config_1._tasks = [task_config_1]      _ScenarioManager._create(scenario_config_1)        scenario_config_1.add_sequences({\"sequence_2\": [task_config_1]})      _ScenarioManager._create(scenario_config_1)        scenario_config_1.add_sequences({\"sequence_3\": [task_config_1, task_config_2]})      with pytest.raises(SequenceTaskConfigDoesNotExistInSameScenarioConfig) as err:          _ScenarioManager._create(scenario_config_1)      assert err.value.args == ([task_config_2.id], \"sequence_3\", scenario_config_1.id)        scenario_config_1._tasks = [task_config_1, task_config_2]      _ScenarioManager._create(scenario_config_1)      def test_get_all_on_multiple_versions_environment():      # Create 5 scenarios with 2 versions each      # Only version 1.0 has the scenario with config_id = \"config_id_1\"      # Only version 2.0 has the scenario with config_id = \"config_id_6\"      for version in range(1, 3):          for i in range(5):              _ScenarioManager._set(                  Scenario(f\"config_id_{i+version}\", [], {}, [], ScenarioId(f\"id{i}_v{version}\"), version=f\"{version}.0\")              )        _VersionManager._set_experiment_version(\"1.0\")      assert len(_ScenarioManager._get_all()) == 5      assert len(_ScenarioManager._get_all_by(filters=[{\"version\": \"1.0\", \"config_id\": \"config_id_1\"}])) == 1      assert len(_ScenarioManager._get_all_by(filters=[{\"version\": \"1.0\", \"config_id\": \"config_id_6\"}])) == 0        _VersionManager._set_experiment_version(\"2.0\")      assert len(_ScenarioManager._get_all()) == 5      assert len(_ScenarioManager._get_all_by(filters=[{\"version\": \"2.0\", \"config_id\": \"config_id_1\"}])) == 0      assert len(_ScenarioManager._get_all_by(filters=[{\"version\": \"2.0\", \"config_id\": \"config_id_6\"}])) == 1        _VersionManager._set_development_version(\"1.0\")      assert len(_ScenarioManager._get_all()) == 5      assert len(_ScenarioManager._get_all_by(filters=[{\"version\": \"1.0\", \"config_id\": \"config_id_1\"}])) == 1      assert len(_ScenarioManager._get_all_by(filters=[{\"version\": \"1.0\", \"config_id\": \"config_id_6\"}])) == 0        _VersionManager._set_development_version(\"2.0\")      assert len(_ScenarioManager._get_all()) == 5      assert len(_ScenarioManager._get_all_by(filters=[{\"version\": \"2.0\", \"config_id\": \"config_id_1\"}])) == 0      assert len(_ScenarioManager._get_all_by(filters=[{\"version\": \"2.0\", \"config_id\": \"config_id_6\"}])) == 1      def test_create_scenario_does_not_modify_config():      Config.configure_job_executions(mode=JobConfig._DEVELOPMENT_MODE)        creation_date_1 = datetime.now()      name_1 = \"name_1\"      scenario_config = Config.configure_scenario(\"sc\", None, None, Frequency.DAILY)      assert scenario_config.properties.get(\"name\") is None      assert len(scenario_config.properties) == 0        _OrchestratorFactory._build_dispatcher()        scenario = _ScenarioManager._create(scenario_config, creation_date=creation_date_1, name=name_1)      assert len(scenario_config.properties) == 0      assert len(scenario.properties) == 1      assert scenario.properties.get(\"name\") == name_1      assert scenario.name == name_1        scenario.properties[\"foo\"] = \"bar\"      _ScenarioManager._set(scenario)      assert len(scenario_config.properties) == 0      assert len(scenario.properties) == 2      assert scenario.properties.get(\"foo\") == \"bar\"      assert scenario.properties.get(\"name\") == name_1      assert scenario.name == name_1        scenario_2 = _ScenarioManager._create(scenario_config, creation_date=creation_date_1)      assert scenario_2.name is None      def test_create_and_delete_scenario():      Config.configure_job_executions(mode=JobConfig._DEVELOPMENT_MODE)        creation_date_1 = datetime.now()      creation_date_2 = creation_date_1 + timedelta(minutes=10)        name_1 = \"name_1\"        _ScenarioManager._delete_all()      assert len(_ScenarioManager._get_all()) == 0        scenario_config = Config.configure_scenario(\"sc\", None, None, Frequency.DAILY)        _OrchestratorFactory._build_dispatcher()        scenario_1 = _ScenarioManager._create(scenario_config, creation_date=creation_date_1, name=name_1)      assert scenario_1.config_id == \"sc\"      assert scenario_1.sequences == {}      assert scenario_1.tasks == {}      assert scenario_1.additional_data_nodes == {}      assert scenario_1.data_nodes == {}      assert scenario_1.cycle.frequency == Frequency.DAILY      assert scenario_1.is_primary      assert scenario_1.cycle.creation_date == creation_date_1      assert scenario_1.cycle.start_date.date() == creation_date_1.date()      assert scenario_1.cycle.end_date.date() == creation_date_1.date()      assert scenario_1.creation_date == creation_date_1      assert scenario_1.name == name_1      assert scenario_1.properties[\"name\"] == name_1      assert scenario_1.tags == set()        cycle_id_1 = scenario_1.cycle.id      assert _CycleManager._get(cycle_id_1).id == cycle_id_1      _ScenarioManager._delete(scenario_1.id)      assert _ScenarioManager._get(scenario_1.id) is None      assert _CycleManager._get(cycle_id_1) is None        # Recreate scenario_1      scenario_1 = _ScenarioManager._create(scenario_config, creation_date=creation_date_1, name=name_1)        scenario_2 = _ScenarioManager._create(scenario_config, creation_date=creation_date_2)      assert scenario_2.config_id == \"sc\"      assert scenario_2.sequences == {}      assert scenario_2.tasks == {}      assert scenario_2.additional_data_nodes == {}      assert scenario_2.data_nodes == {}      assert scenario_2.cycle.frequency == Frequency.DAILY      assert not scenario_2.is_primary      assert scenario_2.cycle.creation_date == creation_date_1      assert scenario_2.cycle.start_date.date() == creation_date_2.date()      assert scenario_2.cycle.end_date.date() == creation_date_2.date()      assert scenario_2.properties.get(\"name\") is None      assert scenario_2.tags == set()        assert scenario_1 != scenario_2      assert scenario_1.cycle == scenario_2.cycle        assert len(_ScenarioManager._get_all()) == 2      with pytest.raises(DeletingPrimaryScenario):          _ScenarioManager._delete(              scenario_1.id,          )        _ScenarioManager._delete(          scenario_2.id,      )      assert len(_ScenarioManager._get_all()) == 1      _ScenarioManager._delete(scenario_1.id)      assert len(_ScenarioManager._get_all()) == 0      def test_is_deletable():      assert len(_ScenarioManager._get_all()) == 0      scenario_config = Config.configure_scenario(\"sc\", None, None, Frequency.DAILY)      creation_date = datetime.now()      scenario_1_primary = _ScenarioManager._create(scenario_config, creation_date=creation_date, name=\"1\")      scenario_2 = _ScenarioManager._create(scenario_config, creation_date=creation_date, name=\"2\")        assert len(_ScenarioManager._get_all()) == 2      assert scenario_1_primary.is_primary      assert not _ScenarioManager._is_deletable(scenario_1_primary)      assert not _ScenarioManager._is_deletable(scenario_1_primary.id)      assert not scenario_2.is_primary      assert _ScenarioManager._is_deletable(scenario_2)      assert _ScenarioManager._is_deletable(scenario_2.id)        _ScenarioManager._hard_delete(scenario_2.id)      del scenario_2        assert len(_ScenarioManager._get_all()) == 1      assert scenario_1_primary.is_primary      assert _ScenarioManager._is_deletable(scenario_1_primary)      assert _ScenarioManager._is_deletable(scenario_1_primary.id)      def test_assign_scenario_as_parent_of_task_and_additional_data_nodes():      dn_config_1 = Config.configure_data_node(\"dn_1\", \"in_memory\", scope=Scope.GLOBAL)      dn_config_2 = Config.configure_data_node(\"dn_2\", \"in_memory\", scope=Scope.GLOBAL)      dn_config_3 = Config.configure_data_node(\"dn_3\", \"in_memory\", scope=Scope.SCENARIO)      additional_dn_config_1 = Config.configure_data_node(\"additional_dn_1\", \"in_memory\", scope=Scope.GLOBAL)      additional_dn_config_2 = Config.configure_data_node(\"additional_dn_2\", \"in_memory\", scope=Scope.SCENARIO)      task_config_1 = Config.configure_task(\"task_1\", print, [dn_config_1], [dn_config_2])      task_config_2 = Config.configure_task(\"task_2\", print, [dn_config_2], [dn_config_3])      task_config_3 = Config.configure_task(\"task_3\", print, [dn_config_2], [dn_config_3])      scenario_config_1 = Config.configure_scenario(          \"scenario_1\", [task_config_1, task_config_2], [additional_dn_config_1, additional_dn_config_2]      )      scenario_config_1.add_sequences({\"sequence_1\": [task_config_1, task_config_2]})      scenario_config_2 = Config.configure_scenario(          \"scenario_2\", [task_config_1, task_config_2, task_config_3], [additional_dn_config_1, additional_dn_config_2]      )      scenario_config_2.add_sequences(          {\"sequence_1\": [task_config_1, task_config_2], \"sequence_2\": [task_config_1, task_config_3]}      )        scenario_1 = _ScenarioManager._create(scenario_config_1)      sequence_1_s1 = scenario_1.sequences[\"sequence_1\"]        assert all([sequence.parent_ids == {scenario_1.id} for sequence in scenario_1.sequences.values()])      tasks = scenario_1.tasks.values()      assert all([task.parent_ids == {scenario_1.id, sequence_1_s1.id} for task in tasks])      data_nodes = {}      for task in tasks:          data_nodes.update(task.data_nodes)      assert data_nodes[\"dn_1\"].parent_ids == {scenario_1.tasks[\"task_1\"].id}      assert data_nodes[\"dn_2\"].parent_ids == {scenario_1.tasks[\"task_1\"].id, scenario_1.tasks[\"task_2\"].id}      assert data_nodes[\"dn_3\"].parent_ids == {scenario_1.tasks[\"task_2\"].id}      additional_data_nodes = scenario_1.additional_data_nodes      assert additional_data_nodes[\"additional_dn_1\"].parent_ids == {scenario_1.id}      assert additional_data_nodes[\"additional_dn_2\"].parent_ids == {scenario_1.id}        scenario_2 = _ScenarioManager._create(scenario_config_2)      sequence_1_s2 = scenario_2.sequences[\"sequence_1\"]      sequence_2_s2 = scenario_2.sequences[\"sequence_2\"]        assert all([sequence.parent_ids == {scenario_2.id} for sequence in scenario_2.sequences.values()])      assert scenario_1.tasks[\"task_1\"] == scenario_2.tasks[\"task_1\"]      assert scenario_1.tasks[\"task_1\"].parent_ids == {          scenario_1.id,          sequence_1_s1.id,          scenario_2.id,          sequence_1_s2.id,          sequence_2_s2.id,      }      assert scenario_1.tasks[\"task_2\"].parent_ids == {scenario_1.id, sequence_1_s1.id}      assert scenario_2.tasks[\"task_2\"].parent_ids == {scenario_2.id, sequence_1_s2.id}      assert scenario_2.tasks[\"task_3\"].parent_ids == {scenario_2.id, sequence_2_s2.id}      additional_data_nodes = scenario_2.additional_data_nodes      assert additional_data_nodes[\"additional_dn_1\"].parent_ids == {scenario_1.id, scenario_2.id}      assert additional_data_nodes[\"additional_dn_2\"].parent_ids == {scenario_2.id}        _ScenarioManager._hard_delete(scenario_1.id)      _ScenarioManager._hard_delete(scenario_2.id)      _TaskManager._delete_all()      _DataManager._delete_all()        dn_config_1 = Config.configure_data_node(\"dn_1\", \"in_memory\", scope=Scope.GLOBAL)      dn_config_2 = Config.configure_data_node(\"dn_2\", \"in_memory\", scope=Scope.GLOBAL)      dn_config_3 = Config.configure_data_node(\"dn_3\", \"in_memory\", scope=Scope.GLOBAL)      additional_dn_config_1 = Config.configure_data_node(\"additional_dn_1\", \"in_memory\", scope=Scope.GLOBAL)      additional_dn_config_2 = Config.configure_data_node(\"additional_dn_2\", \"in_memory\", scope=Scope.GLOBAL)      task_config_1 = Config.configure_task(\"task_1\", print, [dn_config_1], [dn_config_2])      task_config_2 = Config.configure_task(\"task_2\", print, [dn_config_2], [dn_config_3])      task_config_3 = Config.configure_task(\"task_3\", print, [dn_config_2], [dn_config_3])      scenario_config_1 = Config.configure_scenario(          \"scenario_1\", [task_config_1, task_config_2], [additional_dn_config_1, additional_dn_config_2]      )      scenario_config_1.add_sequences({\"sequence_1\": [task_config_1, task_config_2]})      scenario_config_2 = Config.configure_scenario(          \"scenario_2\", [task_config_1, task_config_2, task_config_3], [additional_dn_config_1, additional_dn_config_2]      )      scenario_config_2.add_sequences(          {\"sequence_1\": [task_config_1, task_config_2], \"sequence_2\": [task_config_1, task_config_3]}      )        scenario_1 = _ScenarioManager._create(scenario_config_1)      sequence_1_s1 = scenario_1.sequences[\"sequence_1\"]      assert scenario_1.sequences[\"sequence_1\"].parent_ids == {scenario_1.id}      tasks = scenario_1.tasks.values()      assert all([task.parent_ids == {scenario_1.id, sequence_1_s1.id} for task in tasks])      data_nodes = {}      for task in tasks:          data_nodes.update(task.data_nodes)      assert data_nodes[\"dn_1\"].parent_ids == {scenario_1.tasks[\"task_1\"].id}      assert data_nodes[\"dn_2\"].parent_ids == {scenario_1.tasks[\"task_1\"].id, scenario_1.tasks[\"task_2\"].id}      assert data_nodes[\"dn_3\"].parent_ids == {scenario_1.tasks[\"task_2\"].id}      additional_data_nodes = scenario_1.additional_data_nodes      assert additional_data_nodes[\"additional_dn_1\"].parent_ids == {scenario_1.id}      assert additional_data_nodes[\"additional_dn_2\"].parent_ids == {scenario_1.id}        scenario_2 = _ScenarioManager._create(scenario_config_2)      sequence_1_s2 = scenario_2.sequences[\"sequence_1\"]      sequence_2_s2 = scenario_2.sequences[\"sequence_2\"]        assert scenario_1.sequences[\"sequence_1\"].parent_ids == {scenario_1.id}      assert scenario_2.sequences[\"sequence_1\"].parent_ids == {scenario_2.id}      assert scenario_2.sequences[\"sequence_2\"].parent_ids == {scenario_2.id}      tasks = {**scenario_1.tasks, **scenario_2.tasks}      assert tasks[\"task_1\"].parent_ids == {          scenario_1.id,          scenario_2.id,          sequence_1_s1.id,          sequence_1_s2.id,          sequence_2_s2.id,      }      assert tasks[\"task_2\"].parent_ids == {scenario_1.id, scenario_2.id, sequence_1_s1.id, sequence_1_s2.id}      assert tasks[\"task_3\"].parent_ids == {scenario_2.id, sequence_2_s2.id}      additional_data_nodes = scenario_2.additional_data_nodes      assert additional_data_nodes[\"additional_dn_1\"].parent_ids == {scenario_1.id, scenario_2.id}      assert additional_data_nodes[\"additional_dn_2\"].parent_ids == {scenario_1.id, scenario_2.id}      def mult_by_2(nb: int):      return nb * 2      def mult_by_3(nb: int):      return nb * 3      def mult_by_4(nb: int):      return nb * 4      def test_scenario_manager_only_creates_data_node_once():      Config.configure_job_executions(mode=JobConfig._DEVELOPMENT_MODE)        # dn_1 ---> mult_by_2 ---> dn_2 ---> mult_by_3 ---> dn_6      # dn_1 ---> mult_by_4 ---> dn_4        dn_config_1 = Config.configure_data_node(\"foo\", \"in_memory\", Scope.GLOBAL, default_data=1)      dn_config_2 = Config.configure_data_node(\"bar\", \"in_memory\", Scope.CYCLE, default_data=0)      dn_config_6 = Config.configure_data_node(\"baz\", \"in_memory\", Scope.CYCLE, default_data=0)      dn_config_4 = Config.configure_data_node(\"qux\", \"in_memory\", Scope.SCENARIO, default_data=0)      task_mult_by_2_config = Config.configure_task(\"mult_by_2\", mult_by_2, [dn_config_1], dn_config_2)      task_mult_by_3_config = Config.configure_task(\"mult_by_3\", mult_by_3, [dn_config_2], dn_config_6)      task_mult_by_4_config = Config.configure_task(\"mult_by_4\", mult_by_4, [dn_config_1], dn_config_4)      scenario_config = Config.configure_scenario(          \"awesome_scenario\", [task_mult_by_2_config, task_mult_by_3_config, task_mult_by_4_config], None, Frequency.DAILY      )      scenario_config.add_sequences(          {\"by_6\": [task_mult_by_2_config, task_mult_by_3_config], \"by_4\": [task_mult_by_4_config]}      )        _OrchestratorFactory._build_dispatcher()        assert len(_DataManager._get_all()) == 0      assert len(_TaskManager._get_all()) == 0      assert len(_SequenceManager._get_all()) == 0      assert len(_ScenarioManager._get_all()) == 0      assert len(_CycleManager._get_all()) == 0        scenario_1 = _ScenarioManager._create(scenario_config)        assert len(_DataManager._get_all()) == 4      assert len(_TaskManager._get_all()) == 3      assert len(_SequenceManager._get_all()) == 2      assert len(_ScenarioManager._get_all()) == 1      assert scenario_1.foo.read() == 1      assert scenario_1.bar.read() == 0      assert scenario_1.baz.read() == 0      assert scenario_1.qux.read() == 0      assert scenario_1.by_6._get_sorted_tasks()[0][0].config_id == task_mult_by_2_config.id      assert scenario_1.by_6._get_sorted_tasks()[1][0].config_id == task_mult_by_3_config.id      assert scenario_1.by_4._get_sorted_tasks()[0][0].config_id == task_mult_by_4_config.id      assert scenario_1.tasks.keys() == {task_mult_by_2_config.id, task_mult_by_3_config.id, task_mult_by_4_config.id}        scenario_1_sorted_tasks = scenario_1._get_sorted_tasks()      expected = [{task_mult_by_2_config.id, task_mult_by_4_config.id}, {task_mult_by_3_config.id}]      for i, list_tasks_by_level in enumerate(scenario_1_sorted_tasks):          assert set([t.config_id for t in list_tasks_by_level]) == expected[i]      assert scenario_1.cycle.frequency == Frequency.DAILY        _ScenarioManager._create(scenario_config)        assert len(_DataManager._get_all()) == 5      assert len(_TaskManager._get_all()) == 4      assert len(_SequenceManager._get_all()) == 4      assert len(_ScenarioManager._get_all()) == 2      def test_notification_subscribe(mocker):      Config.configure_job_executions(mode=JobConfig._DEVELOPMENT_MODE)        mocker.patch(\"src.taipy.core._entity._reload._Reloader._reload\", side_effect=lambda m, o: o)        scenario_config = Config.configure_scenario(          \"awesome_scenario\",          [              Config.configure_task(                  \"mult_by_2\",                  mult_by_2,                  [Config.configure_data_node(\"foo\", \"in_memory\", Scope.SCENARIO, default_data=1)],                  Config.configure_data_node(\"bar\", \"in_memory\", Scope.SCENARIO, default_data=0),              )          ],      )        _OrchestratorFactory._build_dispatcher()        scenario = _ScenarioManager._create(scenario_config)        notify_1 = NotifyMock(scenario)      notify_2 = NotifyMock(scenario)      mocker.patch.object(_utils, \"_load_fct\", side_effect=[notify_1, notify_2])        # test subscribing notification      _ScenarioManager._subscribe(callback=notify_1, scenario=scenario)      _ScenarioManager._submit(scenario)      notify_1.assert_called_3_times()        notify_1.reset()        # test unsubscribing notification      # test notis subscribe only on new jobs      # _ScenarioManager._get(scenario)      _ScenarioManager._unsubscribe(callback=notify_1, scenario=scenario)      _ScenarioManager._subscribe(callback=notify_2, scenario=scenario)      _ScenarioManager._submit(scenario)        notify_1.assert_not_called()      notify_2.assert_called_3_times()      class Notify:      def __call__(self, *args, **kwargs):          self.args = args        def assert_called_with(self, args):          assert args in self.args      def test_notification_subscribe_multiple_params(mocker):      Config.configure_job_executions(mode=JobConfig._DEVELOPMENT_MODE)        mocker.patch(\"src.taipy.core._entity._reload._Reloader._reload\", side_effect=lambda m, o: o)        scenario_config = Config.configure_scenario(          \"awesome_scenario\",          [              Config.configure_task(                  \"mult_by_2\",                  mult_by_2,                  [Config.configure_data_node(\"foo\", \"in_memory\", Scope.SCENARIO, default_data=1)],                  Config.configure_data_node(\"bar\", \"in_memory\", Scope.SCENARIO, default_data=0),              )          ],      )      notify = mocker.Mock()        _OrchestratorFactory._build_dispatcher()        scenario = _ScenarioManager._create(scenario_config)      _ScenarioManager._subscribe(callback=notify, params=[\"foobar\", 123, 1.2], scenario=scenario)      mocker.patch.object(_ScenarioManager, \"_get\", return_value=scenario)        _ScenarioManager._submit(scenario)        notify.assert_called_with(\"foobar\", 123, 1.2, scenario, ANY)      def notify_multi_param(param, *args):      assert len(param) == 3      def notify1(*args, **kwargs):      ...      def notify2(*args, **kwargs):      ...      def test_notification_unsubscribe(mocker):      Config.configure_job_executions(mode=JobConfig._DEVELOPMENT_MODE)        mocker.patch(\"src.taipy.core._entity._reload._Reloader._reload\", side_effect=lambda m, o: o)        scenario_config = Config.configure_scenario(          \"awesome_scenario\",          [              Config.configure_task(                  \"mult_by_2\",                  mult_by_2,                  [Config.configure_data_node(\"foo\", \"in_memory\", Scope.SCENARIO, default_data=1)],                  Config.configure_data_node(\"bar\", \"in_memory\", Scope.SCENARIO, default_data=0),              )          ],      )        _OrchestratorFactory._build_dispatcher()        scenario = _ScenarioManager._create(scenario_config)        notify_1 = notify1      notify_2 = notify2        # test subscribing notification      _ScenarioManager._subscribe(callback=notify_1, scenario=scenario)      _ScenarioManager._unsubscribe(callback=notify_1, scenario=scenario)      _ScenarioManager._subscribe(callback=notify_2, scenario=scenario)      _ScenarioManager._submit(scenario.id)        with pytest.raises(ValueError):          _ScenarioManager._unsubscribe(callback=notify_1, scenario=scenario)      _ScenarioManager._unsubscribe(callback=notify_2, scenario=scenario)      def test_notification_unsubscribe_multi_param():      Config.configure_job_executions(mode=JobConfig._DEVELOPMENT_MODE)        scenario_config = Config.configure_scenario(          \"awesome_scenario\",          [              Config.configure_task(                  \"mult_by_2\",                  mult_by_2,                  [Config.configure_data_node(\"foo\", \"in_memory\", Scope.SCENARIO, default_data=1)],                  Config.configure_data_node(\"bar\", \"in_memory\", Scope.SCENARIO, default_data=0),              )          ],      )        _OrchestratorFactory._build_dispatcher()        scenario = _ScenarioManager._create(scenario_config)        # test subscribing notification      _ScenarioManager._subscribe(callback=notify_multi_param, params=[\"foobar\", 123, 0], scenario=scenario)      _ScenarioManager._subscribe(callback=notify_multi_param, params=[\"foobar\", 123, 1], scenario=scenario)      _ScenarioManager._subscribe(callback=notify_multi_param, params=[\"foobar\", 123, 2], scenario=scenario)        assert len(scenario.subscribers) == 3        # if no params are passed, removes the first occurrence of the subscriber when theres more than one copy      scenario.unsubscribe(notify_multi_param)      assert len(scenario.subscribers) == 2      assert _Subscriber(notify_multi_param, [\"foobar\", 123, 0]) not in scenario.subscribers        # If params are passed, find the corresponding pair of callback and params to remove      scenario.unsubscribe(notify_multi_param, [\"foobar\", 123, 2])      assert len(scenario.subscribers) == 1      assert _Subscriber(notify_multi_param, [\"foobar\", 123, 2]) not in scenario.subscribers        # If params are passed but is not on the list of subscribers, throws a ValueErrors      with pytest.raises(ValueError):          scenario.unsubscribe(notify_multi_param, [\"foobar\", 123, 10000])      def test_scenario_notification_subscribe_all():      Config.configure_job_executions(mode=JobConfig._DEVELOPMENT_MODE)        scenario_config = Config.configure_scenario(          \"awesome_scenario\",          [              Config.configure_task(                  \"mult_by_2\",                  mult_by_2,                  [Config.configure_data_node(\"foo\", \"in_memory\", Scope.SCENARIO, default_data=1)],                  Config.configure_data_node(\"bar\", \"in_memory\", Scope.SCENARIO, default_data=0),              )          ],      )      other_scenario_config = Config.configure_scenario(          \"other_scenario\",          [              Config.configure_task(                  \"other_mult_by_2_2\",                  mult_by_2,                  [Config.configure_data_node(\"other_foo\", \"in_memory\", Scope.SCENARIO, default_data=1)],                  Config.configure_data_node(\"other_bar\", \"in_memory\", Scope.SCENARIO, default_data=0),              )          ],      )      _OrchestratorFactory._build_dispatcher()      scenario = _ScenarioManager._create(scenario_config)      other_scenario = _ScenarioManager._create(other_scenario_config)      notify_1 = NotifyMock(scenario)      _ScenarioManager._subscribe(notify_1)      assert len(_ScenarioManager._get(scenario.id).subscribers) == 1      assert len(_ScenarioManager._get(other_scenario.id).subscribers) == 1      def test_is_promotable_to_primary_scenario():      assert len(_ScenarioManager._get_all()) == 0      scenario_config = Config.configure_scenario(\"sc\", set(), set(), Frequency.DAILY)      creation_date = datetime.now()      scenario_1 = _ScenarioManager._create(scenario_config, creation_date=creation_date, name=\"1\")  # primary scenario      scenario_2 = _ScenarioManager._create(scenario_config, creation_date=creation_date, name=\"2\")        assert len(_ScenarioManager._get_all()) == 2      assert scenario_1.is_primary      assert not _ScenarioManager._is_promotable_to_primary(scenario_1)      assert not _ScenarioManager._is_promotable_to_primary(scenario_1.id)      assert not scenario_2.is_primary      assert _ScenarioManager._is_promotable_to_primary(scenario_2)      assert _ScenarioManager._is_promotable_to_primary(scenario_2.id)        _ScenarioManager._set_primary(scenario_2)        assert len(_ScenarioManager._get_all()) == 2      assert not scenario_1.is_primary      assert _ScenarioManager._is_promotable_to_primary(scenario_1)      assert _ScenarioManager._is_promotable_to_primary(scenario_1.id)      assert scenario_2.is_primary      assert not _ScenarioManager._is_promotable_to_primary(scenario_2)      assert not _ScenarioManager._is_promotable_to_primary(scenario_2.id)      def test_get_set_primary_scenario():      Config.configure_job_executions(mode=JobConfig._DEVELOPMENT_MODE)      _OrchestratorFactory._build_dispatcher()        cycle_1 = _CycleManager._create(Frequency.DAILY, name=\"foo\")        scenario_1 = Scenario(\"sc_1\", [], {}, ScenarioId(\"sc_1\"), is_primary=False, cycle=cycle_1)      scenario_2 = Scenario(\"sc_2\", [], {}, ScenarioId(\"sc_2\"), is_primary=False, cycle=cycle_1)        _ScenarioManager._delete_all()      _CycleManager._delete_all()        assert len(_ScenarioManager._get_all()) == 0      assert len(_CycleManager._get_all()) == 0        _CycleManager._set(cycle_1)        _ScenarioManager._set(scenario_1)      _ScenarioManager._set(scenario_2)        assert len(_ScenarioManager._get_primary_scenarios()) == 0      assert len(_ScenarioManager._get_all_by_cycle(cycle_1)) == 2        _ScenarioManager._set_primary(scenario_1)        assert len(_ScenarioManager._get_primary_scenarios()) == 1      assert len(_ScenarioManager._get_all_by_cycle(cycle_1)) == 2      assert _ScenarioManager._get_primary(cycle_1) == scenario_1        _ScenarioManager._set_primary(scenario_2)        assert len(_ScenarioManager._get_primary_scenarios()) == 1      assert len(_ScenarioManager._get_all_by_cycle(cycle_1)) == 2      assert _ScenarioManager._get_primary(cycle_1) == scenario_2      def test_hard_delete_one_single_scenario_with_scenario_data_nodes():      Config.configure_job_executions(mode=JobConfig._DEVELOPMENT_MODE)        dn_input_config = Config.configure_data_node(\"my_input\", \"in_memory\", scope=Scope.SCENARIO, default_data=\"testing\")      dn_output_config = Config.configure_data_node(\"my_output\", \"in_memory\", scope=Scope.SCENARIO)      task_config = Config.configure_task(\"task_config\", print, dn_input_config, dn_output_config)      scenario_config = Config.configure_scenario(\"scenario_config\", [task_config])      scenario_config.add_sequences({\"sequence_config\": [task_config]})        _OrchestratorFactory._build_dispatcher()        scenario = _ScenarioManager._create(scenario_config)      _ScenarioManager._submit(scenario.id)        assert len(_ScenarioManager._get_all()) == 1      assert len(_SequenceManager._get_all()) == 1      assert len(_TaskManager._get_all()) == 1      assert len(_DataManager._get_all()) == 2      assert len(_JobManager._get_all()) == 1      _ScenarioManager._hard_delete(scenario.id)      assert len(_ScenarioManager._get_all()) == 0      assert len(_SequenceManager._get_all()) == 0      assert len(_TaskManager._get_all()) == 0      assert len(_DataManager._get_all()) == 0      assert len(_JobManager._get_all()) == 0      def test_hard_delete_one_scenario_among_two_with_scenario_data_nodes():      Config.configure_job_executions(mode=JobConfig._DEVELOPMENT_MODE)        dn_input_config = Config.configure_data_node(\"my_input\", \"in_memory\", scope=Scope.SCENARIO, default_data=\"testing\")      dn_output_config = Config.configure_data_node(\"my_output\", \"in_memory\", scope=Scope.SCENARIO)      task_config = Config.configure_task(\"task_config\", print, dn_input_config, dn_output_config)      scenario_config = Config.configure_scenario(\"scenario_config\", [task_config])      scenario_config.add_sequences({\"sequence_config\": [task_config]})        _OrchestratorFactory._build_dispatcher()        scenario_1 = _ScenarioManager._create(scenario_config)      scenario_2 = _ScenarioManager._create(scenario_config)      _ScenarioManager._submit(scenario_1.id)      _ScenarioManager._submit(scenario_2.id)        assert len(_ScenarioManager._get_all()) == 2      assert len(_SequenceManager._get_all()) == 2      assert len(_TaskManager._get_all()) == 2      assert len(_DataManager._get_all()) == 4      assert len(_JobManager._get_all()) == 2      _ScenarioManager._hard_delete(scenario_1.id)      assert len(_ScenarioManager._get_all()) == 1      assert len(_SequenceManager._get_all()) == 1      assert len(_TaskManager._get_all()) == 1      assert len(_DataManager._get_all()) == 2      assert len(_JobManager._get_all()) == 1      assert _ScenarioManager._get(scenario_2.id) is not None      def test_hard_delete_one_scenario_among_two_with_cycle_data_nodes():      Config.configure_job_executions(mode=JobConfig._DEVELOPMENT_MODE)        dn_input_config = Config.configure_data_node(\"my_input\", \"in_memory\", scope=Scope.CYCLE, default_data=\"testing\")      dn_output_config = Config.configure_data_node(\"my_output\", \"in_memory\", scope=Scope.CYCLE)      task_config = Config.configure_task(\"task_config\", print, dn_input_config, dn_output_config)      scenario_config = Config.configure_scenario(\"scenario_config\", [task_config])      scenario_config.add_sequences({\"sequence_config\": [task_config]})        _OrchestratorFactory._build_dispatcher()        scenario_1 = _ScenarioManager._create(scenario_config)      scenario_2 = _ScenarioManager._create(scenario_config)      _ScenarioManager._submit(scenario_1.id)      _ScenarioManager._submit(scenario_2.id)        assert len(_ScenarioManager._get_all()) == 2      assert len(_SequenceManager._get_all()) == 2      assert len(_TaskManager._get_all()) == 1      assert len(_DataManager._get_all()) == 2      assert len(_JobManager._get_all()) == 2      _ScenarioManager._hard_delete(scenario_1.id)      assert len(_ScenarioManager._get_all()) == 1      assert len(_SequenceManager._get_all()) == 1      assert len(_TaskManager._get_all()) == 1      assert len(_DataManager._get_all()) == 2      assert len(_JobManager._get_all()) == 2      assert _ScenarioManager._get(scenario_2.id) is not None      def test_hard_delete_shared_entities():      Config.configure_job_executions(mode=JobConfig._DEVELOPMENT_MODE)        dn_config_1 = Config.configure_data_node(\"my_input_1\", \"in_memory\", scope=Scope.CYCLE, default_data=\"testing\")      dn_config_2 = Config.configure_data_node(\"my_input_2\", \"in_memory\", scope=Scope.SCENARIO, default_data=\"testing\")      dn_config_3 = Config.configure_data_node(\"my_input_3\", \"in_memory\", scope=Scope.GLOBAL, default_data=\"testing\")      dn_config_4 = Config.configure_data_node(\"my_input_4\", \"in_memory\", scope=Scope.GLOBAL, default_data=\"testing\")      task_config_1 = Config.configure_task(\"task_config_1\", print, dn_config_1, dn_config_2)      task_config_2 = Config.configure_task(\"task_config_2\", print, dn_config_2, dn_config_3)      task_config_3 = Config.configure_task(\"task_config_3\", print, dn_config_3, dn_config_4)  # scope = global      task_config_4 = Config.configure_task(\"task_config_4\", print, dn_config_1)  # scope = cycle      scenario_config_1 = Config.configure_scenario(          \"scenario_config_1\",          [task_config_1, task_config_2, task_config_3, task_config_4],          frequency=Frequency.WEEKLY,      )      scenario_config_1.add_sequences(          {              \"sequence_config_1\": [task_config_1, task_config_2],              \"sequence_config_2\": [task_config_1, task_config_2],              \"sequence_config_3\": [task_config_3],              \"sequence_config_4\": [task_config_4],          }      )        _OrchestratorFactory._build_dispatcher()        scenario_1 = _ScenarioManager._create(scenario_config_1)      scenario_2 = _ScenarioManager._create(scenario_config_1)      scenario_1.submit()      scenario_2.submit()        assert len(_CycleManager._get_all()) == 1      assert len(_ScenarioManager._get_all()) == 2      assert len(_SequenceManager._get_all()) == 8      assert len(_TaskManager._get_all()) == 6      assert len(_DataManager._get_all()) == 5      assert len(_JobManager._get_all()) == 8      _ScenarioManager._hard_delete(scenario_2.id)      assert len(_CycleManager._get_all()) == 1      assert len(_ScenarioManager._get_all()) == 1      assert len(_SequenceManager._get_all()) == 4      assert len(_TaskManager._get_all()) == 4      assert len(_DataManager._get_all()) == 4      assert len(_JobManager._get_all()) == 6      def test_is_submittable():      assert len(_ScenarioManager._get_all()) == 0        dn_config = Config.configure_in_memory_data_node(\"dn\", 10)      task_config = Config.configure_task(\"task\", print, [dn_config])      scenario_config = Config.configure_scenario(\"sc\", set([task_config]), set(), Frequency.DAILY)      scenario = _ScenarioManager._create(scenario_config)        assert len(_ScenarioManager._get_all()) == 1      assert _ScenarioManager._is_submittable(scenario)      assert _ScenarioManager._is_submittable(scenario.id)      assert not _ScenarioManager._is_submittable(\"Scenario_temp\")        scenario.dn.edit_in_progress = True      assert not _ScenarioManager._is_submittable(scenario)      assert not _ScenarioManager._is_submittable(scenario.id)        scenario.dn.edit_in_progress = False      assert _ScenarioManager._is_submittable(scenario)      assert _ScenarioManager._is_submittable(scenario.id)      def test_submit():      Config.configure_job_executions(mode=JobConfig._DEVELOPMENT_MODE)      _OrchestratorFactory._build_dispatcher()        data_node_1 = InMemoryDataNode(\"foo\", Scope.SCENARIO, \"s1\")      data_node_2 = InMemoryDataNode(\"bar\", Scope.SCENARIO, \"s2\")      data_node_3 = InMemoryDataNode(\"baz\", Scope.SCENARIO, \"s3\")      data_node_4 = InMemoryDataNode(\"qux\", Scope.SCENARIO, \"s4\")      data_node_5 = InMemoryDataNode(\"quux\", Scope.SCENARIO, \"s5\")      data_node_6 = InMemoryDataNode(\"quuz\", Scope.SCENARIO, \"s6\")      data_node_7 = InMemoryDataNode(\"corge\", Scope.SCENARIO, \"s7\")      data_node_8 = InMemoryDataNode(\"fum\", Scope.SCENARIO, \"s8\")      task_1 = Task(          \"grault\",          {},          print,          [data_node_1, data_node_2],          [data_node_3, data_node_4],          TaskId(\"t1\"),      )      task_2 = Task(\"garply\", {}, print, [data_node_3], [data_node_5], TaskId(\"t2\"))      task_3 = Task(\"waldo\", {}, print, [data_node_5, data_node_4], [data_node_6], TaskId(\"t3\"))      task_4 = Task(\"fred\", {}, print, [data_node_4], [data_node_7], TaskId(\"t4\"))      task_5 = Task(\"thud\", {}, print, [data_node_6], [data_node_8], TaskId(\"t5\"))        scenario = Scenario(          \"scenario_name\",          [task_5, task_4, task_2, task_1, task_3],          {},          [],          ScenarioId(\"sce_id\"),      )        class MockOrchestrator(_Orchestrator):          submit_calls = []            @classmethod          def _lock_dn_output_and_create_job(              cls,              task: Task,              submit_id: str,              submit_entity_id: str,              callbacks: Optional[Iterable[Callable]] = None,              force: bool = False,          ) -> Job:              cls.submit_calls.append(task.id)              return super()._lock_dn_output_and_create_job(task, submit_id, submit_entity_id, callbacks, force)        with patch(\"src.taipy.core.task._task_manager._TaskManager._orchestrator\", new=MockOrchestrator):          with pytest.raises(NonExistingScenario):              _ScenarioManager._submit(scenario.id)          with pytest.raises(NonExistingScenario):              _ScenarioManager._submit(scenario)            # scenario and sequence do exist, but tasks does not exist.          # We expect an exception to be raised          _ScenarioManager._set(scenario)          with pytest.raises(NonExistingTask):              _ScenarioManager._submit(scenario.id)          with pytest.raises(NonExistingTask):              _ScenarioManager._submit(scenario)            # scenario, sequence, and tasks do exist.          # We expect all the tasks to be submitted once,          # and respecting specific constraints on the order          _TaskManager._set(task_1)          _TaskManager._set(task_2)          _TaskManager._set(task_3)          _TaskManager._set(task_4)          _TaskManager._set(task_5)          _ScenarioManager._submit(scenario.id)          submit_calls = _TaskManager._orchestrator().submit_calls          assert len(submit_calls) == 5          assert set(submit_calls) == {task_1.id, task_2.id, task_4.id, task_3.id, task_5.id}          assert submit_calls.index(task_2.id) < submit_calls.index(task_3.id)          assert submit_calls.index(task_1.id) < submit_calls.index(task_3.id)          assert submit_calls.index(task_1.id) < submit_calls.index(task_2.id)          assert submit_calls.index(task_1.id) < submit_calls.index(task_4.id)            _ScenarioManager._submit(scenario)          submit_calls = _TaskManager._orchestrator().submit_calls          assert len(submit_calls) == 10          assert set(submit_calls) == {task_1.id, task_2.id, task_4.id, task_3.id, task_5.id}          assert submit_calls.index(task_2.id) < submit_calls.index(task_3.id)          assert submit_calls.index(task_1.id) < submit_calls.index(task_3.id)          assert submit_calls.index(task_1.id) < submit_calls.index(task_2.id)          assert submit_calls.index(task_1.id) < submit_calls.index(task_4.id)      def my_print(a, b):      print(a + b)      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\")      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\")      json_dn_cfg = Config.configure_parquet_data_node(\"wrong_json_file_path\", default_path=\"wrong_path.json\")      task_cfg = Config.configure_task(\"task\", my_print, [csv_dn_cfg, pickle_dn_cfg], parquet_dn_cfg)      task_2_cfg = Config.configure_task(\"task2\", my_print, [csv_dn_cfg, parquet_dn_cfg], json_dn_cfg)      scenario_cfg = Config.configure_scenario(\"scenario\", [task_cfg, task_2_cfg])      sc_manager = _ScenarioManagerFactory._build_manager()      scenario = sc_manager._create(scenario_cfg)      sc_manager._submit(scenario)        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 scenario.get_inputs()      ]      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 scenario.data_nodes.values()          if input_dn not in scenario.get_inputs()      ]      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_one_input_dn_wrong_file_path(caplog):      csv_dn_cfg = Config.configure_csv_data_node(\"wrong_csv_file_path\", default_path=\"wrong_path.csv\")      pickle_dn_cfg = Config.configure_pickle_data_node(\"wrong_pickle_file_path\", default_data=\"value\")      parquet_dn_cfg = Config.configure_parquet_data_node(\"wrong_parquet_file_path\", default_path=\"wrong_path.parquet\")      json_dn_cfg = Config.configure_parquet_data_node(\"wrong_json_file_path\", default_path=\"wrong_path.json\")      task_cfg = Config.configure_task(\"task\", my_print, [csv_dn_cfg, pickle_dn_cfg], parquet_dn_cfg)      task_2_cfg = Config.configure_task(\"task2\", my_print, [csv_dn_cfg, parquet_dn_cfg], json_dn_cfg)      scenario_cfg = Config.configure_scenario(\"scenario\", [task_cfg, task_2_cfg])      sce_manager = _ScenarioManagerFactory._build_manager()      scenario = sce_manager._create(scenario_cfg)      sce_manager._submit(scenario)        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 scenario.get_inputs()          if input_dn.config_id == \"wrong_csv_file_path\"      ]      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 scenario.data_nodes.values()          if input_dn.config_id != \"wrong_csv_file_path\"      ]      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 subtraction(n1, n2):      return n1 - n2      def addition(n1, n2):      return n1 + n2      def test_scenarios_comparison_development_mode():      Config.configure_job_executions(mode=JobConfig._DEVELOPMENT_MODE)        scenario_config = Config.configure_scenario(          \"Awesome_scenario\",          [              Config.configure_task(                  \"mult_by_2\",                  mult_by_2,                  [Config.configure_data_node(\"foo\", \"in_memory\", Scope.SCENARIO, default_data=1)],                  Config.configure_data_node(\"bar\", \"in_memory\", Scope.SCENARIO, default_data=0),              )          ],          comparators={\"bar\": [subtraction], \"foo\": [subtraction, addition]},      )        _OrchestratorFactory._build_dispatcher()        assert scenario_config.comparators is not None      scenario_1 = _ScenarioManager._create(scenario_config)      scenario_2 = _ScenarioManager._create(scenario_config)        with pytest.raises(InsufficientScenarioToCompare):          _ScenarioManager._compare(scenario_1, data_node_config_id=\"bar\")        scenario_3 = Scenario(\"awesome_scenario_config\", [], {})      with pytest.raises(DifferentScenarioConfigs):          _ScenarioManager._compare(scenario_1, scenario_3, data_node_config_id=\"bar\")        _ScenarioManager._submit(scenario_1.id)      _ScenarioManager._submit(scenario_2.id)        bar_comparison = _ScenarioManager._compare(scenario_1, scenario_2, data_node_config_id=\"bar\")[\"bar\"]      assert bar_comparison[\"subtraction\"] == 0        foo_comparison = _ScenarioManager._compare(scenario_1, scenario_2, data_node_config_id=\"foo\")[\"foo\"]      assert len(foo_comparison.keys()) == 2      assert foo_comparison[\"addition\"] == 2      assert foo_comparison[\"subtraction\"] == 0        assert len(_ScenarioManager._compare(scenario_1, scenario_2).keys()) == 2        with pytest.raises(NonExistingScenarioConfig):          _ScenarioManager._compare(scenario_3, scenario_3)        with pytest.raises(NonExistingComparator):          _ScenarioManager._compare(scenario_1, scenario_2, data_node_config_id=\"abc\")      def test_scenarios_comparison_standalone_mode():      Config.configure_job_executions(mode=JobConfig._STANDALONE_MODE)        scenario_config = Config.configure_scenario(          \"Awesome_scenario\",          [              Config.configure_task(                  \"mult_by_2\",                  mult_by_2,                  [Config.configure_data_node(\"foo\", \"in_memory\", Scope.SCENARIO, default_data=1)],                  Config.configure_data_node(\"bar\", \"in_memory\", Scope.SCENARIO, default_data=0),              )          ],          comparators={\"bar\": [subtraction], \"foo\": [subtraction, addition]},      )        _OrchestratorFactory._build_dispatcher()        assert scenario_config.comparators is not None      scenario_1 = _ScenarioManager._create(scenario_config)      scenario_2 = _ScenarioManager._create(scenario_config)        with pytest.raises(InsufficientScenarioToCompare):          _ScenarioManager._compare(scenario_1, data_node_config_id=\"bar\")        scenario_3 = Scenario(\"awesome_scenario_config\", [], {})      with pytest.raises(DifferentScenarioConfigs):          _ScenarioManager._compare(scenario_1, scenario_3, data_node_config_id=\"bar\")        _ScenarioManager._submit(scenario_1.id)      _ScenarioManager._submit(scenario_2.id)        bar_comparison = _ScenarioManager._compare(scenario_1, scenario_2, data_node_config_id=\"bar\")[\"bar\"]      assert_true_after_time(lambda: bar_comparison[\"subtraction\"] == 0)        foo_comparison = _ScenarioManager._compare(scenario_1, scenario_2, data_node_config_id=\"foo\")[\"foo\"]      assert_true_after_time(lambda: len(foo_comparison.keys()) == 2)      assert_true_after_time(lambda: foo_comparison[\"addition\"] == 2)      assert_true_after_time(lambda: foo_comparison[\"subtraction\"] == 0)        assert_true_after_time(lambda: len(_ScenarioManager._compare(scenario_1, scenario_2).keys()) == 2)        with pytest.raises(NonExistingScenarioConfig):          _ScenarioManager._compare(scenario_3, scenario_3)        with pytest.raises(NonExistingComparator):          _ScenarioManager._compare(scenario_1, scenario_2, data_node_config_id=\"abc\")      def test_tags():      Config.configure_job_executions(mode=JobConfig._DEVELOPMENT_MODE)      _OrchestratorFactory._build_dispatcher()        cycle_1 = _CycleManager._create(Frequency.DAILY, name=\"today\", creation_date=datetime.now())      cycle_2 = _CycleManager._create(          Frequency.DAILY,          name=\"tomorrow\",          creation_date=datetime.now() + timedelta(days=1),      )      cycle_3 = _CycleManager._create(          Frequency.DAILY,          name=\"yesterday\",          creation_date=datetime.now() + timedelta(days=-1),      )        scenario_no_tag = Scenario(\"scenario_no_tag\", [], {}, [], ScenarioId(\"scenario_no_tag\"), cycle=cycle_1)      scenario_1_tag = Scenario(          \"scenario_1_tag\",          [],          {},          [],          ScenarioId(\"scenario_1_tag\"),          cycle=cycle_1,          tags={\"fst\"},      )      scenario_2_tags = Scenario(          \"scenario_2_tags\",          [],          {},          [],          ScenarioId(\"scenario_2_tags\"),          cycle=cycle_2,          tags={\"fst\", \"scd\"},      )        # Test has_tag      assert len(scenario_no_tag.tags) == 0      assert not scenario_no_tag.has_tag(\"fst\")      assert not scenario_no_tag.has_tag(\"scd\")        assert len(scenario_1_tag.tags) == 1      assert scenario_1_tag.has_tag(\"fst\")      assert not scenario_1_tag.has_tag(\"scd\")        assert len(scenario_2_tags.tags) == 2      assert scenario_2_tags.has_tag(\"fst\")      assert scenario_2_tags.has_tag(\"scd\")        # test get and set serialize/deserialize tags      _CycleManager._set(cycle_1)      _CycleManager._set(cycle_2)      _CycleManager._set(cycle_3)      _ScenarioManager._set(scenario_no_tag)      _ScenarioManager._set(scenario_1_tag)      _ScenarioManager._set(scenario_2_tags)        assert len(_ScenarioManager._get(ScenarioId(\"scenario_no_tag\")).tags) == 0      assert not _ScenarioManager._get(ScenarioId(\"scenario_no_tag\")).has_tag(\"fst\")      assert not _ScenarioManager._get(ScenarioId(\"scenario_no_tag\")).has_tag(\"scd\")        assert len(_ScenarioManager._get(ScenarioId(\"scenario_1_tag\")).tags) == 1      assert \"fst\" in _ScenarioManager._get(ScenarioId(\"scenario_1_tag\")).tags      assert \"scd\" not in _ScenarioManager._get(ScenarioId(\"scenario_1_tag\")).tags        assert len(_ScenarioManager._get(ScenarioId(\"scenario_2_tags\")).tags) == 2      assert \"fst\" in _ScenarioManager._get(ScenarioId(\"scenario_2_tags\")).tags      assert \"scd\" in _ScenarioManager._get(ScenarioId(\"scenario_2_tags\")).tags        # Test tag & untag        _ScenarioManager._tag(scenario_no_tag, \"thd\")  # add new tag      _ScenarioManager._untag(scenario_1_tag, \"NOT_EXISTING_TAG\")  # remove not existing tag does nothing      _ScenarioManager._untag(scenario_1_tag, \"fst\")  # remove `fst` tag        assert len(scenario_no_tag.tags) == 1      assert not scenario_no_tag.has_tag(\"fst\")      assert not scenario_no_tag.has_tag(\"scd\")      assert scenario_no_tag.has_tag(\"thd\")        assert len(scenario_1_tag.tags) == 0      assert not scenario_1_tag.has_tag(\"fst\")      assert not scenario_1_tag.has_tag(\"scd\")      assert not scenario_1_tag.has_tag(\"thd\")        assert len(scenario_2_tags.tags) == 2      assert scenario_2_tags.has_tag(\"fst\")      assert scenario_2_tags.has_tag(\"scd\")      assert not scenario_2_tags.has_tag(\"thd\")        _ScenarioManager._untag(scenario_no_tag, \"thd\")      _ScenarioManager._set(scenario_no_tag)      _ScenarioManager._tag(scenario_1_tag, \"fst\")      _ScenarioManager._set(scenario_1_tag)        # test getters      assert not _ScenarioManager._get_by_tag(cycle_3, \"fst\")      assert not _ScenarioManager._get_by_tag(cycle_3, \"scd\")      assert not _ScenarioManager._get_by_tag(cycle_3, \"thd\")        assert _ScenarioManager._get_by_tag(cycle_2, \"fst\") == scenario_2_tags      assert _ScenarioManager._get_by_tag(cycle_2, \"scd\") == scenario_2_tags      assert not _ScenarioManager._get_by_tag(cycle_2, \"thd\")        assert _ScenarioManager._get_by_tag(cycle_1, \"fst\") == scenario_1_tag      assert not _ScenarioManager._get_by_tag(cycle_1, \"scd\")      assert not _ScenarioManager._get_by_tag(cycle_1, \"thd\")        assert len(_ScenarioManager._get_all_by_tag(\"NOT_EXISTING\")) == 0      assert scenario_1_tag in _ScenarioManager._get_all_by_tag(\"fst\")      assert scenario_2_tags in _ScenarioManager._get_all_by_tag(\"fst\")      assert _ScenarioManager._get_all_by_tag(\"scd\") == [scenario_2_tags]      assert len(_ScenarioManager._get_all_by_tag(\"thd\")) == 0        # test tag cycle mgt        _ScenarioManager._tag(          scenario_no_tag, \"fst\"      )  # tag sc_no_tag should untag sc_1_tag with same cycle but not sc_2_tags        assert not _ScenarioManager._get_by_tag(cycle_3, \"fst\")      assert not _ScenarioManager._get_by_tag(cycle_3, \"scd\")      assert not _ScenarioManager._get_by_tag(cycle_3, \"thd\")        assert _ScenarioManager._get_by_tag(cycle_2, \"fst\") == scenario_2_tags      assert _ScenarioManager._get_by_tag(cycle_2, \"scd\") == scenario_2_tags      assert not _ScenarioManager._get_by_tag(cycle_2, \"thd\")        assert _ScenarioManager._get_by_tag(cycle_1, \"fst\") == scenario_no_tag      assert not _ScenarioManager._get_by_tag(cycle_1, \"scd\")      assert not _ScenarioManager._get_by_tag(cycle_1, \"thd\")        assert len(_ScenarioManager._get_all_by_tag(\"NOT_EXISTING\")) == 0      assert len(_ScenarioManager._get_all_by_tag(\"fst\")) == 2      assert scenario_2_tags in _ScenarioManager._get_all_by_tag(\"fst\")      assert scenario_no_tag in _ScenarioManager._get_all_by_tag(\"fst\")      assert _ScenarioManager._get_all_by_tag(\"scd\") == [scenario_2_tags]      assert len(_ScenarioManager._get_all_by_tag(\"thd\")) == 0      def test_authorized_tags():      Config.configure_job_executions(mode=JobConfig._DEVELOPMENT_MODE)        scenario = Scenario(\"scenario_1\", [], {\"authorized_tags\": [\"foo\", \"bar\"]}, [], ScenarioId(\"scenario_1\"))      scenario_2_cfg = Config.configure_scenario(\"scenario_2\", [], [], Frequency.DAILY, authorized_tags=[\"foo\", \"bar\"])        _OrchestratorFactory._build_dispatcher()        scenario_2 = _ScenarioManager._create(scenario_2_cfg)      _ScenarioManager._set(scenario)        assert len(scenario.tags) == 0      assert len(scenario_2.tags) == 0        with pytest.raises(UnauthorizedTagError):          _ScenarioManager._tag(scenario, \"baz\")          _ScenarioManager._tag(scenario_2, \"baz\")      assert len(scenario.tags) == 0      assert len(scenario_2.tags) == 0        _ScenarioManager._tag(scenario, \"foo\")      _ScenarioManager._tag(scenario_2, \"foo\")      assert len(scenario.tags) == 1      assert len(scenario_2.tags) == 1        _ScenarioManager._tag(scenario, \"bar\")      _ScenarioManager._tag(scenario_2, \"bar\")      assert len(scenario.tags) == 2      assert len(scenario_2.tags) == 2        _ScenarioManager._tag(scenario, \"foo\")      _ScenarioManager._tag(scenario_2, \"foo\")      assert len(scenario.tags) == 2      assert len(scenario_2.tags) == 2        _ScenarioManager._untag(scenario, \"foo\")      _ScenarioManager._untag(scenario_2, \"foo\")      assert len(scenario.tags) == 1      assert len(scenario_2.tags) == 1      def test_get_scenarios_by_config_id():      scenario_config_1 = Config.configure_scenario(\"s1\", sequence_configs=[])      scenario_config_2 = Config.configure_scenario(\"s2\", sequence_configs=[])      scenario_config_3 = Config.configure_scenario(\"s3\", sequence_configs=[])        s_1_1 = _ScenarioManager._create(scenario_config_1)      s_1_2 = _ScenarioManager._create(scenario_config_1)      s_1_3 = _ScenarioManager._create(scenario_config_1)      assert len(_ScenarioManager._get_all()) == 3        s_2_1 = _ScenarioManager._create(scenario_config_2)      s_2_2 = _ScenarioManager._create(scenario_config_2)      assert len(_ScenarioManager._get_all()) == 5        s_3_1 = _ScenarioManager._create(scenario_config_3)      assert len(_ScenarioManager._get_all()) == 6        s1_scenarios = _ScenarioManager._get_by_config_id(scenario_config_1.id)      assert len(s1_scenarios) == 3      assert sorted([s_1_1.id, s_1_2.id, s_1_3.id]) == sorted([scenario.id for scenario in s1_scenarios])        s2_scenarios = _ScenarioManager._get_by_config_id(scenario_config_2.id)      assert len(s2_scenarios) == 2      assert sorted([s_2_1.id, s_2_2.id]) == sorted([scenario.id for scenario in s2_scenarios])        s3_scenarios = _ScenarioManager._get_by_config_id(scenario_config_3.id)      assert len(s3_scenarios) == 1      assert sorted([s_3_1.id]) == sorted([scenario.id for scenario in s3_scenarios])      def test_get_scenarios_by_config_id_in_multiple_versions_environment():      scenario_config_1 = Config.configure_scenario(\"s1\", sequence_configs=[])      scenario_config_2 = Config.configure_scenario(\"s2\", sequence_configs=[])        _VersionManager._set_experiment_version(\"1.0\")      _ScenarioManager._create(scenario_config_1)      _ScenarioManager._create(scenario_config_1)      _ScenarioManager._create(scenario_config_1)      _ScenarioManager._create(scenario_config_2)      _ScenarioManager._create(scenario_config_2)        assert len(_ScenarioManager._get_by_config_id(scenario_config_1.id)) == 3      assert len(_ScenarioManager._get_by_config_id(scenario_config_2.id)) == 2        _VersionManager._set_experiment_version(\"2.0\")      _ScenarioManager._create(scenario_config_1)      _ScenarioManager._create(scenario_config_1)      _ScenarioManager._create(scenario_config_1)      _ScenarioManager._create(scenario_config_2)      _ScenarioManager._create(scenario_config_2)        assert len(_ScenarioManager._get_by_config_id(scenario_config_1.id)) == 3      assert len(_ScenarioManager._get_by_config_id(scenario_config_2.id)) == 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": "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 datetime import datetime, timedelta    import pytest    from src.taipy.core._orchestrator._orchestrator_factory import _OrchestratorFactory  from src.taipy.core._version._version_manager import _VersionManager  from src.taipy.core.config.job_config import JobConfig  from src.taipy.core.cycle._cycle_manager import _CycleManager  from src.taipy.core.cycle._cycle_manager_factory import _CycleManagerFactory  from src.taipy.core.data._data_manager import _DataManager  from src.taipy.core.data._data_manager_factory import _DataManagerFactory  from src.taipy.core.data.in_memory import InMemoryDataNode  from src.taipy.core.exceptions.exceptions import DeletingPrimaryScenario  from src.taipy.core.scenario._scenario_manager import _ScenarioManager  from src.taipy.core.scenario._scenario_manager_factory import _ScenarioManagerFactory  from src.taipy.core.scenario.scenario import Scenario  from src.taipy.core.scenario.scenario_id import ScenarioId  from src.taipy.core.sequence._sequence_manager import _SequenceManager  from src.taipy.core.sequence._sequence_manager_factory import _SequenceManagerFactory  from src.taipy.core.sequence.sequence import Sequence  from src.taipy.core.sequence.sequence_id import SequenceId  from src.taipy.core.task._task_manager import _TaskManager  from src.taipy.core.task._task_manager_factory import _TaskManagerFactory  from src.taipy.core.task.task import Task  from src.taipy.core.task.task_id import TaskId  from taipy.config.common.frequency import Frequency  from taipy.config.common.scope import Scope  from taipy.config.config import Config  from tests.core.conftest import init_managers      def test_set_and_get_scenario(cycle, init_sql_repo):      Config.configure_job_executions(mode=JobConfig._DEVELOPMENT_MODE)        init_managers()      _OrchestratorFactory._build_dispatcher()        scenario_id_1 = ScenarioId(\"scenario_id_1\")      scenario_1 = Scenario(\"scenario_name_1\", [], {}, [], scenario_id_1)        input_dn_2 = InMemoryDataNode(\"foo\", Scope.SCENARIO)      output_dn_2 = InMemoryDataNode(\"bar\", Scope.SCENARIO)      additional_dn_2 = InMemoryDataNode(\"zyx\", Scope.SCENARIO)      task_name_2 = \"task_2\"      task_2 = Task(task_name_2, {}, print, [input_dn_2], [output_dn_2], TaskId(\"task_id_2\"))      scenario_id_2 = ScenarioId(\"scenario_id_2\")      scenario_2 = Scenario(          \"scenario_name_2\",          [task_2],          {},          [additional_dn_2],          scenario_id_2,          datetime.now(),          True,          cycle,          sequences={\"sequence_2\": {\"tasks\": [task_2]}},      )        additional_dn_3 = InMemoryDataNode(\"baz\", Scope.SCENARIO)      task_name_3 = \"task_3\"      task_3 = Task(task_name_3, {}, print, id=TaskId(\"task_id_3\"))      scenario_3_with_same_id = Scenario(          \"scenario_name_3\",          [task_3],          {},          [additional_dn_3],          scenario_id_1,          datetime.now(),          False,          cycle,          sequences={\"sequence_3\": {}},      )        # No existing scenario      assert len(_ScenarioManager._get_all()) == 0      assert _ScenarioManager._get(scenario_id_1) is None      assert _ScenarioManager._get(scenario_1) is None      assert _ScenarioManager._get(scenario_id_2) is None      assert _ScenarioManager._get(scenario_2) is None        # Save one scenario. We expect to have only one scenario stored      _ScenarioManager._set(scenario_1)      assert len(_ScenarioManager._get_all()) == 1      assert _ScenarioManager._get(scenario_id_1).id == scenario_1.id      assert _ScenarioManager._get(scenario_id_1).config_id == scenario_1.config_id      assert len(_ScenarioManager._get(scenario_id_1).tasks) == 0      assert len(_ScenarioManager._get(scenario_id_1).additional_data_nodes) == 0      assert len(_ScenarioManager._get(scenario_id_1).data_nodes) == 0      assert len(_ScenarioManager._get(scenario_id_1).sequences) == 0      assert _ScenarioManager._get(scenario_1).id == scenario_1.id      assert _ScenarioManager._get(scenario_1).config_id == scenario_1.config_id      assert len(_ScenarioManager._get(scenario_1).tasks) == 0      assert len(_ScenarioManager._get(scenario_1).additional_data_nodes) == 0      assert len(_ScenarioManager._get(scenario_1).data_nodes) == 0      assert len(_ScenarioManager._get(scenario_1).sequences) == 0      assert _ScenarioManager._get(scenario_id_2) is None      assert _ScenarioManager._get(scenario_2) is None        # Save a second scenario. Now, we expect to have a total of two scenarios stored      _TaskManager._set(task_2)      _CycleManager._set(cycle)      _ScenarioManager._set(scenario_2)      _DataManager._set(additional_dn_2)      assert len(_ScenarioManager._get_all()) == 2      assert _ScenarioManager._get(scenario_id_1).id == scenario_1.id      assert _ScenarioManager._get(scenario_id_1).config_id == scenario_1.config_id      assert len(_ScenarioManager._get(scenario_id_1).tasks) == 0      assert len(_ScenarioManager._get(scenario_id_1).additional_data_nodes) == 0      assert len(_ScenarioManager._get(scenario_id_1).data_nodes) == 0      assert len(_ScenarioManager._get(scenario_id_1).sequences) == 0      assert _ScenarioManager._get(scenario_1).id == scenario_1.id      assert _ScenarioManager._get(scenario_1).config_id == scenario_1.config_id      assert len(_ScenarioManager._get(scenario_1).tasks) == 0      assert len(_ScenarioManager._get(scenario_1).additional_data_nodes) == 0      assert len(_ScenarioManager._get(scenario_1).data_nodes) == 0      assert len(_ScenarioManager._get(scenario_1).sequences) == 0      assert _ScenarioManager._get(scenario_id_2).id == scenario_2.id      assert _ScenarioManager._get(scenario_id_2).config_id == scenario_2.config_id      assert len(_ScenarioManager._get(scenario_id_2).tasks) == 1      assert len(_ScenarioManager._get(scenario_id_2).additional_data_nodes) == 1      assert len(_ScenarioManager._get(scenario_id_2).data_nodes) == 3      assert len(_ScenarioManager._get(scenario_id_2).sequences) == 1      assert _ScenarioManager._get(scenario_2).id == scenario_2.id      assert _ScenarioManager._get(scenario_2).config_id == scenario_2.config_id      assert len(_ScenarioManager._get(scenario_2).tasks) == 1      assert len(_ScenarioManager._get(scenario_2).additional_data_nodes) == 1      assert len(_ScenarioManager._get(scenario_2).data_nodes) == 3      assert len(_ScenarioManager._get(scenario_2).sequences) == 1      assert _TaskManager._get(task_2.id).id == task_2.id      assert _ScenarioManager._get(scenario_id_2).cycle == cycle      assert _ScenarioManager._get(scenario_2).cycle == cycle      assert _CycleManager._get(cycle.id).id == cycle.id        # We save the first scenario again. We expect nothing to change      _ScenarioManager._set(scenario_1)      assert len(_ScenarioManager._get_all()) == 2      assert _ScenarioManager._get(scenario_id_1).id == scenario_1.id      assert _ScenarioManager._get(scenario_id_1).config_id == scenario_1.config_id      assert len(_ScenarioManager._get(scenario_id_1).tasks) == 0      assert len(_ScenarioManager._get(scenario_id_1).additional_data_nodes) == 0      assert len(_ScenarioManager._get(scenario_id_1).data_nodes) == 0      assert len(_ScenarioManager._get(scenario_id_1).sequences) == 0      assert _ScenarioManager._get(scenario_1).id == scenario_1.id      assert _ScenarioManager._get(scenario_1).config_id == scenario_1.config_id      assert len(_ScenarioManager._get(scenario_1).tasks) == 0      assert len(_ScenarioManager._get(scenario_1).additional_data_nodes) == 0      assert len(_ScenarioManager._get(scenario_1).data_nodes) == 0      assert len(_ScenarioManager._get(scenario_1).sequences) == 0      assert _ScenarioManager._get(scenario_id_2).id == scenario_2.id      assert _ScenarioManager._get(scenario_id_2).config_id == scenario_2.config_id      assert len(_ScenarioManager._get(scenario_id_2).tasks) == 1      assert len(_ScenarioManager._get(scenario_id_2).additional_data_nodes) == 1      assert len(_ScenarioManager._get(scenario_id_2).data_nodes) == 3      assert len(_ScenarioManager._get(scenario_id_2).sequences) == 1      assert _ScenarioManager._get(scenario_2).id == scenario_2.id      assert _ScenarioManager._get(scenario_2).config_id == scenario_2.config_id      assert len(_ScenarioManager._get(scenario_2).tasks) == 1      assert len(_ScenarioManager._get(scenario_2).additional_data_nodes) == 1      assert len(_ScenarioManager._get(scenario_2).data_nodes) == 3      assert len(_ScenarioManager._get(scenario_2).sequences) == 1      assert _TaskManager._get(task_2.id).id == task_2.id      assert _CycleManager._get(cycle.id).id == cycle.id        # We save a third scenario with same id as the first one.      # We expect the first scenario to be updated      _DataManager._set(additional_dn_3)      _TaskManager._set(task_3)      _TaskManager._set(scenario_2.tasks[task_name_2])      _ScenarioManager._set(scenario_3_with_same_id)      assert len(_ScenarioManager._get_all()) == 2      assert _ScenarioManager._get(scenario_id_1).id == scenario_1.id      assert _ScenarioManager._get(scenario_id_1).config_id == scenario_3_with_same_id.config_id      assert len(_ScenarioManager._get(scenario_id_1).tasks) == 1      assert len(_ScenarioManager._get(scenario_id_1).additional_data_nodes) == 1      assert len(_ScenarioManager._get(scenario_id_1).data_nodes) == 1      assert len(_ScenarioManager._get(scenario_id_1).sequences) == 1      assert _ScenarioManager._get(scenario_id_1).cycle == cycle      assert _ScenarioManager._get(scenario_1).id == scenario_1.id      assert _ScenarioManager._get(scenario_1).config_id == scenario_3_with_same_id.config_id      assert len(_ScenarioManager._get(scenario_1).tasks) == 1      assert len(_ScenarioManager._get(scenario_1).additional_data_nodes) == 1      assert len(_ScenarioManager._get(scenario_1).data_nodes) == 1      assert len(_ScenarioManager._get(scenario_1).sequences) == 1      assert _ScenarioManager._get(scenario_1).cycle == cycle      assert _ScenarioManager._get(scenario_id_2).id == scenario_2.id      assert _ScenarioManager._get(scenario_id_2).config_id == scenario_2.config_id      assert len(_ScenarioManager._get(scenario_id_2).tasks) == 1      assert len(_ScenarioManager._get(scenario_id_2).additional_data_nodes) == 1      assert len(_ScenarioManager._get(scenario_id_2).data_nodes) == 3      assert len(_ScenarioManager._get(scenario_id_2).sequences) == 1      assert _ScenarioManager._get(scenario_2).id == scenario_2.id      assert _ScenarioManager._get(scenario_2).config_id == scenario_2.config_id      assert len(_ScenarioManager._get(scenario_2).tasks) == 1      assert len(_ScenarioManager._get(scenario_2).additional_data_nodes) == 1      assert len(_ScenarioManager._get(scenario_2).data_nodes) == 3      assert len(_ScenarioManager._get(scenario_2).sequences) == 1      assert _TaskManager._get(task_2.id).id == task_2.id      def test_get_all_on_multiple_versions_environment(init_sql_repo):      init_managers()        # Create 5 scenarios with 2 versions each      # Only version 1.0 has the scenario with config_id = \"config_id_1\"      # Only version 2.0 has the scenario with config_id = \"config_id_6\"      for version in range(1, 3):          for i in range(5):              _ScenarioManager._set(                  Scenario(f\"config_id_{i+version}\", [], {}, ScenarioId(f\"id{i}_v{version}\"), version=f\"{version}.0\")              )        _VersionManager._set_experiment_version(\"1.0\")      assert len(_ScenarioManager._get_all()) == 5      assert len(_ScenarioManager._get_all_by(filters=[{\"version\": \"1.0\", \"config_id\": \"config_id_1\"}])) == 1      assert len(_ScenarioManager._get_all_by(filters=[{\"version\": \"1.0\", \"config_id\": \"config_id_6\"}])) == 0        _VersionManager._set_experiment_version(\"2.0\")      assert len(_ScenarioManager._get_all()) == 5      assert len(_ScenarioManager._get_all_by(filters=[{\"version\": \"2.0\", \"config_id\": \"config_id_1\"}])) == 0      assert len(_ScenarioManager._get_all_by(filters=[{\"version\": \"2.0\", \"config_id\": \"config_id_6\"}])) == 1        _VersionManager._set_development_version(\"1.0\")      assert len(_ScenarioManager._get_all()) == 5      assert len(_ScenarioManager._get_all_by(filters=[{\"version\": \"1.0\", \"config_id\": \"config_id_1\"}])) == 1      assert len(_ScenarioManager._get_all_by(filters=[{\"version\": \"1.0\", \"config_id\": \"config_id_6\"}])) == 0        _VersionManager._set_development_version(\"2.0\")      assert len(_ScenarioManager._get_all()) == 5      assert len(_ScenarioManager._get_all_by(filters=[{\"version\": \"2.0\", \"config_id\": \"config_id_1\"}])) == 0      assert len(_ScenarioManager._get_all_by(filters=[{\"version\": \"2.0\", \"config_id\": \"config_id_6\"}])) == 1      def test_create_scenario_does_not_modify_config(init_sql_repo):      Config.configure_job_executions(mode=JobConfig._DEVELOPMENT_MODE)        init_managers()        creation_date_1 = datetime.now()      name_1 = \"name_1\"      scenario_config = Config.configure_scenario(\"sc\", None, None, Frequency.DAILY)        _OrchestratorFactory._build_dispatcher()        assert scenario_config.properties.get(\"name\") is None      assert len(scenario_config.properties) == 0        scenario = _ScenarioManager._create(scenario_config, creation_date=creation_date_1, name=name_1)      assert len(scenario_config.properties) == 0      assert len(scenario.properties) == 1      assert scenario.properties.get(\"name\") == name_1      assert scenario.name == name_1        scenario.properties[\"foo\"] = \"bar\"      _ScenarioManager._set(scenario)      assert len(scenario_config.properties) == 0      assert len(scenario.properties) == 2      assert scenario.properties.get(\"foo\") == \"bar\"      assert scenario.properties.get(\"name\") == name_1      assert scenario.name == name_1        scenario_2 = _ScenarioManager._create(scenario_config, creation_date=creation_date_1)      assert scenario_2.name is None      def test_create_and_delete_scenario(init_sql_repo):      Config.configure_job_executions(mode=JobConfig._DEVELOPMENT_MODE)        init_managers()        creation_date_1 = datetime.now()      creation_date_2 = creation_date_1 + timedelta(minutes=10)        name_1 = \"name_1\"        _ScenarioManager._delete_all()      assert len(_ScenarioManager._get_all()) == 0        scenario_config = Config.configure_scenario(\"sc\", None, None, Frequency.DAILY)        _OrchestratorFactory._build_dispatcher()        scenario_1 = _ScenarioManager._create(scenario_config, creation_date=creation_date_1, name=name_1)      assert scenario_1.config_id == \"sc\"      assert scenario_1.sequences == {}      assert scenario_1.tasks == {}      assert scenario_1.additional_data_nodes == {}      assert scenario_1.data_nodes == {}      assert scenario_1.cycle.frequency == Frequency.DAILY      assert scenario_1.is_primary      assert scenario_1.cycle.creation_date == creation_date_1      assert scenario_1.cycle.start_date.date() == creation_date_1.date()      assert scenario_1.cycle.end_date.date() == creation_date_1.date()      assert scenario_1.creation_date == creation_date_1      assert scenario_1.name == name_1      assert scenario_1.properties[\"name\"] == name_1      assert scenario_1.tags == set()        cycle_id_1 = scenario_1.cycle.id      assert _CycleManager._get(cycle_id_1).id == cycle_id_1      _ScenarioManager._delete(scenario_1.id)      assert _ScenarioManager._get(scenario_1.id) is None      assert _CycleManager._get(cycle_id_1) is None        # Recreate scenario_1      scenario_1 = _ScenarioManager._create(scenario_config, creation_date=creation_date_1, name=name_1)        scenario_2 = _ScenarioManager._create(scenario_config, creation_date=creation_date_2)      assert scenario_2.config_id == \"sc\"      assert scenario_2.sequences == {}      assert scenario_2.tasks == {}      assert scenario_2.additional_data_nodes == {}      assert scenario_2.data_nodes == {}      assert scenario_2.cycle.frequency == Frequency.DAILY      assert not scenario_2.is_primary      assert scenario_2.cycle.creation_date == creation_date_1      assert scenario_2.cycle.start_date.date() == creation_date_2.date()      assert scenario_2.cycle.end_date.date() == creation_date_2.date()      assert scenario_2.properties.get(\"name\") is None      assert scenario_2.tags == set()        assert scenario_1 != scenario_2      assert scenario_1.cycle == scenario_2.cycle        assert len(_ScenarioManager._get_all()) == 2      with pytest.raises(DeletingPrimaryScenario):          _ScenarioManager._delete(              scenario_1.id,          )        _ScenarioManager._delete(          scenario_2.id,      )      assert len(_ScenarioManager._get_all()) == 1      _ScenarioManager._delete(scenario_1.id)      assert len(_ScenarioManager._get_all()) == 0      def mult_by_2(nb: int):      return nb * 2      def mult_by_3(nb: int):      return nb * 3      def mult_by_4(nb: int):      return nb * 4      def test_scenario_manager_only_creates_data_node_once(init_sql_repo):      Config.configure_job_executions(mode=JobConfig._DEVELOPMENT_MODE)        init_managers()        # dn_1 ---> mult_by_2 ---> dn_2 ---> mult_by_3 ---> dn_6      # dn_1 ---> mult_by_4 ---> dn_4        dn_config_1 = Config.configure_data_node(\"foo\", \"in_memory\", Scope.GLOBAL, default_data=1)      dn_config_2 = Config.configure_data_node(\"bar\", \"in_memory\", Scope.CYCLE, default_data=0)      dn_config_6 = Config.configure_data_node(\"baz\", \"in_memory\", Scope.CYCLE, default_data=0)      dn_config_4 = Config.configure_data_node(\"qux\", \"in_memory\", Scope.SCENARIO, default_data=0)      task_mult_by_2_config = Config.configure_task(\"mult_by_2\", mult_by_2, [dn_config_1], dn_config_2)      task_mult_by_3_config = Config.configure_task(\"mult_by_3\", mult_by_3, [dn_config_2], dn_config_6)      task_mult_by_4_config = Config.configure_task(\"mult_by_4\", mult_by_4, [dn_config_1], dn_config_4)      scenario_config = Config.configure_scenario(          \"awesome_scenario\", [task_mult_by_2_config, task_mult_by_3_config, task_mult_by_4_config], None, Frequency.DAILY      )      scenario_config.add_sequences(          {\"by_6\": [task_mult_by_2_config, task_mult_by_3_config], \"by_4\": [task_mult_by_4_config]}      )        _OrchestratorFactory._build_dispatcher()        assert len(_DataManager._get_all()) == 0      assert len(_TaskManager._get_all()) == 0      assert len(_SequenceManager._get_all()) == 0      assert len(_ScenarioManager._get_all()) == 0      assert len(_CycleManager._get_all()) == 0        scenario_1 = _ScenarioManager._create(scenario_config)        assert len(_DataManager._get_all()) == 4      assert len(_TaskManager._get_all()) == 3      assert len(_SequenceManager._get_all()) == 2      assert len(_ScenarioManager._get_all()) == 1      assert scenario_1.foo.read() == 1      assert scenario_1.bar.read() == 0      assert scenario_1.baz.read() == 0      assert scenario_1.qux.read() == 0      assert scenario_1.by_6._get_sorted_tasks()[0][0].config_id == task_mult_by_2_config.id      assert scenario_1.by_6._get_sorted_tasks()[1][0].config_id == task_mult_by_3_config.id      assert scenario_1.by_4._get_sorted_tasks()[0][0].config_id == task_mult_by_4_config.id      assert scenario_1.tasks.keys() == {task_mult_by_2_config.id, task_mult_by_3_config.id, task_mult_by_4_config.id}        scenario_1_sorted_tasks = scenario_1._get_sorted_tasks()      expected = [{task_mult_by_2_config.id, task_mult_by_4_config.id}, {task_mult_by_3_config.id}]      for i, list_tasks_by_level in enumerate(scenario_1_sorted_tasks):          assert set([t.config_id for t in list_tasks_by_level]) == expected[i]      assert scenario_1.cycle.frequency == Frequency.DAILY        _ScenarioManager._create(scenario_config)        assert len(_DataManager._get_all()) == 5      assert len(_TaskManager._get_all()) == 4      assert len(_SequenceManager._get_all()) == 4      assert len(_ScenarioManager._get_all()) == 2      def test_get_scenarios_by_config_id(init_sql_repo):      init_managers()        scenario_config_1 = Config.configure_scenario(\"s1\", sequence_configs=[])      scenario_config_2 = Config.configure_scenario(\"s2\", sequence_configs=[])      scenario_config_3 = Config.configure_scenario(\"s3\", sequence_configs=[])        s_1_1 = _ScenarioManager._create(scenario_config_1)      s_1_2 = _ScenarioManager._create(scenario_config_1)      s_1_3 = _ScenarioManager._create(scenario_config_1)      assert len(_ScenarioManager._get_all()) == 3        s_2_1 = _ScenarioManager._create(scenario_config_2)      s_2_2 = _ScenarioManager._create(scenario_config_2)      assert len(_ScenarioManager._get_all()) == 5        s_3_1 = _ScenarioManager._create(scenario_config_3)      assert len(_ScenarioManager._get_all()) == 6        s1_scenarios = _ScenarioManager._get_by_config_id(scenario_config_1.id)      assert len(s1_scenarios) == 3      assert sorted([s_1_1.id, s_1_2.id, s_1_3.id]) == sorted([scenario.id for scenario in s1_scenarios])        s2_scenarios = _ScenarioManager._get_by_config_id(scenario_config_2.id)      assert len(s2_scenarios) == 2      assert sorted([s_2_1.id, s_2_2.id]) == sorted([scenario.id for scenario in s2_scenarios])        s3_scenarios = _ScenarioManager._get_by_config_id(scenario_config_3.id)      assert len(s3_scenarios) == 1      assert sorted([s_3_1.id]) == sorted([scenario.id for scenario in s3_scenarios])      def test_get_scenarios_by_config_id_in_multiple_versions_environment(init_sql_repo):      init_managers()        scenario_config_1 = Config.configure_scenario(\"s1\", sequence_configs=[])      scenario_config_2 = Config.configure_scenario(\"s2\", sequence_configs=[])        _VersionManager._set_experiment_version(\"1.0\")      _ScenarioManager._create(scenario_config_1)      _ScenarioManager._create(scenario_config_1)      _ScenarioManager._create(scenario_config_1)      _ScenarioManager._create(scenario_config_2)      _ScenarioManager._create(scenario_config_2)        assert len(_ScenarioManager._get_by_config_id(scenario_config_1.id)) == 3      assert len(_ScenarioManager._get_by_config_id(scenario_config_2.id)) == 2        _VersionManager._set_experiment_version(\"2.0\")      _ScenarioManager._create(scenario_config_1)      _ScenarioManager._create(scenario_config_1)      _ScenarioManager._create(scenario_config_1)      _ScenarioManager._create(scenario_config_2)      _ScenarioManager._create(scenario_config_2)        assert len(_ScenarioManager._get_by_config_id(scenario_config_1.id)) == 3      assert len(_ScenarioManager._get_by_config_id(scenario_config_2.id)) == 2 "}
{"text": "from datetime import datetime, timedelta  from unittest import mock    import pytest    from src.taipy.core.common._utils import _Subscriber  from src.taipy.core.cycle._cycle_manager_factory import _CycleManagerFactory  from src.taipy.core.cycle.cycle import Cycle, CycleId  from src.taipy.core.data._data_manager_factory import _DataManagerFactory  from src.taipy.core.data.in_memory import DataNode, InMemoryDataNode  from src.taipy.core.data.pickle import PickleDataNode  from src.taipy.core.exceptions.exceptions import SequenceTaskDoesNotExistInScenario  from src.taipy.core.scenario._scenario_manager_factory import _ScenarioManagerFactory  from src.taipy.core.scenario.scenario import Scenario  from src.taipy.core.scenario.scenario_id import ScenarioId  from src.taipy.core.sequence.sequence import Sequence  from src.taipy.core.sequence.sequence_id import SequenceId  from src.taipy.core.task._task_manager_factory import _TaskManagerFactory  from src.taipy.core.task.task import Task, TaskId  from taipy.config import Frequency  from taipy.config.common.scope import Scope  from taipy.config.exceptions.exceptions import InvalidConfigurationId      def test_create_primary_scenario(cycle):      scenario = Scenario(\"foo\", set(), {\"key\": \"value\"}, is_primary=True, cycle=cycle)      assert scenario.id is not None      assert scenario.config_id == \"foo\"      assert scenario.tasks == {}      assert scenario.additional_data_nodes == {}      assert scenario.data_nodes == {}      assert scenario.sequences == {}      assert scenario.properties == {\"key\": \"value\"}      assert scenario.key == \"value\"      assert scenario.creation_date is not None      assert scenario.is_primary      assert scenario.cycle == cycle      assert scenario.tags == set()      assert scenario.get_simple_label() == scenario.config_id        with mock.patch(\"src.taipy.core.get\") as get_mck:            class MockOwner:              label = \"owner_label\"                def get_label(self):                  return self.label            get_mck.return_value = MockOwner()          assert scenario.get_label() == \"owner_label > \" + scenario.config_id      def test_create_scenario_at_time(current_datetime):      scenario = Scenario(\"bar\", set(), {}, set(), ScenarioId(\"baz\"), creation_date=current_datetime)      assert scenario.id == \"baz\"      assert scenario.config_id == \"bar\"      assert scenario.tasks == {}      assert scenario.additional_data_nodes == {}      assert scenario.data_nodes == {}      assert scenario.sequences == {}      assert scenario.properties == {}      assert scenario.creation_date == current_datetime      assert not scenario.is_primary      assert scenario.cycle is None      assert scenario.tags == set()      assert scenario.get_simple_label() == scenario.config_id      assert scenario.get_label() == scenario.config_id      def test_create_scenario_with_task_and_additional_dn_and_sequence():      dn_1 = PickleDataNode(\"xyz\", Scope.SCENARIO)      dn_2 = PickleDataNode(\"abc\", Scope.SCENARIO)      task = Task(\"qux\", {}, print, [dn_1])        scenario = Scenario(\"quux\", set([task]), {}, set([dn_2]), sequences={\"acb\": {\"tasks\": [task]}})      sequence = scenario.sequences[\"acb\"]      assert scenario.id is not None      assert scenario.config_id == \"quux\"      assert len(scenario.tasks) == 1      assert len(scenario.additional_data_nodes) == 1      assert len(scenario.data_nodes) == 2      assert len(scenario.sequences) == 1      assert scenario.qux == task      assert scenario.xyz == dn_1      assert scenario.abc == dn_2      assert scenario.acb == sequence      assert scenario.properties == {}      assert scenario.tags == set()      def test_create_scenario_invalid_config_id():      with pytest.raises(InvalidConfigurationId):          Scenario(\"foo bar\", [], {})      def test_create_scenario_and_add_sequences():      input_1 = PickleDataNode(\"input_1\", Scope.SCENARIO)      output_1 = PickleDataNode(\"output_1\", Scope.SCENARIO)      output_2 = PickleDataNode(\"output_2\", Scope.SCENARIO)      additional_dn_1 = PickleDataNode(\"additional_1\", Scope.SCENARIO)      additional_dn_2 = PickleDataNode(\"additional_2\", Scope.SCENARIO)      task_1 = Task(\"task_1\", {}, print, [input_1], [output_1], TaskId(\"task_id_1\"))      task_2 = Task(\"task_2\", {}, print, [output_1], [output_2], TaskId(\"task_id_2\"))        data_manager = _DataManagerFactory._build_manager()      task_manager = _TaskManagerFactory._build_manager()      data_manager._set(input_1)      data_manager._set(output_1)      data_manager._set(output_2)      data_manager._set(additional_dn_1)      data_manager._set(additional_dn_2)      task_manager._set(task_1)      task_manager._set(task_2)        scenario = Scenario(\"scenario\", set([task_1]), {})      scenario.sequences = {\"sequence_1\": {\"tasks\": [task_1]}, \"sequence_2\": {\"tasks\": []}}      assert scenario.id is not None      assert scenario.config_id == \"scenario\"      assert len(scenario.tasks) == 1      assert scenario.tasks.keys() == {task_1.config_id}      assert len(scenario.additional_data_nodes) == 0      assert scenario.additional_data_nodes == {}      assert len(scenario.data_nodes) == 2      assert scenario.data_nodes == {          input_1.config_id: input_1,          output_1.config_id: output_1,      }      assert len(scenario.sequences) == 2      assert scenario.sequence_1 == scenario.sequences[\"sequence_1\"]      assert scenario.sequence_2 == scenario.sequences[\"sequence_2\"]      assert scenario.sequences == {\"sequence_1\": scenario.sequence_1, \"sequence_2\": scenario.sequence_2}      def test_create_scenario_overlapping_sequences():      input_1 = PickleDataNode(\"input_1\", Scope.SCENARIO)      output_1 = PickleDataNode(\"output_1\", Scope.SCENARIO)      output_2 = PickleDataNode(\"output_2\", Scope.SCENARIO)      additional_dn_1 = PickleDataNode(\"additional_1\", Scope.SCENARIO)      additional_dn_2 = PickleDataNode(\"additional_2\", Scope.SCENARIO)      task_1 = Task(\"task_1\", {}, print, [input_1], [output_1], TaskId(\"task_id_1\"))      task_2 = Task(\"task_2\", {}, print, [output_1], [output_2], TaskId(\"task_id_2\"))      data_manager = _DataManagerFactory._build_manager()      task_manager = _TaskManagerFactory._build_manager()      data_manager._set(input_1)      data_manager._set(output_1)      data_manager._set(output_2)      data_manager._set(additional_dn_1)      data_manager._set(additional_dn_2)      task_manager._set(task_1)      task_manager._set(task_2)        scenario = Scenario(\"scenario\", set([task_1, task_2]), {})      scenario.add_sequence(\"sequence_1\", [task_1])      scenario.add_sequence(\"sequence_2\", [task_1, task_2])      assert scenario.id is not None      assert scenario.config_id == \"scenario\"      assert len(scenario.tasks) == 2      assert scenario.tasks.keys() == {task_1.config_id, task_2.config_id}      assert len(scenario.additional_data_nodes) == 0      assert scenario.additional_data_nodes == {}      assert len(scenario.data_nodes) == 3      assert scenario.data_nodes == {          input_1.config_id: input_1,          output_1.config_id: output_1,          output_2.config_id: output_2,      }      sequence_1 = scenario.sequences[\"sequence_1\"]      sequence_2 = scenario.sequences[\"sequence_2\"]      assert scenario.sequences == {\"sequence_1\": sequence_1, \"sequence_2\": sequence_2}      scenario.remove_sequences([\"sequence_2\"])      assert scenario.sequences == {\"sequence_1\": sequence_1}      scenario.remove_sequences([\"sequence_1\"])      assert scenario.sequences == {}      def test_create_scenario_one_additional_dn():      input_1 = PickleDataNode(\"input_1\", Scope.SCENARIO)      input_2 = PickleDataNode(\"input_2\", Scope.SCENARIO)      output_1 = PickleDataNode(\"output_1\", Scope.SCENARIO)      output_2 = PickleDataNode(\"output_2\", Scope.SCENARIO)      additional_dn_1 = PickleDataNode(\"additional_1\", Scope.SCENARIO)      additional_dn_2 = PickleDataNode(\"additional_2\", Scope.SCENARIO)      task_1 = Task(\"task_1\", {}, print, [input_1], [output_1], TaskId(\"task_id_1\"))      task_2 = Task(\"task_2\", {}, print, [input_2], [output_2], TaskId(\"task_id_2\"))      data_manager = _DataManagerFactory._build_manager()      task_manager = _TaskManagerFactory._build_manager()      data_manager._set(input_1)      data_manager._set(output_1)      data_manager._set(input_2)      data_manager._set(output_2)      data_manager._set(additional_dn_1)      data_manager._set(additional_dn_2)      task_manager._set(task_1)      task_manager._set(task_2)        scenario = Scenario(\"scenario\", set(), {}, set([additional_dn_1]))      assert scenario.id is not None      assert scenario.config_id == \"scenario\"      assert len(scenario.tasks) == 0      assert len(scenario.additional_data_nodes) == 1      assert len(scenario.data_nodes) == 1      assert scenario.tasks == {}      assert scenario.additional_data_nodes == {additional_dn_1.config_id: additional_dn_1}      assert scenario.data_nodes == {additional_dn_1.config_id: additional_dn_1}      def test_create_scenario_wth_additional_dns():      input_1 = PickleDataNode(\"input_1\", Scope.SCENARIO)      input_2 = PickleDataNode(\"input_2\", Scope.SCENARIO)      output_1 = PickleDataNode(\"output_1\", Scope.SCENARIO)      output_2 = PickleDataNode(\"output_2\", Scope.SCENARIO)      additional_dn_1 = PickleDataNode(\"additional_1\", Scope.SCENARIO)      additional_dn_2 = PickleDataNode(\"additional_2\", Scope.SCENARIO)      task_1 = Task(\"task_1\", {}, print, [input_1], [output_1], TaskId(\"task_id_1\"))      task_2 = Task(\"task_2\", {}, print, [input_2], [output_2], TaskId(\"task_id_2\"))      data_manager = _DataManagerFactory._build_manager()      task_manager = _TaskManagerFactory._build_manager()      data_manager._set(input_1)      data_manager._set(output_1)      data_manager._set(input_2)      data_manager._set(output_2)      data_manager._set(additional_dn_1)      data_manager._set(additional_dn_2)      task_manager._set(task_1)      task_manager._set(task_2)        scenario = Scenario(\"scenario\", set(), {}, set([additional_dn_1, additional_dn_2]))      assert scenario.id is not None      assert scenario.config_id == \"scenario\"      assert len(scenario.tasks) == 0      assert len(scenario.additional_data_nodes) == 2      assert len(scenario.data_nodes) == 2      assert scenario.tasks == {}      assert scenario.additional_data_nodes == {          additional_dn_1.config_id: additional_dn_1,          additional_dn_2.config_id: additional_dn_2,      }      assert scenario.data_nodes == {          additional_dn_1.config_id: additional_dn_1,          additional_dn_2.config_id: additional_dn_2,      }        scenario_1 = Scenario(\"scenario_1\", set([task_1]), {}, set([additional_dn_1]))      assert scenario_1.id is not None      assert scenario_1.config_id == \"scenario_1\"      assert len(scenario_1.tasks) == 1      assert len(scenario_1.additional_data_nodes) == 1      assert len(scenario_1.data_nodes) == 3      assert scenario_1.tasks.keys() == {task_1.config_id}      assert scenario_1.additional_data_nodes == {          additional_dn_1.config_id: additional_dn_1,      }      assert scenario_1.data_nodes == {          input_1.config_id: input_1,          output_1.config_id: output_1,          additional_dn_1.config_id: additional_dn_1,      }        scenario_2 = Scenario(\"scenario_2\", set([task_1, task_2]), {}, set([additional_dn_1, additional_dn_2]))      assert scenario_2.id is not None      assert scenario_2.config_id == \"scenario_2\"      assert len(scenario_2.tasks) == 2      assert len(scenario_2.additional_data_nodes) == 2      assert len(scenario_2.data_nodes) == 6      assert scenario_2.tasks.keys() == {task_1.config_id, task_2.config_id}      assert scenario_2.additional_data_nodes == {          additional_dn_1.config_id: additional_dn_1,          additional_dn_2.config_id: additional_dn_2,      }      assert {dn_config_id: dn.id for dn_config_id, dn in scenario_2.data_nodes.items()} == {          input_1.config_id: input_1.id,          output_1.config_id: output_1.id,          input_2.config_id: input_2.id,          output_2.config_id: output_2.id,          additional_dn_1.config_id: additional_dn_1.id,          additional_dn_2.config_id: additional_dn_2.id,      }      def test_raise_sequence_tasks_not_in_scenario(data_node):      task_1 = Task(\"task_1\", {}, print, output=[data_node])      task_2 = Task(\"task_2\", {}, print, input=[data_node])        with pytest.raises(SequenceTaskDoesNotExistInScenario) as err:          Scenario(\"scenario\", [], {}, sequences={\"sequence\": {\"tasks\": [task_1]}}, scenario_id=\"SCENARIO_scenario\")      assert err.value.args == ([task_1.id], \"sequence\", \"SCENARIO_scenario\")        with pytest.raises(SequenceTaskDoesNotExistInScenario) as err:          Scenario(              \"scenario\",              [task_1],              {},              sequences={\"sequence\": {\"tasks\": [task_1, task_2]}},              scenario_id=\"SCENARIO_scenario\",          )      assert err.value.args == ([task_2.id], \"sequence\", \"SCENARIO_scenario\")        Scenario(\"scenario\", [task_1], {}, sequences={\"sequence\": {\"tasks\": [task_1]}})      Scenario(          \"scenario\",          [task_1, task_2],          {},          sequences={\"sequence_1\": {\"tasks\": [task_1]}, \"sequence_2\": {\"tasks\": [task_1, task_2]}},      )      def test_raise_tasks_not_in_scenario_with_add_sequence_api(data_node):      task_1 = Task(\"task_1\", {}, print, output=[data_node])      task_2 = Task(\"task_2\", {}, print, input=[data_node])      scenario = Scenario(\"scenario\", [task_1], {})      scenario_manager = _ScenarioManagerFactory._build_manager()      task_manager = _TaskManagerFactory._build_manager()      scenario_manager._set(scenario)      task_manager._set(task_1)      task_manager._set(task_2)        scenario.add_sequences({\"sequence_1\": {}})        with pytest.raises(SequenceTaskDoesNotExistInScenario) as err:          scenario.add_sequence(\"sequence_2\", [task_2])      assert err.value.args == ([task_2.id], \"sequence_2\", scenario.id)        scenario.add_sequence(\"sequence_3\", [task_1])        with pytest.raises(SequenceTaskDoesNotExistInScenario) as err:          scenario.add_sequences({\"sequence_4\": [task_2]})      assert err.value.args == ([task_2.id], \"sequence_4\", scenario.id)        with pytest.raises(SequenceTaskDoesNotExistInScenario) as err:          scenario.add_sequences({\"sequence_5\": [task_1, task_2]})      assert err.value.args == ([task_2.id], \"sequence_5\", scenario.id)        scenario.tasks = [task_1, task_2]      scenario.add_sequence(\"sequence_6\", [task_1, task_2])      def test_add_property_to_scenario():      scenario = Scenario(\"foo\", [], {\"key\": \"value\"})      assert scenario.properties == {\"key\": \"value\"}      assert scenario.key == \"value\"        scenario.properties[\"new_key\"] = \"new_value\"        assert scenario.properties == {\"key\": \"value\", \"new_key\": \"new_value\"}      assert scenario.key == \"value\"      assert scenario.new_key == \"new_value\"      def test_add_cycle_to_scenario(cycle):      scenario = Scenario(\"foo\", [], {})      assert scenario.cycle is None      _CycleManagerFactory._build_manager()._set(cycle)      scenario.cycle = cycle        assert scenario.cycle == cycle      def test_add_and_remove_subscriber():      scenario = Scenario(\"foo\", [], {})        scenario._add_subscriber(print)      assert len(scenario.subscribers) == 1        scenario._remove_subscriber(print)      assert len(scenario.subscribers) == 0      def test_add_and_remove_tag():      scenario = Scenario(\"foo\", [], {})        assert len(scenario.tags) == 0      scenario._add_tag(\"tag\")      assert len(scenario.tags) == 1        scenario._remove_tag(\"tag\")      assert len(scenario.tags) == 0      def test_auto_set_and_reload(cycle, current_datetime, task, data_node):      scenario_1 = Scenario(          \"foo\",          set(),          {\"name\": \"bar\"},          set(),          creation_date=current_datetime,          is_primary=True,          cycle=None,      )      additional_dn = InMemoryDataNode(\"additional_dn\", Scope.SCENARIO)      example_date = datetime.fromisoformat(\"2021-11-11T11:11:01.000001\")      tmp_cycle = Cycle(          Frequency.WEEKLY,          {},          creation_date=example_date,          start_date=example_date,          end_date=example_date,          name=\"cc\",          id=CycleId(\"tmp_cc_id\"),      )        sequence_1_name = \"sequence_1\"      sequence_1 = Sequence({}, [], SequenceId(f\"SEQUENCE_{sequence_1_name}_{scenario_1.id}\"))        tmp_sequence_name = \"tmp_sequence\"      tmp_sequence = Sequence(          {},          [],          SequenceId(f\"SEQUENCE_{tmp_sequence_name}_{scenario_1.id}\"),      )        _TaskManagerFactory._build_manager()._set(task)      _DataManagerFactory._build_manager()._set(data_node)      _DataManagerFactory._build_manager()._set(additional_dn)      _CycleManagerFactory._build_manager()._set(cycle)      scenario_manager = _ScenarioManagerFactory._build_manager()      cycle_manager = _CycleManagerFactory._build_manager()      cycle_manager._set(cycle)      cycle_manager._set(tmp_cycle)      scenario_manager._set(scenario_1)        scenario_2 = scenario_manager._get(scenario_1)      assert scenario_1.config_id == \"foo\"      assert scenario_2.config_id == \"foo\"        # auto set & reload on name attribute      assert scenario_1.name == \"bar\"      assert scenario_2.name == \"bar\"      scenario_1.name = \"zab\"      assert scenario_1.name == \"zab\"      assert scenario_2.name == \"zab\"      scenario_2.name = \"baz\"      assert scenario_1.name == \"baz\"      assert scenario_2.name == \"baz\"        # auto set & reload on sequences attribute      assert len(scenario_1.sequences) == 0      assert len(scenario_2.sequences) == 0      scenario_1.sequences = {tmp_sequence_name: {}}      assert len(scenario_1.sequences) == 1      assert scenario_1.sequences[tmp_sequence_name] == tmp_sequence      assert len(scenario_2.sequences) == 1      assert scenario_2.sequences[tmp_sequence_name] == tmp_sequence      scenario_2.add_sequences({sequence_1_name: []})      assert len(scenario_1.sequences) == 2      assert scenario_1.sequences == {sequence_1_name: sequence_1, tmp_sequence_name: tmp_sequence}      assert len(scenario_2.sequences) == 2      assert scenario_2.sequences == {sequence_1_name: sequence_1, tmp_sequence_name: tmp_sequence}      scenario_2.remove_sequences([tmp_sequence_name])      assert len(scenario_1.sequences) == 1      assert scenario_1.sequences == {sequence_1_name: sequence_1}      assert len(scenario_2.sequences) == 1      assert scenario_2.sequences == {sequence_1_name: sequence_1}        assert len(scenario_1.tasks) == 0      assert len(scenario_1.data_nodes) == 0      scenario_1.tasks = {task}      assert len(scenario_1.tasks) == 1      assert scenario_1.tasks[task.config_id] == task      assert len(scenario_1.data_nodes) == 2      assert len(scenario_2.tasks) == 1      assert scenario_2.tasks[task.config_id] == task      assert len(scenario_2.data_nodes) == 2        assert len(scenario_1.additional_data_nodes) == 0      scenario_1.additional_data_nodes = {additional_dn}      assert len(scenario_1.additional_data_nodes) == 1      assert scenario_1.additional_data_nodes[additional_dn.config_id] == additional_dn      assert len(scenario_1.data_nodes) == 3      assert len(scenario_2.additional_data_nodes) == 1      assert scenario_2.additional_data_nodes[additional_dn.config_id] == additional_dn      assert len(scenario_2.data_nodes) == 3        new_datetime = current_datetime + timedelta(1)      new_datetime_1 = current_datetime + timedelta(2)        # auto set & reload on name attribute      assert scenario_1.creation_date == current_datetime      assert scenario_2.creation_date == current_datetime      scenario_1.creation_date = new_datetime_1      assert scenario_1.creation_date == new_datetime_1      assert scenario_2.creation_date == new_datetime_1      scenario_2.creation_date = new_datetime      assert scenario_1.creation_date == new_datetime      assert scenario_2.creation_date == new_datetime        # auto set & reload on cycle attribute      assert scenario_1.cycle is None      assert scenario_2.cycle is None      scenario_1.cycle = tmp_cycle      assert scenario_1.cycle == tmp_cycle      assert scenario_2.cycle == tmp_cycle      scenario_2.cycle = cycle      assert scenario_1.cycle == cycle      assert scenario_2.cycle == cycle        # auto set & reload on is_primary attribute      assert scenario_1.is_primary      assert scenario_2.is_primary      scenario_1.is_primary = False      assert not scenario_1.is_primary      assert not scenario_2.is_primary      scenario_2.is_primary = True      assert scenario_1.is_primary      assert scenario_2.is_primary        # auto set & reload on subscribers attribute      assert len(scenario_1.subscribers) == 0      assert len(scenario_2.subscribers) == 0      scenario_1.subscribers.append(_Subscriber(print, []))      assert len(scenario_1.subscribers) == 1      assert len(scenario_2.subscribers) == 1      scenario_2.subscribers.append(_Subscriber(print, []))      assert len(scenario_1.subscribers) == 2      assert len(scenario_2.subscribers) == 2        scenario_1.subscribers.clear()      assert len(scenario_1.subscribers) == 0      assert len(scenario_2.subscribers) == 0        scenario_1.subscribers.extend([_Subscriber(print, []), _Subscriber(map, [])])      assert len(scenario_1.subscribers) == 2      assert len(scenario_2.subscribers) == 2        scenario_1.subscribers.remove(_Subscriber(print, []))      assert len(scenario_1.subscribers) == 1      assert len(scenario_2.subscribers) == 1        scenario_1.subscribers + print + len      assert len(scenario_1.subscribers) == 3      assert len(scenario_2.subscribers) == 3        scenario_1.subscribers = []      assert len(scenario_1.subscribers) == 0      assert len(scenario_2.subscribers) == 0        assert len(scenario_1.tags) == 0      scenario_1.tags = {\"hi\"}      assert len(scenario_1.tags) == 1      assert len(scenario_2.tags) == 1        # auto set & reload on properties attribute      assert scenario_1.properties == {\"name\": \"baz\"}      assert scenario_2.properties == {\"name\": \"baz\"}      scenario_1._properties[\"qux\"] = 4      assert scenario_1.properties[\"qux\"] == 4      assert scenario_2.properties[\"qux\"] == 4        assert scenario_1.properties == {\"name\": \"baz\", \"qux\": 4}      assert scenario_2.properties == {\"name\": \"baz\", \"qux\": 4}      scenario_2._properties[\"qux\"] = 5      assert scenario_1.properties[\"qux\"] == 5      assert scenario_2.properties[\"qux\"] == 5        scenario_1.properties[\"temp_key_1\"] = \"temp_value_1\"      scenario_1.properties[\"temp_key_2\"] = \"temp_value_2\"      assert scenario_1.properties == {          \"name\": \"baz\",          \"qux\": 5,          \"temp_key_1\": \"temp_value_1\",          \"temp_key_2\": \"temp_value_2\",      }      assert scenario_2.properties == {          \"name\": \"baz\",          \"qux\": 5,          \"temp_key_1\": \"temp_value_1\",          \"temp_key_2\": \"temp_value_2\",      }      scenario_1.properties.pop(\"temp_key_1\")      assert \"temp_key_1\" not in scenario_1.properties.keys()      assert \"temp_key_1\" not in scenario_1.properties.keys()      assert scenario_1.properties == {          \"name\": \"baz\",          \"qux\": 5,          \"temp_key_2\": \"temp_value_2\",      }      assert scenario_2.properties == {          \"name\": \"baz\",          \"qux\": 5,          \"temp_key_2\": \"temp_value_2\",      }      scenario_2.properties.pop(\"temp_key_2\")      assert scenario_1.properties == {\"name\": \"baz\", \"qux\": 5}      assert scenario_2.properties == {\"name\": \"baz\", \"qux\": 5}      assert \"temp_key_2\" not in scenario_1.properties.keys()      assert \"temp_key_2\" not in scenario_2.properties.keys()        scenario_1.properties[\"temp_key_3\"] = 0      assert scenario_1.properties == {\"name\": \"baz\", \"qux\": 5, \"temp_key_3\": 0}      assert scenario_2.properties == {\"name\": \"baz\", \"qux\": 5, \"temp_key_3\": 0}      scenario_1.properties.update({\"temp_key_3\": 1})      assert scenario_1.properties == {\"name\": \"baz\", \"qux\": 5, \"temp_key_3\": 1}      assert scenario_2.properties == {\"name\": \"baz\", \"qux\": 5, \"temp_key_3\": 1}      scenario_1.properties.update(dict())      assert scenario_1.properties == {\"name\": \"baz\", \"qux\": 5, \"temp_key_3\": 1}      assert scenario_2.properties == {\"name\": \"baz\", \"qux\": 5, \"temp_key_3\": 1}      scenario_1.properties[\"temp_key_4\"] = 0      scenario_1.properties[\"temp_key_5\"] = 0        with scenario_1 as scenario:          assert scenario.config_id == \"foo\"          assert len(scenario.tasks) == 1          assert len(scenario.sequences) == 1          assert scenario.sequences[\"sequence_1\"] == sequence_1          assert scenario.tasks[task.config_id] == task          assert len(scenario.additional_data_nodes) == 1          assert scenario.additional_data_nodes[additional_dn.config_id] == additional_dn          assert scenario.creation_date == new_datetime          assert scenario.cycle == cycle          assert scenario.is_primary          assert len(scenario.subscribers) == 0          assert len(scenario.tags) == 1          assert scenario._is_in_context          assert scenario.name == \"baz\"          assert scenario.properties[\"qux\"] == 5          assert scenario.properties[\"temp_key_3\"] == 1          assert scenario.properties[\"temp_key_4\"] == 0          assert scenario.properties[\"temp_key_5\"] == 0            new_datetime_2 = new_datetime + timedelta(5)          scenario.config_id = \"foo\"          scenario.tasks = set()          scenario.additional_data_nodes = set()          scenario.remove_sequences([sequence_1_name])          scenario.creation_date = new_datetime_2          scenario.cycle = None          scenario.is_primary = False          scenario.subscribers = [print]          scenario.tags = None          scenario.name = \"qux\"          scenario.properties[\"qux\"] = 9          scenario.properties.pop(\"temp_key_3\")          scenario.properties.pop(\"temp_key_4\")          scenario.properties.update({\"temp_key_4\": 1})          scenario.properties.update({\"temp_key_5\": 2})          scenario.properties.pop(\"temp_key_5\")          scenario.properties.update(dict())            assert scenario.config_id == \"foo\"          assert len(scenario.sequences) == 1          assert scenario.sequences[sequence_1_name] == sequence_1          assert len(scenario.tasks) == 1          assert scenario.tasks[task.config_id] == task          assert len(scenario.additional_data_nodes) == 1          assert scenario.additional_data_nodes[additional_dn.config_id] == additional_dn          assert scenario.creation_date == new_datetime          assert scenario.cycle == cycle          assert scenario.is_primary          assert len(scenario.subscribers) == 0          assert len(scenario.tags) == 1          assert scenario._is_in_context          assert scenario.name == \"baz\"          assert scenario.properties[\"qux\"] == 5          assert scenario.properties[\"temp_key_3\"] == 1          assert scenario.properties[\"temp_key_4\"] == 0          assert scenario.properties[\"temp_key_5\"] == 0        assert scenario_1.config_id == \"foo\"      assert len(scenario_1.sequences) == 0      assert len(scenario_1.tasks) == 0      assert len(scenario_1.additional_data_nodes) == 0      assert scenario_1.tasks == {}      assert scenario_1.additional_data_nodes == {}      assert scenario_1.creation_date == new_datetime_2      assert scenario_1.cycle is None      assert not scenario_1.is_primary      assert len(scenario_1.subscribers) == 1      assert len(scenario_1.tags) == 0      assert not scenario_1._is_in_context      assert scenario_1.properties[\"qux\"] == 9      assert \"temp_key_3\" not in scenario_1.properties.keys()      assert scenario_1.properties[\"temp_key_4\"] == 1      assert \"temp_key_5\" not in scenario_1.properties.keys()      def test_is_deletable():      with mock.patch(\"src.taipy.core.scenario._scenario_manager._ScenarioManager._is_deletable\") as mock_submit:          scenario = Scenario(\"foo\", [], {})          scenario.is_deletable()          mock_submit.assert_called_once_with(scenario)      def test_submit_scenario():      with mock.patch(\"src.taipy.core.scenario._scenario_manager._ScenarioManager._submit\") as mock_submit:          scenario = Scenario(\"foo\", [], {})          scenario.submit(force=False)          mock_submit.assert_called_once_with(scenario, None, False, False, None)      def test_subscribe_scenario():      with mock.patch(\"src.taipy.core.subscribe_scenario\") as mock_subscribe:          scenario = Scenario(\"foo\", [], {})          scenario.subscribe(None)          mock_subscribe.assert_called_once_with(None, None, scenario)      def test_unsubscribe_scenario():      with mock.patch(\"src.taipy.core.unsubscribe_scenario\") as mock_unsubscribe:          scenario = Scenario(\"foo\", [], {})          scenario.unsubscribe(None)          mock_unsubscribe.assert_called_once_with(None, None, scenario)      def test_add_tag_scenario():      with mock.patch(\"src.taipy.core.tag\") as mock_add_tag:          scenario = Scenario(\"foo\", [], {})          scenario.add_tag(\"tag\")          mock_add_tag.assert_called_once_with(scenario, \"tag\")      def test_remove_tag_scenario():      with mock.patch(\"src.taipy.core.untag\") as mock_remove_tag:          scenario = Scenario(\"foo\", [], {})          scenario.remove_tag(\"tag\")          mock_remove_tag.assert_called_once_with(scenario, \"tag\")      def test_get_inputs_outputs_intermediate_data_nodes():      data_node_1 = DataNode(\"foo\", Scope.SCENARIO, \"s1\")      data_node_2 = DataNode(\"bar\", Scope.SCENARIO, \"s2\")      data_node_3 = DataNode(\"baz\", Scope.SCENARIO, \"s3\")      data_node_4 = DataNode(\"qux\", Scope.SCENARIO, \"s4\")      data_node_5 = DataNode(\"quux\", Scope.SCENARIO, \"s5\")      data_node_6 = DataNode(\"quuz\", Scope.SCENARIO, \"s6\")      data_node_7 = DataNode(\"corge\", Scope.SCENARIO, \"s7\")      task_1 = Task(\"grault\", {}, print, [data_node_1, data_node_2], [data_node_3, data_node_4], TaskId(\"t1\"))      task_2 = Task(\"garply\", {}, print, [data_node_3], [data_node_5], TaskId(\"t2\"))      task_3 = Task(\"waldo\", {}, print, [data_node_5, data_node_4], [data_node_6], TaskId(\"t3\"))      task_4 = Task(\"fred\", {}, print, [data_node_4], [data_node_7], TaskId(\"t4\"))      scenario = Scenario(\"scenario\", {task_1, task_2, task_3, task_4}, {}, set(), ScenarioId(\"s1\"))      # s1 ---             ---> s3 ---> t2 ---> s5 ----      #       |           |                           |      #       |---> t1 ---|      -------------------------> t3 ---> s6      #       |           |      |      # s2 ---             ---> s4 ---> t4 ---> s7      assert scenario.get_inputs() == {data_node_1, data_node_2}      assert scenario.get_outputs() == {data_node_6, data_node_7}      assert scenario.get_intermediate() == {data_node_3, data_node_4, data_node_5}        data_node_1 = DataNode(\"foo\", Scope.SCENARIO, \"s1\")      data_node_2 = DataNode(\"bar\", Scope.SCENARIO, \"s2\")      data_node_4 = DataNode(\"qux\", Scope.SCENARIO, \"s4\")      data_node_5 = DataNode(\"quux\", Scope.SCENARIO, \"s5\")      data_node_6 = DataNode(\"quuz\", Scope.SCENARIO, \"s6\")      data_node_7 = DataNode(\"corge\", Scope.SCENARIO, \"s7\")      task_1 = Task(\"grault\", {}, print, [data_node_1, data_node_2], [data_node_4], TaskId(\"t1\"))      task_2 = Task(\"garply\", {}, print, None, [data_node_5], TaskId(\"t2\"))      task_3 = Task(\"waldo\", {}, print, [data_node_5, data_node_4], [data_node_6], TaskId(\"t3\"))      task_4 = Task(\"fred\", {}, print, [data_node_4], [data_node_7], TaskId(\"t4\"))      scenario = Scenario(\"scenario\", {task_1, task_2, task_3, task_4}, {}, set(), ScenarioId(\"s1\"))      # s1 ---      t2 ---> s5 ------      #       |                     |      #       |---> t1 ---|      -----> t3 ---> s6      #       |           |      |      # s2 ---             ---> s4 ---> t4 ---> s7      assert scenario.get_inputs() == {data_node_1, data_node_2}      assert scenario.get_outputs() == {data_node_6, data_node_7}      assert scenario.get_intermediate() == {data_node_4, data_node_5}        data_node_1 = DataNode(\"foo\", Scope.SCENARIO, \"s1\")      data_node_2 = DataNode(\"bar\", Scope.SCENARIO, \"s2\")      data_node_4 = DataNode(\"qux\", Scope.SCENARIO, \"s4\")      data_node_5 = DataNode(\"quux\", Scope.SCENARIO, \"s5\")      data_node_6 = DataNode(\"quuz\", Scope.SCENARIO, \"s6\")      data_node_7 = DataNode(\"corge\", Scope.SCENARIO, \"s7\")      data_node_8 = DataNode(\"d8\", Scope.SCENARIO, \"s8\")      data_node_9 = DataNode(\"d9\", Scope.SCENARIO, \"s9\")      task_1 = Task(\"grault\", {}, print, [data_node_1, data_node_2], [data_node_4], TaskId(\"t1\"))      task_2 = Task(\"garply\", {}, print, [data_node_6], [data_node_5], TaskId(\"t2\"))      task_3 = Task(\"waldo\", {}, print, [data_node_5, data_node_4], id=TaskId(\"t3\"))      task_4 = Task(\"fred\", {}, print, [data_node_4], [data_node_7], TaskId(\"t4\"))      task_5 = Task(\"t5\", {}, print, [data_node_8], [data_node_9], TaskId(\"t5\"))      task_6 = Task(\"t6\", {}, print, [data_node_7, data_node_9], id=TaskId(\"t6\"))      scenario = Scenario(\"scenario\", {task_1, task_2, task_3, task_4, task_5, task_6}, {}, set(), ScenarioId(\"s1\"))      # s1 ---      s6 ---> t2 ---> s5      #       |                     |      #       |---> t1 ---|      -----> t3      #       |           |      |      # s2 ---             ---> s4 ---> t4 ---> s7 ---> t6      #                                              |      # s8 -------> t5 -------> s9 ------------------      assert scenario.get_inputs() == {data_node_1, data_node_2, data_node_6, data_node_8}      assert scenario.get_outputs() == set()      assert scenario.get_intermediate() == {data_node_5, data_node_4, data_node_7, data_node_9}        data_node_1 = DataNode(\"foo\", Scope.SCENARIO, \"s1\")      data_node_2 = DataNode(\"bar\", Scope.SCENARIO, \"s2\")      data_node_4 = DataNode(\"qux\", Scope.SCENARIO, \"s4\")      data_node_5 = DataNode(\"quux\", Scope.SCENARIO, \"s5\")      data_node_6 = DataNode(\"quuz\", Scope.SCENARIO, \"s6\")      data_node_7 = DataNode(\"corge\", Scope.SCENARIO, \"s7\")      data_node_8 = DataNode(\"hugh\", Scope.SCENARIO, \"s8\")      task_1 = Task(\"grault\", {}, print, [data_node_1, data_node_2], [data_node_4], TaskId(\"t1\"))      task_2 = Task(\"garply\", {}, print, output=[data_node_5], id=TaskId(\"t2\"))      task_3 = Task(\"waldo\", {}, print, [data_node_4], None, id=TaskId(\"t3\"))      task_4 = Task(\"fred\", {}, print, [data_node_4, data_node_6], [data_node_7], TaskId(\"t4\"))      task_5 = Task(\"bob\", {}, print, [data_node_8], None, TaskId(\"t5\"))      scenario = Scenario(\"scenario\", {task_1, task_2, task_3, task_4, task_5}, {}, set(), ScenarioId(\"sc1\"))      # s1 ---      #       |      #       |---> t1 ---|      -----> t3      #       |           |      |      # s2 ---             ---> s4 ---> t4 ---> s7      # t2 ---> s5                   |      # s8 ---> t5              s6 --|      assert scenario.get_inputs() == {data_node_1, data_node_2, data_node_8, data_node_6}      assert scenario.get_outputs() == {data_node_5, data_node_7}      assert scenario.get_intermediate() == {data_node_4}      def test_is_ready_to_run():      data_node_1 = PickleDataNode(\"foo\", Scope.SCENARIO, \"s1\", properties={\"default_data\": 1})      data_node_2 = PickleDataNode(\"bar\", Scope.SCENARIO, \"s2\", properties={\"default_data\": 2})      data_node_4 = PickleDataNode(\"qux\", Scope.SCENARIO, \"s4\", properties={\"default_data\": 4})      data_node_5 = PickleDataNode(\"quux\", Scope.SCENARIO, \"s5\", properties={\"default_data\": 5})      data_node_6 = PickleDataNode(\"quuz\", Scope.SCENARIO, \"s6\", properties={\"default_data\": 6})      data_node_7 = PickleDataNode(\"corge\", Scope.SCENARIO, \"s7\", properties={\"default_data\": 7})      data_node_8 = PickleDataNode(\"d8\", Scope.SCENARIO, \"s8\", properties={\"default_data\": 8})      data_node_9 = PickleDataNode(\"d9\", Scope.SCENARIO, \"s9\", properties={\"default_data\": 9})      task_1 = Task(\"grault\", {}, print, [data_node_1, data_node_2], [data_node_4], TaskId(\"t1\"))      task_2 = Task(\"garply\", {}, print, [data_node_6], [data_node_5], TaskId(\"t2\"))      task_3 = Task(\"waldo\", {}, print, [data_node_5, data_node_4], id=TaskId(\"t3\"))      task_4 = Task(\"fred\", {}, print, [data_node_4], [data_node_7], TaskId(\"t4\"))      task_5 = Task(\"t5\", {}, print, [data_node_8], [data_node_9], TaskId(\"t5\"))      task_6 = Task(\"t6\", {}, print, [data_node_7, data_node_9], id=TaskId(\"t6\"))      scenario = Scenario(\"scenario\", {task_1, task_2, task_3, task_4, task_5, task_6}, {}, set(), ScenarioId(\"s1\"))      # s1 ---      s6 ---> t2 ---> s5      #       |                     |      #       |---> t1 ---|      -----> t3      #       |           |      |      # s2 ---             ---> s4 ---> t4 ---> s7 ---> t6      #                                              |      # s8 -------> t5 -------> s9 ------------------      assert scenario.get_inputs() == {data_node_1, data_node_2, data_node_6, data_node_8}        data_manager = _DataManagerFactory._build_manager()      data_manager._delete_all()      for dn in [data_node_1, data_node_2, data_node_4, data_node_5, data_node_6, data_node_7, data_node_8, data_node_9]:          data_manager._set(dn)        assert scenario.is_ready_to_run()        data_node_1.edit_in_progress = True      assert not scenario.is_ready_to_run()        data_node_2.edit_in_progress = True      assert not scenario.is_ready_to_run()        data_node_6.edit_in_progress = True      data_node_8.edit_in_progress = True      assert not scenario.is_ready_to_run()        data_node_1.edit_in_progress = False      data_node_2.edit_in_progress = False      data_node_6.edit_in_progress = False      data_node_8.edit_in_progress = False      assert scenario.is_ready_to_run()      def test_data_nodes_being_edited():      data_node_1 = PickleDataNode(\"foo\", Scope.SCENARIO, \"s1\", properties={\"default_data\": 1})      data_node_2 = PickleDataNode(\"bar\", Scope.SCENARIO, \"s2\", properties={\"default_data\": 2})      data_node_4 = PickleDataNode(\"qux\", Scope.SCENARIO, \"s4\", properties={\"default_data\": 4})      data_node_5 = PickleDataNode(\"quux\", Scope.SCENARIO, \"s5\", properties={\"default_data\": 5})      data_node_6 = PickleDataNode(\"quuz\", Scope.SCENARIO, \"s6\", properties={\"default_data\": 6})      data_node_7 = PickleDataNode(\"corge\", Scope.SCENARIO, \"s7\", properties={\"default_data\": 7})      data_node_8 = PickleDataNode(\"d8\", Scope.SCENARIO, \"s8\", properties={\"default_data\": 8})      data_node_9 = PickleDataNode(\"d9\", Scope.SCENARIO, \"s9\", properties={\"default_data\": 9})      task_1 = Task(\"grault\", {}, print, [data_node_1, data_node_2], [data_node_4], TaskId(\"t1\"))      task_2 = Task(\"garply\", {}, print, [data_node_6], [data_node_5], TaskId(\"t2\"))      task_3 = Task(\"waldo\", {}, print, [data_node_5, data_node_4], id=TaskId(\"t3\"))      task_4 = Task(\"fred\", {}, print, [data_node_4], [data_node_7], TaskId(\"t4\"))      task_5 = Task(\"t5\", {}, print, [data_node_8], [data_node_9], TaskId(\"t5\"))      task_6 = Task(\"t6\", {}, print, [data_node_7, data_node_9], id=TaskId(\"t6\"))      scenario = Scenario(\"scenario\", {task_1, task_2, task_3, task_4, task_5, task_6}, {}, set(), ScenarioId(\"s1\"))      # s1 ---      s6 ---> t2 ---> s5      #       |                     |      #       |---> t1 ---|      -----> t3      #       |           |      |      # s2 ---             ---> s4 ---> t4 ---> s7 ---> t6      #                                              |      # s8 -------> t5 -------> s9 ------------------        data_manager = _DataManagerFactory._build_manager()      for dn in [data_node_1, data_node_2, data_node_4, data_node_5, data_node_6, data_node_7, data_node_8, data_node_9]:          data_manager._set(dn)        assert len(scenario.data_nodes_being_edited()) == 0      assert scenario.data_nodes_being_edited() == set()        data_node_1.edit_in_progress = True      assert len(scenario.data_nodes_being_edited()) == 1      assert scenario.data_nodes_being_edited() == {data_node_1}        data_node_2.edit_in_progress = True      data_node_6.edit_in_progress = True      data_node_8.edit_in_progress = True      assert len(scenario.data_nodes_being_edited()) == 4      assert scenario.data_nodes_being_edited() == {data_node_1, data_node_2, data_node_6, data_node_8}        data_node_4.edit_in_progress = True      data_node_5.edit_in_progress = True      data_node_9.edit_in_progress = True      assert len(scenario.data_nodes_being_edited()) == 7      assert scenario.data_nodes_being_edited() == {          data_node_1,          data_node_2,          data_node_4,          data_node_5,          data_node_6,          data_node_8,          data_node_9,      }        data_node_1.edit_in_progress = False      data_node_2.edit_in_progress = False      data_node_6.edit_in_progress = False      data_node_8.edit_in_progress = False      assert len(scenario.data_nodes_being_edited()) == 3      assert scenario.data_nodes_being_edited() == {data_node_4, data_node_5, data_node_9}        data_node_4.edit_in_progress = False      data_node_5.edit_in_progress = False      data_node_7.edit_in_progress = True      assert len(scenario.data_nodes_being_edited()) == 2      assert scenario.data_nodes_being_edited() == {data_node_7, data_node_9}        data_node_7.edit_in_progress = False      data_node_9.edit_in_progress = False      assert len(scenario.data_nodes_being_edited()) == 0      assert scenario.data_nodes_being_edited() == set()      def test_get_tasks():      task_1 = Task(\"grault\", {}, print, id=TaskId(\"t1\"))      task_2 = Task(\"garply\", {}, print, id=TaskId(\"t2\"))      task_3 = Task(\"waldo\", {}, print, id=TaskId(\"t3\"))      task_4 = Task(\"fred\", {}, print, id=TaskId(\"t4\"))      scenario_1 = Scenario(\"scenario_1\", {task_1, task_2, task_3, task_4}, {}, set(), ScenarioId(\"s1\"))      assert scenario_1.tasks == {\"grault\": task_1, \"garply\": task_2, \"waldo\": task_3, \"fred\": task_4}        task_5 = Task(\"wallo\", {}, print, id=TaskId(\"t5\"))      scenario_2 = Scenario(\"scenario_2\", {task_1, task_2, task_3, task_4, task_5}, {}, set(), ScenarioId(\"s2\"))      assert scenario_2.tasks == {\"grault\": task_1, \"garply\": task_2, \"waldo\": task_3, \"fred\": task_4, \"wallo\": task_5}      def test_get_set_of_tasks():      task_1 = Task(\"grault\", {}, print, id=TaskId(\"t1\"))      task_2 = Task(\"garply\", {}, print, id=TaskId(\"t2\"))      task_3 = Task(\"waldo\", {}, print, id=TaskId(\"t3\"))      task_4 = Task(\"fred\", {}, print, id=TaskId(\"t4\"))      scenario_1 = Scenario(\"scenario_1\", {task_1, task_2, task_3, task_4}, {}, set(), ScenarioId(\"s1\"))      assert scenario_1._get_set_of_tasks() == {task_1, task_2, task_3, task_4}        task_5 = Task(\"wallo\", {}, print, id=TaskId(\"t5\"))      scenario_2 = Scenario(\"scenario_2\", {task_1, task_2, task_3, task_4, task_5}, {}, set(), ScenarioId(\"s2\"))      assert scenario_2._get_set_of_tasks() == {task_1, task_2, task_3, task_4, task_5}      def test_get_sorted_tasks():      def _assert_equal(tasks_a, tasks_b) -> bool:          if len(tasks_a) != len(tasks_b):              return False          for i in range(len(tasks_a)):              task_a, task_b = tasks_a[i], tasks_b[i]              if isinstance(task_a, list) and isinstance(task_b, list):                  if not _assert_equal(task_a, task_b):                      return False              elif isinstance(task_a, list) or isinstance(task_b, list):                  return False              else:                  index_task_b = tasks_b.index(task_a)                  if any([isinstance(task_b, list) for task_b in tasks_b[i : index_task_b + 1]]):                      return False          return True        # s1 ---             ---> s3 ---> t2 ---> s5 ----      #       |           |                           |      #       |---> t1 ---|      -------------------------> t3 ---> s6      #       |           |      |      # s2 ---             ---> s4 ---> t4 ---> s7        data_node_1 = InMemoryDataNode(\"foo\", Scope.SCENARIO, \"s1\")      data_node_2 = InMemoryDataNode(\"bar\", Scope.SCENARIO, \"s2\")      data_node_3 = InMemoryDataNode(\"baz\", Scope.SCENARIO, \"s3\")      data_node_4 = InMemoryDataNode(\"qux\", Scope.SCENARIO, \"s4\")      data_node_5 = InMemoryDataNode(\"quux\", Scope.SCENARIO, \"s5\")      data_node_6 = InMemoryDataNode(\"quuz\", Scope.SCENARIO, \"s6\")      data_node_7 = InMemoryDataNode(\"corge\", Scope.SCENARIO, \"s7\")      task_1 = Task(\"grault\", {}, print, [data_node_1, data_node_2], [data_node_3, data_node_4], TaskId(\"t1\"))      task_2 = Task(\"garply\", {}, print, [data_node_3], [data_node_5], TaskId(\"t2\"))      task_3 = Task(\"waldo\", {}, print, [data_node_5, data_node_4], [data_node_6], TaskId(\"t3\"))      task_4 = Task(\"fred\", {}, print, [data_node_4], [data_node_7], TaskId(\"t4\"))      scenario_1 = Scenario(\"scenario_1\", {task_1, task_2, task_3, task_4}, {}, [], ScenarioId(\"s1\"))        assert scenario_1.get_inputs() == {data_node_1, data_node_2}      assert scenario_1._get_set_of_tasks() == {task_1, task_2, task_3, task_4}      _assert_equal(scenario_1._get_sorted_tasks(), [[task_1], [task_2, task_4], [task_3]])        # s1 ---              t2 ---> s5      #       |                     |      #       |---> t1 ---|      -----> t3 ---> s6      #       |           |      |      # s2 ---             ---> s4 ---> t4 ---> s7        data_node_1 = InMemoryDataNode(\"foo\", Scope.SCENARIO, \"s1\")      data_node_2 = InMemoryDataNode(\"bar\", Scope.SCENARIO, \"s2\")      data_node_4 = InMemoryDataNode(\"qux\", Scope.SCENARIO, \"s4\")      data_node_5 = InMemoryDataNode(\"quux\", Scope.SCENARIO, \"s5\")      data_node_6 = InMemoryDataNode(\"quuz\", Scope.SCENARIO, \"s6\")      data_node_7 = InMemoryDataNode(\"corge\", Scope.SCENARIO, \"s7\")      task_1 = Task(\"grault\", {}, print, [data_node_1, data_node_2], [data_node_4], TaskId(\"t1\"))      task_2 = Task(\"garply\", {}, print, None, [data_node_5], TaskId(\"t2\"))      task_3 = Task(\"waldo\", {}, print, [data_node_5, data_node_4], [data_node_6], TaskId(\"t3\"))      task_4 = Task(\"fred\", {}, print, [data_node_4], [data_node_7], TaskId(\"t4\"))      scenario_2 = Scenario(\"scenario_2\", {task_1, task_2, task_3, task_4}, {}, [], ScenarioId(\"s2\"))        assert scenario_2.get_inputs() == {data_node_1, data_node_2}      assert scenario_2._get_set_of_tasks() == {task_1, task_2, task_3, task_4}      _assert_equal(scenario_2._get_sorted_tasks(), [[task_1, task_2], [task_3, task_4]])        # s1 ---      s6 ---> t2 ---> s5      #       |                     |      #       |---> t1 ---|      -----> t3      #       |           |      |      # s2 ---             ---> s4 ---> t4 ---> s7        data_node_1 = DataNode(\"foo\", Scope.SCENARIO, \"s1\")      data_node_2 = DataNode(\"bar\", Scope.SCENARIO, \"s2\")      data_node_4 = DataNode(\"qux\", Scope.SCENARIO, \"s4\")      data_node_5 = DataNode(\"quux\", Scope.SCENARIO, \"s5\")      data_node_6 = DataNode(\"quuz\", Scope.SCENARIO, \"s6\")      data_node_7 = DataNode(\"corge\", Scope.SCENARIO, \"s7\")      task_1 = Task(          \"grault\",          {},          print,          [data_node_1, data_node_2],          [data_node_4],          TaskId(\"t1\"),      )      task_2 = Task(\"garply\", {}, print, [data_node_6], [data_node_5], TaskId(\"t2\"))      task_3 = Task(\"waldo\", {}, print, [data_node_5, data_node_4], id=TaskId(\"t3\"))      task_4 = Task(\"fred\", {}, print, [data_node_4], [data_node_7], TaskId(\"t4\"))      scenario_3 = Scenario(\"quest\", [task_4, task_2, task_1, task_3], {}, [], scenario_id=ScenarioId(\"s3\"))        assert scenario_3.get_inputs() == {data_node_1, data_node_2, data_node_6}      assert scenario_3._get_set_of_tasks() == {task_1, task_2, task_3, task_4}      assert _assert_equal(scenario_3._get_sorted_tasks(), [[task_2, task_1], [task_4, task_3]])        # s1 ---      s6 ---> t2 ---> s5      #       |                     |      #       |---> t1 ---|      -----> t3      #       |           |      |      # s2 ---             ---> s4 ---> t4 ---> s7 ---> t6      #                                              |      # s8 -------> t5 -------> s9 ------------------        data_node_1 = InMemoryDataNode(\"foo\", Scope.SCENARIO, \"s1\")      data_node_2 = InMemoryDataNode(\"bar\", Scope.SCENARIO, \"s2\")      data_node_4 = InMemoryDataNode(\"qux\", Scope.SCENARIO, \"s4\")      data_node_5 = InMemoryDataNode(\"quux\", Scope.SCENARIO, \"s5\")      data_node_6 = InMemoryDataNode(\"quuz\", Scope.SCENARIO, \"s6\")      data_node_7 = InMemoryDataNode(\"corge\", Scope.SCENARIO, \"s7\")      data_node_8 = InMemoryDataNode(\"d8\", Scope.SCENARIO, \"s8\")      data_node_9 = InMemoryDataNode(\"d9\", Scope.SCENARIO, \"s9\")      task_1 = Task(\"grault\", {}, print, [data_node_1, data_node_2], [data_node_4], TaskId(\"t1\"))      task_2 = Task(\"garply\", {}, print, [data_node_6], [data_node_5], TaskId(\"t2\"))      task_3 = Task(\"waldo\", {}, print, [data_node_5, data_node_4], id=TaskId(\"t3\"))      task_4 = Task(\"fred\", {}, print, [data_node_4], [data_node_7], TaskId(\"t4\"))      task_5 = Task(\"t5\", {}, print, [data_node_8], [data_node_9], TaskId(\"t5\"))      task_6 = Task(\"t6\", {}, print, [data_node_7, data_node_9], id=TaskId(\"t6\"))      scenario_4 = Scenario(\"scenario_3\", [task_1, task_2, task_3, task_4, task_5, task_6], {}, [], ScenarioId(\"s4\"))        assert scenario_4.get_inputs() == {data_node_1, data_node_2, data_node_6, data_node_8}      assert scenario_4._get_set_of_tasks() == {task_1, task_2, task_3, task_4, task_5, task_6}      _assert_equal(scenario_4._get_sorted_tasks(), [[task_1, task_2, task_5], [task_3, task_4], [task_6]])        # s1 ---      #       |      #       |---> t1 ---|      -----> t3      #       |           |      |      # s2 ---             ---> s4 ---> t4 ---> s7      # t2 ---> s5                      |      # s8 ---> t5                 s6 --|        data_node_1 = InMemoryDataNode(\"foo\", Scope.SCENARIO, \"s1\")      data_node_2 = InMemoryDataNode(\"bar\", Scope.SCENARIO, \"s2\")      data_node_4 = InMemoryDataNode(\"qux\", Scope.SCENARIO, \"s4\")      data_node_5 = InMemoryDataNode(\"quux\", Scope.SCENARIO, \"s5\")      data_node_6 = InMemoryDataNode(\"quuz\", Scope.SCENARIO, \"s6\")      data_node_7 = InMemoryDataNode(\"corge\", Scope.SCENARIO, \"s7\")      data_node_8 = InMemoryDataNode(\"hugh\", Scope.SCENARIO, \"s8\")      task_1 = Task(\"grault\", {}, print, [data_node_1, data_node_2], [data_node_4], TaskId(\"t1\"))      task_2 = Task(\"garply\", {}, print, output=[data_node_5], id=TaskId(\"t2\"))      task_3 = Task(\"waldo\", {}, print, [data_node_4], None, id=TaskId(\"t3\"))      task_4 = Task(\"fred\", {}, print, [data_node_4, data_node_6], [data_node_7], TaskId(\"t4\"))      task_5 = Task(\"bob\", {}, print, [data_node_8], None, TaskId(\"t5\"))      scenario_5 = Scenario(\"scenario_4\", [task_1, task_2, task_3, task_4, task_5], {}, [], ScenarioId(\"s5\"))        assert scenario_5.get_inputs() == {data_node_1, data_node_2, data_node_8, data_node_6}      assert scenario_5._get_set_of_tasks() == {task_1, task_2, task_3, task_4, task_5}      _assert_equal(scenario_5._get_sorted_tasks(), [[task_1, task_2, task_5], [task_3, task_4]])        #  p1  s1 ---      #            |      #            |---> t1 ---|      -----> t3      #            |           |      |      #      s2 ---             ---> s4 ---> t4 ---> s5      #  p2  t2 ---> s4 ---> t3      #  p3  s6 ---> t5        data_node_1 = DataNode(\"foo\", Scope.SCENARIO, \"s1\")      data_node_2 = DataNode(\"bar\", Scope.SCENARIO, \"s2\")      data_node_4 = DataNode(\"qux\", Scope.SCENARIO, \"s4\")      data_node_5 = DataNode(\"quux\", Scope.SCENARIO, \"s5\")      data_node_6 = DataNode(\"quuz\", Scope.SCENARIO, \"s6\")      task_1 = Task(          \"grault\",          {},          print,          [data_node_1, data_node_2],          [data_node_4],          TaskId(\"t1\"),      )      task_2 = Task(\"garply\", {}, print, output=[data_node_4], id=TaskId(\"t2\"))      task_3 = Task(\"waldo\", {}, print, [data_node_4], None, id=TaskId(\"t3\"))      task_4 = Task(\"fred\", {}, print, [data_node_4], [data_node_5], TaskId(\"t4\"))      task_5 = Task(\"bob\", {}, print, [data_node_6], None, TaskId(\"t5\"))      scenario_6 = Scenario(\"quest\", [task_1, task_2, task_3, task_4, task_5], {}, [], ScenarioId(\"s6\"))        assert scenario_6.get_inputs() == {data_node_1, data_node_2, data_node_6}      assert scenario_6._get_set_of_tasks() == {task_1, task_2, task_3, task_4, task_5}      _assert_equal(scenario_6._get_sorted_tasks(), [[task_5, task_2, task_1], [task_4, task_3]])        #  p1  s1 ---      #            |      #            |---> t1 ---|      -----> t3      #            |           |      |      #      s2 ---             ---> s4 ---> t4 ---> s5      #  p2  t2 ---> s4 ---> t3      #  p3  s6 ---> t5 ---> s4 ---> t4 ---> s5        data_node_1 = DataNode(\"foo\", Scope.SCENARIO, \"s1\")      data_node_2 = DataNode(\"bar\", Scope.SCENARIO, \"s2\")      data_node_4 = DataNode(\"qux\", Scope.SCENARIO, \"s4\")      data_node_5 = DataNode(\"quux\", Scope.SCENARIO, \"s5\")      data_node_6 = DataNode(\"quuz\", Scope.SCENARIO, \"s6\")      task_1 = Task(          \"grault\",          {},          print,          [data_node_1, data_node_2],          [data_node_4],          TaskId(\"t1\"),      )      task_2 = Task(\"garply\", {}, print, output=[data_node_4], id=TaskId(\"t2\"))      task_3 = Task(\"waldo\", {}, print, [data_node_4], None, id=TaskId(\"t3\"))      task_4 = Task(\"fred\", {}, print, [data_node_4], [data_node_5], TaskId(\"t4\"))      task_5 = Task(\"bob\", {}, print, [data_node_6], [data_node_4], None, TaskId(\"t5\"))      scenario_7 = Scenario(\"quest\", [task_4, task_1, task_2, task_3, task_5], {}, [], scenario_id=ScenarioId(\"s7\"))        assert scenario_7.get_inputs() == {data_node_1, data_node_2, data_node_6}      assert scenario_7._get_set_of_tasks() == {task_1, task_2, task_3, task_4, task_5}      _assert_equal(scenario_7._get_sorted_tasks(), [[task_5, task_2, task_1], [task_4, task_3]])        #  p1  s1 ---      #            |      #            |---> t1 ---|      -----> t3      #            |           |      |      #      s2 ---             ---> s3 ---> t4 ---> s4      #  p2  t2 ---> s3 ---> t3      #  p3  s5 ---> t5 ---> s3 ---> t4 ---> s4      #  p4  s3 ---> t4 ---> s4        data_node_1 = DataNode(\"foo\", Scope.SCENARIO, \"s1\")      data_node_2 = DataNode(\"bar\", Scope.SCENARIO, \"s2\")      data_node_3 = DataNode(\"qux\", Scope.SCENARIO, \"s3\")      data_node_4 = DataNode(\"quux\", Scope.SCENARIO, \"s4\")      data_node_5 = DataNode(\"quuz\", Scope.SCENARIO, \"s5\")      task_1 = Task(          \"grault\",          {},          print,          [data_node_1, data_node_2],          [data_node_3],          TaskId(\"t1\"),      )      task_2 = Task(\"garply\", {}, print, output=[data_node_3], id=TaskId(\"t2\"))      task_3 = Task(\"waldo\", {}, print, [data_node_3], None, id=TaskId(\"t3\"))      task_4 = Task(\"fred\", {}, print, [data_node_3], [data_node_4], TaskId(\"t4\"))      task_5 = Task(\"bob\", {}, print, [data_node_5], [data_node_3], TaskId(\"t5\"))      scenario_8 = Scenario(\"quest\", [task_1, task_2, task_3, task_4, task_5], {}, [], scenario_id=ScenarioId(\"s8\"))        assert scenario_8.get_inputs() == {data_node_1, data_node_2, data_node_5}      assert scenario_8._get_set_of_tasks() == {task_1, task_2, task_3, task_4, task_5}      _assert_equal(scenario_8._get_sorted_tasks(), [[task_5, task_2, task_1], [task_3, task_4]])      def test_add_and_remove_sequences():      data_node_1 = InMemoryDataNode(\"foo\", Scope.SCENARIO, \"s1\")      data_node_2 = InMemoryDataNode(\"bar\", Scope.SCENARIO, \"s2\")      data_node_3 = InMemoryDataNode(\"qux\", Scope.SCENARIO, \"s3\")      data_node_4 = InMemoryDataNode(\"quux\", Scope.SCENARIO, \"s4\")      data_node_5 = InMemoryDataNode(\"quuz\", Scope.SCENARIO, \"s5\")      task_1 = Task(          \"grault\",          {},          print,          [data_node_1, data_node_2],          [data_node_3],          TaskId(\"t1\"),      )      task_2 = Task(\"garply\", {}, print, [data_node_3], id=TaskId(\"t2\"))      task_3 = Task(\"waldo\", {}, print, [data_node_3], None, id=TaskId(\"t3\"))      task_4 = Task(\"fred\", {}, print, [data_node_3], [data_node_4], TaskId(\"t4\"))      task_5 = Task(\"bob\", {}, print, [data_node_5], [data_node_3], TaskId(\"t5\"))      scenario_1 = Scenario(\"quest\", [task_1, task_2, task_3, task_4, task_5], {}, [], scenario_id=ScenarioId(\"s1\"))        sequence_1 = Sequence({\"name\": \"sequence_1\"}, [task_1], SequenceId(f\"SEQUENCE_sequence_1_{scenario_1.id}\"))      sequence_2 = Sequence({\"name\": \"sequence_2\"}, [task_1, task_2], SequenceId(f\"SEQUENCE_sequence_2_{scenario_1.id}\"))      sequence_3 = Sequence(          {\"name\": \"sequence_3\"}, [task_1, task_5, task_3], SequenceId(f\"SEQUENCE_sequence_3_{scenario_1.id}\")      )        task_manager = _TaskManagerFactory._build_manager()      data_manager = _DataManagerFactory._build_manager()      scenario_manager = _ScenarioManagerFactory._build_manager()      for dn in [data_node_1, data_node_2, data_node_3, data_node_4, data_node_5]:          data_manager._set(dn)      for t in [task_1, task_2, task_3, task_4, task_5]:          task_manager._set(t)      scenario_manager._set(scenario_1)        assert scenario_1.get_inputs() == {data_node_1, data_node_2, data_node_5}      assert scenario_1._get_set_of_tasks() == {task_1, task_2, task_3, task_4, task_5}      assert len(scenario_1.sequences) == 0        scenario_1.sequences = {\"sequence_1\": {\"tasks\": [task_1]}}      assert scenario_1.sequences == {\"sequence_1\": sequence_1}        scenario_1.add_sequences({\"sequence_2\": [task_1, task_2]})      assert scenario_1.sequences == {\"sequence_1\": sequence_1, \"sequence_2\": sequence_2}        scenario_1.remove_sequences([\"sequence_1\"])      assert scenario_1.sequences == {\"sequence_2\": sequence_2}        scenario_1.add_sequences({\"sequence_1\": [task_1], \"sequence_3\": [task_1, task_5, task_3]})      assert scenario_1.sequences == {          \"sequence_2\": sequence_2,          \"sequence_1\": sequence_1,          \"sequence_3\": sequence_3,      }        scenario_1.remove_sequences([\"sequence_2\", \"sequence_3\"])      assert scenario_1.sequences == {\"sequence_1\": sequence_1}      def test_check_consistency():      data_node_1 = InMemoryDataNode(\"foo\", Scope.SCENARIO, \"s1\")      data_node_2 = InMemoryDataNode(\"bar\", Scope.SCENARIO, \"s2\")      data_node_3 = InMemoryDataNode(\"bar\", Scope.SCENARIO, \"s3\")      data_node_4 = InMemoryDataNode(\"qux\", Scope.SCENARIO, \"s4\")      data_node_5 = InMemoryDataNode(\"quux\", Scope.SCENARIO, \"s5\")      data_node_6 = InMemoryDataNode(\"quuz\", Scope.SCENARIO, \"s6\")      data_node_7 = InMemoryDataNode(\"corge\", Scope.SCENARIO, \"s7\")      data_node_8 = InMemoryDataNode(\"d8\", Scope.SCENARIO, \"s8\")      data_node_9 = InMemoryDataNode(\"d9\", Scope.SCENARIO, \"s9\")        scenario_0 = Scenario(\"scenario_0\", [], {})      assert scenario_0._is_consistent()        task_1 = Task(\"foo\", {}, print, [data_node_1], [data_node_2], TaskId(\"t1\"))      scenario_1 = Scenario(\"scenario_1\", [task_1], {})      assert scenario_1._is_consistent()        # s1 ---             ---> s3 ---> t2 ---> s5 ----      #       |           |                           |      #       |---> t1 ---|      -------------------------> t3 ---> s6      #       |           |      |      # s2 ---             ---> s4 ---> t4 ---> s7      task_1 = Task(\"grault\", {}, print, [data_node_1, data_node_2], [data_node_3, data_node_4], TaskId(\"t1\"))      task_2 = Task(\"garply\", {}, print, [data_node_3], [data_node_5], TaskId(\"t2\"))      task_3 = Task(\"waldo\", {}, print, [data_node_5, data_node_4], [data_node_6], TaskId(\"t3\"))      task_4 = Task(\"fred\", {}, print, [data_node_4], [data_node_7], TaskId(\"t4\"))      scenario_2 = Scenario(\"scenario_2\", {task_1, task_2, task_3, task_4}, {}, [], ScenarioId(\"s1\"))      assert scenario_2._is_consistent()        # s1 ---              t2 ---> s5      #       |                     |      #       |---> t1 ---|      -----> t3 ---> s6      #       |           |      |      # s2 ---             ---> s4 ---> t4 ---> s7      task_1 = Task(\"grault\", {}, print, [data_node_1, data_node_2], [data_node_4], TaskId(\"t1\"))      task_2 = Task(\"garply\", {}, print, None, [data_node_5], TaskId(\"t2\"))      task_3 = Task(\"waldo\", {}, print, [data_node_5, data_node_4], [data_node_6], TaskId(\"t3\"))      task_4 = Task(\"fred\", {}, print, [data_node_4], [data_node_7], TaskId(\"t4\"))      scenario_3 = Scenario(\"scenario_3\", {task_1, task_2, task_3, task_4}, {}, [], ScenarioId(\"s2\"))      assert scenario_3._is_consistent()        # s1 ---      s6 ---> t2 ---> s5      #       |                     |      #       |---> t1 ---|      -----> t3      #       |           |      |      # s2 ---             ---> s4 ---> t4 ---> s7      task_1 = Task(\"grault\", {}, print, [data_node_1, data_node_2], [data_node_4], TaskId(\"t1\"))      task_2 = Task(\"garply\", {}, print, [data_node_6], [data_node_5], TaskId(\"t2\"))      task_3 = Task(\"waldo\", {}, print, [data_node_5, data_node_4], id=TaskId(\"t3\"))      task_4 = Task(\"fred\", {}, print, [data_node_4], [data_node_7], TaskId(\"t4\"))      scenario_4 = Scenario(\"scenario_4\", [task_4, task_2, task_1, task_3], {}, [], scenario_id=ScenarioId(\"s3\"))      assert scenario_4._is_consistent()        # s1 ---      s6 ---> t2 ---> s5      #       |                     |      #       |---> t1 ---|      -----> t3      #       |           |      |      # s2 ---             ---> s4 ---> t4 ---> s7 ---> t6      #                                              |      # s8 -------> t5 -------> s9 ------------------      task_1 = Task(\"grault\", {}, print, [data_node_1, data_node_2], [data_node_4], TaskId(\"t1\"))      task_2 = Task(\"garply\", {}, print, [data_node_6], [data_node_5], TaskId(\"t2\"))      task_3 = Task(\"waldo\", {}, print, [data_node_5, data_node_4], id=TaskId(\"t3\"))      task_4 = Task(\"fred\", {}, print, [data_node_4], [data_node_7], TaskId(\"t4\"))      task_5 = Task(\"t5\", {}, print, [data_node_8], [data_node_9], TaskId(\"t5\"))      task_6 = Task(\"t6\", {}, print, [data_node_7, data_node_9], id=TaskId(\"t6\"))      scenario_5 = Scenario(\"scenario_5\", [task_1, task_2, task_3, task_4, task_5, task_6], {}, [], ScenarioId(\"s4\"))      assert scenario_5._is_consistent()        # s1 ---      #       |      #       |---> t1 ---|      -----> t3      #       |           |      |      # s2 ---             ---> s4 ---> t4 ---> s7      # t2 ---> s5                      |      # s8 ---> t5                 s6 --|      task_1 = Task(\"grault\", {}, print, [data_node_1, data_node_2], [data_node_4], TaskId(\"t1\"))      task_2 = Task(\"garply\", {}, print, output=[data_node_5], id=TaskId(\"t2\"))      task_3 = Task(\"waldo\", {}, print, [data_node_4], None, id=TaskId(\"t3\"))      task_4 = Task(\"fred\", {}, print, [data_node_4, data_node_6], [data_node_7], TaskId(\"t4\"))      task_5 = Task(\"bob\", {}, print, [data_node_8], None, TaskId(\"t5\"))      scenario_6 = Scenario(\"scenario_6\", [task_1, task_2, task_3, task_4, task_5], {}, [], ScenarioId(\"s5\"))      assert scenario_6._is_consistent()        #  p1  s1 ---      #            |      #            |---> t1 ---|      -----> t3      #            |           |      |      #      s2 ---             ---> s4 ---> t4 ---> s5      #  p2  t2 ---> s4 ---> t3      #  p3  s6 ---> t5      task_1 = Task(\"grault\", {}, print, [data_node_1, data_node_2], [data_node_4], TaskId(\"t1\"))      task_2 = Task(\"garply\", {}, print, output=[data_node_4], id=TaskId(\"t2\"))      task_3 = Task(\"waldo\", {}, print, [data_node_4], None, id=TaskId(\"t3\"))      task_4 = Task(\"fred\", {}, print, [data_node_4], [data_node_5], TaskId(\"t4\"))      task_5 = Task(\"bob\", {}, print, [data_node_6], None, TaskId(\"t5\"))      scenario_7 = Scenario(\"scenario_7\", [task_1, task_2, task_3, task_4, task_5], {}, [], ScenarioId(\"s6\"))      assert scenario_7._is_consistent()        #  p1  s1 ---      #            |      #            |---> t1 ---|      -----> t3      #            |           |      |      #      s2 ---             ---> s4 ---> t4 ---> s5      #  p2  t2 ---> s4 ---> t3      #  p3  s6 ---> t5 ---> s4 ---> t4 ---> s5      task_1 = Task(\"grault\", {}, print, [data_node_1, data_node_2], [data_node_4], TaskId(\"t1\"))      task_2 = Task(\"garply\", {}, print, output=[data_node_4], id=TaskId(\"t2\"))      task_3 = Task(\"waldo\", {}, print, [data_node_4], None, id=TaskId(\"t3\"))      task_4 = Task(\"fred\", {}, print, [data_node_4], [data_node_5], TaskId(\"t4\"))      task_5 = Task(\"bob\", {}, print, [data_node_6], [data_node_4], None, TaskId(\"t5\"))      scenario_8 = Scenario(\"scenario_8\", [task_4, task_1, task_2, task_3, task_5], {}, [], scenario_id=ScenarioId(\"s7\"))      assert scenario_8._is_consistent()        #  p1  s1 ---      #            |      #            |---> t1 ---|      -----> t3      #            |           |      |      #      s2 ---             ---> s3 ---> t4 ---> s4      #  p2  t2 ---> s3 ---> t3      #  p3  s5 ---> t5 ---> s3 ---> t4 ---> s4      #  p4  s3 ---> t4 ---> s4      task_1 = Task(\"grault\", {}, print, [data_node_1, data_node_2], [data_node_3], TaskId(\"t1\"))      task_2 = Task(\"garply\", {}, print, output=[data_node_3], id=TaskId(\"t2\"))      task_3 = Task(\"waldo\", {}, print, [data_node_3], None, id=TaskId(\"t3\"))      task_4 = Task(\"fred\", {}, print, [data_node_3], [data_node_4], TaskId(\"t4\"))      task_5 = Task(\"bob\", {}, print, [data_node_5], [data_node_3], TaskId(\"t5\"))      scenario_9 = Scenario(\"scenario_9\", [task_1, task_2, task_3, task_4, task_5], {}, [], scenario_id=ScenarioId(\"s8\"))      assert scenario_9._is_consistent() "}
{"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 multiprocessing  from unittest.mock import patch    from src.taipy.core import Core, taipy  from src.taipy.core.data._data_manager import _DataManager  from src.taipy.core.scenario._scenario_manager import _ScenarioManager  from taipy.config.config import Config  from tests.core.conftest import init_config  from tests.core.utils import assert_true_after_time    m = multiprocessing.Manager()      def twice(a):      return a * 2      def triple(a):      return a * 3      def migrate_pickle_path(dn):      dn.path = \"bar.pkl\"      return dn      def migrate_skippable_task(task):      task.skippable = True      return task      def migrate_foo_scenario(scenario):      scenario.properties[\"foo\"] = \"bar\"      return scenario      def test_migrate_datanode():      scenario_v1 = submit_v1()        init_config()      Config.add_migration_function(\"2.0\", \"d1\", migrate_pickle_path)        submit_v2()      v1 = taipy.get(scenario_v1.id)      assert v1.d1.version == \"2.0\"      assert v1.d1.path == \"bar.pkl\"      def test_migrate_datanode_in_standalone_mode():      scenario_v1 = submit_v1()        init_config()      Config.configure_job_executions(mode=\"standalone\", max_nb_of_workers=2)      Config.add_migration_function(\"2.0\", \"d1\", migrate_pickle_path)        scenario_cfg_v2 = config_scenario_v2()      with patch(\"sys.argv\", [\"prog\", \"--production\", \"2.0\"]):          core = Core()          core.run()          scenario_v2 = _ScenarioManager._create(scenario_cfg_v2)          jobs = _ScenarioManager._submit(scenario_v2)          v1 = taipy.get(scenario_v1.id)          assert v1.d1.version == \"2.0\"          assert v1.d1.path == \"bar.pkl\"          assert_true_after_time(jobs[0].is_completed)          core.stop()      def test_migrate_task():      scenario_v1 = submit_v1()        init_config()      Config.add_migration_function(\"2.0\", \"my_task\", migrate_skippable_task)        submit_v2()      v1 = taipy.get(scenario_v1.id)      assert v1.my_task.version == \"2.0\"      assert v1.my_task.skippable is True      def test_migrate_task_in_standalone_mode():      scenario_v1 = submit_v1()        init_config()      Config.configure_job_executions(mode=\"standalone\", max_nb_of_workers=2)      Config.add_migration_function(\"2.0\", \"my_task\", migrate_skippable_task)        scenario_cfg_v2 = config_scenario_v2()      with patch(\"sys.argv\", [\"prog\", \"--production\", \"2.0\"]):          core = Core()          core.run()          scenario_v2 = _ScenarioManager._create(scenario_cfg_v2)          jobs = _ScenarioManager._submit(scenario_v2)          v1 = taipy.get(scenario_v1.id)          assert v1.my_task.version == \"2.0\"          assert v1.my_task.skippable is True          assert_true_after_time(jobs[0].is_completed)          core.stop()      def test_migrate_scenario():      scenario_v1 = submit_v1()        init_config()      Config.add_migration_function(\"2.0\", \"my_scenario\", migrate_foo_scenario)        submit_v2()      v1 = taipy.get(scenario_v1.id)      assert v1.version == \"2.0\"      assert v1.properties[\"foo\"] == \"bar\"      def test_migrate_scenario_in_standalone_mode():      scenario_v1 = submit_v1()        init_config()      Config.configure_job_executions(mode=\"standalone\", max_nb_of_workers=2)      Config.add_migration_function(\"2.0\", \"my_scenario\", migrate_foo_scenario)        scenario_cfg_v2 = config_scenario_v2()      with patch(\"sys.argv\", [\"prog\", \"--production\", \"2.0\"]):          core = Core()          core.run()          scenario_v2 = _ScenarioManager._create(scenario_cfg_v2)          jobs = _ScenarioManager._submit(scenario_v2)          v1 = taipy.get(scenario_v1.id)          assert v1.version == \"2.0\"          assert v1.properties[\"foo\"] == \"bar\"          assert_true_after_time(jobs[0].is_completed)          core.stop()      def test_migrate_all_entities():      scenario_v1 = submit_v1()        init_config()      Config.add_migration_function(\"2.0\", \"d1\", migrate_pickle_path)      Config.add_migration_function(\"2.0\", \"my_task\", migrate_skippable_task)      Config.add_migration_function(\"2.0\", \"my_scenario\", migrate_foo_scenario)        submit_v2()      v1 = taipy.get(scenario_v1.id)        assert v1.d1.version == \"2.0\"      assert v1.my_task.version == \"2.0\"        assert v1.d1.path == \"bar.pkl\"      assert v1.my_task.skippable is True      assert v1.properties[\"foo\"] == \"bar\"      def test_migrate_all_entities_in_standalone_mode():      scenario_v1 = submit_v1()        init_config()      Config.configure_job_executions(mode=\"standalone\", max_nb_of_workers=2)      Config.add_migration_function(\"2.0\", \"my_scenario\", migrate_foo_scenario)        scenario_cfg_v2 = config_scenario_v2()      with patch(\"sys.argv\", [\"prog\", \"--production\", \"2.0\"]):          core = Core()          core.run()          scenario_v2 = _ScenarioManager._create(scenario_cfg_v2)          jobs = _ScenarioManager._submit(scenario_v2)          v1 = taipy.get(scenario_v1.id)          assert v1.version == \"2.0\"          assert v1.properties[\"foo\"] == \"bar\"          assert_true_after_time(jobs[0].is_completed)          core.stop()      def test_migrate_compatible_version():      scenario_cfg = config_scenario_v1()      # Production 1.0      with patch(\"sys.argv\", [\"prog\", \"--production\", \"1.0\"]):          core = Core()          core.run()            scenario_v1 = _ScenarioManager._create(scenario_cfg)          _ScenarioManager._submit(scenario_v1)            assert scenario_v1.d2.read() == 2          assert len(_DataManager._get_all(version_number=\"all\")) == 2          core.stop()        init_config()      scenario_cfg = config_scenario_v1()        # Production 2.0 is a compatible version      with patch(\"sys.argv\", [\"prog\", \"--production\", \"2.0\"]):          core = Core()          core.run()            scenario_v2 = _ScenarioManager._create(scenario_cfg)          _ScenarioManager._submit(scenario_v2)            assert scenario_v2.d2.read() == 2          assert len(_DataManager._get_all(version_number=\"all\")) == 4          core.stop()        init_config()        # Production 2.1      Config.add_migration_function(          target_version=\"2.1\",          config=\"d1\",          migration_fct=migrate_pickle_path,      )      scenario_cfg_v2_1 = config_scenario_v2()        with patch(\"sys.argv\", [\"prog\", \"--production\", \"2.1\"]):          core = Core()          core.run()          scenario_v2_1 = _ScenarioManager._create(scenario_cfg_v2_1)          _ScenarioManager._submit(scenario_v2_1)          core.stop()        assert scenario_v2_1.d2.read() == 6      assert len(_DataManager._get_all(version_number=\"all\")) == 6        v1 = taipy.get(scenario_v1.id)      assert v1.d1.version == \"2.1\"      assert v1.d1.path == \"bar.pkl\"        v2 = taipy.get(scenario_v2.id)      assert v2.d1.version == \"2.1\"      assert v2.d1.path == \"bar.pkl\"      def submit_v1():      scenario_cfg_v1 = config_scenario_v1()      with patch(\"sys.argv\", [\"prog\", \"--production\", \"1.0\"]):          core = Core()          core.run()          scenario_v1 = _ScenarioManager._create(scenario_cfg_v1)          _ScenarioManager._submit(scenario_v1)          core.stop()      return scenario_v1      def submit_v2():      scenario_cfg_v2 = config_scenario_v2()      with patch(\"sys.argv\", [\"prog\", \"--production\", \"2.0\"]):          core = Core()          core.run()          scenario_v2 = _ScenarioManager._create(scenario_cfg_v2)          _ScenarioManager._submit(scenario_v2)          core.stop()      return scenario_v2      def config_scenario_v1():      dn1 = Config.configure_pickle_data_node(id=\"d1\", default_data=1)      dn2 = Config.configure_pickle_data_node(id=\"d2\")      task_cfg = Config.configure_task(\"my_task\", twice, dn1, dn2)      scenario_cfg = Config.configure_scenario(\"my_scenario\", [task_cfg])      scenario_cfg.add_sequences({\"my_sequence\": [task_cfg]})      return scenario_cfg      def config_scenario_v2():      dn1 = Config.configure_pickle_data_node(id=\"d1\", default_data=2)      dn2 = Config.configure_pickle_data_node(id=\"d2\")      task_cfg = Config.configure_task(\"my_task\", triple, dn1, dn2)      scenario_cfg = Config.configure_scenario(\"my_scenario\", [task_cfg])      scenario_cfg.add_sequences({\"my_scenario\": [task_cfg]})      return scenario_cfg "}
{"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": "from time import sleep  from unittest.mock import patch    import pytest    from src.taipy.core import Core  from src.taipy.core._version._cli._version_cli import _VersionCLI  from src.taipy.core._version._version_manager import _VersionManager  from src.taipy.core.data._data_manager import _DataManager  from src.taipy.core.job._job_manager import _JobManager  from src.taipy.core.scenario._scenario_manager import _ScenarioManager  from src.taipy.core.sequence._sequence_manager import _SequenceManager  from src.taipy.core.task._task_manager import _TaskManager  from taipy.config.common.frequency import Frequency  from taipy.config.common.scope import Scope  from taipy.config.config import Config  from tests.core.conftest import init_config      def test_delete_version(caplog):      scenario_config = config_scenario()        with patch(\"sys.argv\", [\"prog\", \"--development\"]):          core = Core()          core.run()          scenario = _ScenarioManager._create(scenario_config)          _ScenarioManager._submit(scenario)          core.stop()        with patch(\"sys.argv\", [\"prog\", \"--experiment\", \"1.0\"]):          core = Core()          core.run()          scenario = _ScenarioManager._create(scenario_config)          _ScenarioManager._submit(scenario)          core.stop()        with patch(\"sys.argv\", [\"prog\", \"--experiment\", \"1.1\"]):          core = Core()          core.run()          scenario = _ScenarioManager._create(scenario_config)          _ScenarioManager._submit(scenario)          core.stop()        with patch(\"sys.argv\", [\"prog\", \"--production\", \"1.1\"]):          core = Core()          core.run()          core.stop()        with patch(\"sys.argv\", [\"prog\", \"--experiment\", \"2.0\"]):          core = Core()          core.run()          scenario = _ScenarioManager._create(scenario_config)          _ScenarioManager._submit(scenario)          core.stop()        with patch(\"sys.argv\", [\"prog\", \"--experiment\", \"2.1\"]):          core = Core()          core.run()          scenario = _ScenarioManager._create(scenario_config)          _ScenarioManager._submit(scenario)          core.stop()        with patch(\"sys.argv\", [\"prog\", \"--production\", \"2.1\"]):          core = Core()          core.run()          core.stop()        all_versions = [version.id for version in _VersionManager._get_all()]      production_version = _VersionManager._get_production_versions()      assert len(all_versions) == 5      assert len(production_version) == 2      assert \"1.0\" in all_versions      assert \"1.1\" in all_versions and \"1.1\" in production_version      assert \"2.0\" in all_versions      assert \"2.1\" in all_versions and \"2.1\" in production_version        _VersionCLI.create_parser()      with pytest.raises(SystemExit):          with patch(\"sys.argv\", [\"prog\", \"manage-versions\", \"--delete\", \"1.0\"]):              _VersionCLI.parse_arguments()        assert \"Successfully delete version 1.0.\" in caplog.text      all_versions = [version.id for version in _VersionManager._get_all()]      assert len(all_versions) == 4      assert \"1.0\" not in all_versions        # Test delete a non-existed version      with pytest.raises(SystemExit):          with patch(\"sys.argv\", [\"prog\", \"manage-versions\", \"--delete\", \"non_exist_version\"]):              _VersionCLI.parse_arguments()      assert \"Version 'non_exist_version' does not exist.\" in caplog.text        # Test delete production version will change the version from production to experiment      with pytest.raises(SystemExit):          with patch(\"sys.argv\", [\"prog\", \"manage-versions\", \"--delete-production\", \"1.1\"]):              _VersionCLI.parse_arguments()        assert \"Successfully delete version 1.1 from the production version list.\" in caplog.text      all_versions = [version.id for version in _VersionManager._get_all()]      production_version = _VersionManager._get_production_versions()      assert len(all_versions) == 4      assert \"1.1\" in all_versions and \"1.1\" not in production_version        # Test delete a non-existed production version      with pytest.raises(SystemExit) as e:          with patch(\"sys.argv\", [\"prog\", \"manage-versions\", \"--delete-production\", \"non_exist_version\"]):              _VersionCLI.parse_arguments()        assert str(e.value) == \"Version 'non_exist_version' is not a production version.\"      def test_list_versions(capsys):      with patch(\"sys.argv\", [\"prog\", \"--development\"]):          core = Core()          core.run()          core.stop()      sleep(0.05)      with patch(\"sys.argv\", [\"prog\", \"--experiment\", \"1.0\"]):          core = Core()          core.run()          core.stop()      sleep(0.05)      with patch(\"sys.argv\", [\"prog\", \"--experiment\", \"1.1\"]):          core = Core()          core.run()          core.stop()      sleep(0.05)      with patch(\"sys.argv\", [\"prog\", \"--production\", \"1.1\"]):          core = Core()          core.run()          core.stop()      sleep(0.05)      with patch(\"sys.argv\", [\"prog\", \"--experiment\", \"2.0\"]):          core = Core()          core.run()          core.stop()      sleep(0.05)      with patch(\"sys.argv\", [\"prog\", \"--experiment\", \"2.1\"]):          core = Core()          core.run()          core.stop()      sleep(0.05)      with patch(\"sys.argv\", [\"prog\", \"--production\", \"2.1\"]):          core = Core()          core.run()          core.stop()        _VersionCLI.create_parser()      with pytest.raises(SystemExit):          with patch(\"sys.argv\", [\"prog\", \"manage-versions\", \"--list\"]):              _VersionCLI.parse_arguments()        out, _ = capsys.readouterr()      version_list = str(out).strip().split(\"\\n\")      assert len(version_list) == 6  # 5 versions with the header      assert all(column in version_list[0] for column in [\"Version number\", \"Mode\", \"Creation date\"])      assert all(column in version_list[1] for column in [\"2.1\", \"Production\", \"latest\"])      assert all(column in version_list[2] for column in [\"2.0\", \"Experiment\"]) and \"latest\" not in version_list[2]      assert all(column in version_list[3] for column in [\"1.1\", \"Production\"]) and \"latest\" not in version_list[3]      assert all(column in version_list[4] for column in [\"1.0\", \"Experiment\"]) and \"latest\" not in version_list[4]      assert \"Development\" in version_list[5] and \"latest\" not in version_list[5]      def test_rename_version(caplog):      scenario_config = config_scenario()        with patch(\"sys.argv\", [\"prog\", \"--experiment\", \"1.0\"]):          core = Core()          core.run()          scenario = _ScenarioManager._create(scenario_config)          _ScenarioManager._submit(scenario)          core.stop()        with patch(\"sys.argv\", [\"prog\", \"--production\", \"2.0\"]):          core = Core()          core.run()          scenario = _ScenarioManager._create(scenario_config)          _ScenarioManager._submit(scenario)          core.stop()        dev_ver = _VersionManager._get_development_version()        _VersionCLI.create_parser()      with pytest.raises(SystemExit):          with patch(\"sys.argv\", [\"prog\", \"manage-versions\", \"--rename\", \"non_exist_version\", \"1.1\"]):              # This should raise an exception since version \"non_exist_version\" does not exist              _VersionCLI.parse_arguments()      assert \"Version 'non_exist_version' does not exist.\" in caplog.text        _VersionCLI.create_parser()      with pytest.raises(SystemExit):          with patch(\"sys.argv\", [\"prog\", \"manage-versions\", \"--rename\", \"1.0\", \"2.0\"]):              # This should raise an exception since 2.0 already exists              _VersionCLI.parse_arguments()      assert \"Version name '2.0' is already used.\" in caplog.text        _VersionCLI.create_parser()      with pytest.raises(SystemExit):          with patch(\"sys.argv\", [\"prog\", \"manage-versions\", \"--rename\", \"1.0\", \"1.1\"]):              _VersionCLI.parse_arguments()      assert _VersionManager._get(\"1.0\") is None      assert [version.id for version in _VersionManager._get_all()].sort() == [dev_ver, \"1.1\", \"2.0\"].sort()      # All entities are assigned to the new version      assert len(_DataManager._get_all(\"1.1\")) == 2      assert len(_TaskManager._get_all(\"1.1\")) == 1      assert len(_SequenceManager._get_all(\"1.1\")) == 1      assert len(_ScenarioManager._get_all(\"1.1\")) == 1      assert len(_JobManager._get_all(\"1.1\")) == 1        _VersionCLI.create_parser()      with pytest.raises(SystemExit):          with patch(\"sys.argv\", [\"prog\", \"manage-versions\", \"--rename\", \"2.0\", \"2.1\"]):              _VersionCLI.parse_arguments()      assert _VersionManager._get(\"2.0\") is None      assert [version.id for version in _VersionManager._get_all()].sort() == [dev_ver, \"1.1\", \"2.1\"].sort()      assert _VersionManager._get_production_versions() == [\"2.1\"]      # All entities are assigned to the new version      assert len(_DataManager._get_all(\"2.1\")) == 2      assert len(_TaskManager._get_all(\"2.1\")) == 1      assert len(_SequenceManager._get_all(\"2.1\")) == 1      assert len(_ScenarioManager._get_all(\"2.1\")) == 1      assert len(_JobManager._get_all(\"2.1\")) == 1      def test_compare_version_config(caplog):      scenario_config_1 = config_scenario()        with patch(\"sys.argv\", [\"prog\", \"--experiment\", \"1.0\"]):          core = Core()          core.run()          scenario = _ScenarioManager._create(scenario_config_1)          _ScenarioManager._submit(scenario)          core.stop()        init_config()        scenario_config_2 = config_scenario()      Config.configure_data_node(id=\"d2\", storage_type=\"csv\", default_path=\"bar.csv\")        with patch(\"sys.argv\", [\"prog\", \"--experiment\", \"2.0\"]):          core = Core()          core.run()          scenario = _ScenarioManager._create(scenario_config_2)          _ScenarioManager._submit(scenario)          core.stop()        _VersionCLI.create_parser()      with pytest.raises(SystemExit):          with patch(\"sys.argv\", [\"prog\", \"manage-versions\", \"--compare-config\", \"non_exist_version\", \"2.0\"]):              # This should raise an exception since version \"non_exist_version\" does not exist              _VersionCLI.parse_arguments()      assert \"Version 'non_exist_version' does not exist.\" in caplog.text        with pytest.raises(SystemExit):          with patch(\"sys.argv\", [\"prog\", \"manage-versions\", \"--compare-config\", \"1.0\", \"non_exist_version\"]):              # This should raise an exception since 2.0 already exists              _VersionCLI.parse_arguments()      assert \"Version 'non_exist_version' does not exist.\" in caplog.text        with pytest.raises(SystemExit):          with patch(\"sys.argv\", [\"prog\", \"manage-versions\", \"--compare-config\", \"1.0\", \"1.0\"]):              _VersionCLI.parse_arguments()      assert \"There is no difference between version 1.0 Configuration and version 1.0 Configuration.\" in caplog.text        with pytest.raises(SystemExit):          with patch(\"sys.argv\", [\"prog\", \"manage-versions\", \"--compare-config\", \"1.0\", \"2.0\"]):              _VersionCLI.parse_arguments()      expected_message = \"\"\"Differences between version 1.0 Configuration and version 2.0 Configuration:  \\tDATA_NODE \"d2\" has attribute \"default_path\" modified: foo.csv -> bar.csv\"\"\"      assert expected_message in caplog.text      def twice(a):      return a * 2      def config_scenario():      data_node_1_config = Config.configure_data_node(          id=\"d1\", storage_type=\"pickle\", default_data=\"abc\", scope=Scope.SCENARIO      )      data_node_2_config = Config.configure_data_node(id=\"d2\", storage_type=\"csv\", default_path=\"foo.csv\")      task_config = Config.configure_task(\"my_task\", twice, data_node_1_config, data_node_2_config)      scenario_config = Config.configure_scenario(\"my_scenario\", [task_config], frequency=Frequency.DAILY)      scenario_config.add_sequences({\"my_sequence\": [task_config]})        return scenario_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": "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": "from time import sleep  from unittest.mock import patch    import pytest    from src.taipy.core import Core  from src.taipy.core._version._cli._version_cli import _VersionCLI  from src.taipy.core._version._version_manager import _VersionManager  from src.taipy.core.data._data_manager import _DataManager  from src.taipy.core.job._job_manager import _JobManager  from src.taipy.core.scenario._scenario_manager import _ScenarioManager  from src.taipy.core.scenario._scenario_manager_factory import _ScenarioManagerFactory  from src.taipy.core.sequence._sequence_manager import _SequenceManager  from src.taipy.core.task._task_manager import _TaskManager  from taipy.config.common.frequency import Frequency  from taipy.config.common.scope import Scope  from taipy.config.config import Config  from tests.core.conftest import init_config      def test_delete_version(caplog, init_sql_repo):      _ScenarioManagerFactory._build_manager()        scenario_config = config_scenario()        with patch(\"sys.argv\", [\"prog\", \"--development\"]):          core = Core()          core.run()          scenario = _ScenarioManager._create(scenario_config)          _ScenarioManager._submit(scenario)          core.stop()        with patch(\"sys.argv\", [\"prog\", \"--experiment\", \"1.0\"]):          core = Core()          core.run()          scenario = _ScenarioManager._create(scenario_config)          _ScenarioManager._submit(scenario)          core.stop()        with patch(\"sys.argv\", [\"prog\", \"--experiment\", \"1.1\"]):          core = Core()          core.run()          scenario = _ScenarioManager._create(scenario_config)          _ScenarioManager._submit(scenario)          core.stop()        with patch(\"sys.argv\", [\"prog\", \"--production\", \"1.1\"]):          core = Core()          core.run()          core.stop()        with patch(\"sys.argv\", [\"prog\", \"--experiment\", \"2.0\"]):          core = Core()          core.run()          scenario = _ScenarioManager._create(scenario_config)          _ScenarioManager._submit(scenario)          core.stop()        with patch(\"sys.argv\", [\"prog\", \"--experiment\", \"2.1\"]):          core = Core()          core.run()          scenario = _ScenarioManager._create(scenario_config)          _ScenarioManager._submit(scenario)          core.stop()        with patch(\"sys.argv\", [\"prog\", \"--production\", \"2.1\"]):          core = Core()          core.run()          core.stop()        all_versions = [version.id for version in _VersionManager._get_all()]      production_version = _VersionManager._get_production_versions()      assert len(all_versions) == 5      assert len(production_version) == 2      assert \"1.0\" in all_versions      assert \"1.1\" in all_versions and \"1.1\" in production_version      assert \"2.0\" in all_versions      assert \"2.1\" in all_versions and \"2.1\" in production_version        _VersionCLI.create_parser()      with pytest.raises(SystemExit):          with patch(\"sys.argv\", [\"prog\", \"manage-versions\", \"--delete\", \"1.0\"]):              _VersionCLI.parse_arguments()        assert \"Successfully delete version 1.0.\" in caplog.text      all_versions = [version.id for version in _VersionManager._get_all()]      assert len(all_versions) == 4      assert \"1.0\" not in all_versions        # Test delete a non-existed version      with pytest.raises(SystemExit):          with patch(\"sys.argv\", [\"prog\", \"manage-versions\", \"--delete\", \"non_exist_version\"]):              _VersionCLI.parse_arguments()      assert \"Version 'non_exist_version' does not exist.\" in caplog.text        # Test delete production version will change the version from production to experiment      with pytest.raises(SystemExit):          with patch(\"sys.argv\", [\"prog\", \"manage-versions\", \"--delete-production\", \"1.1\"]):              _VersionCLI.parse_arguments()        assert \"Successfully delete version 1.1 from the production version list.\" in caplog.text      all_versions = [version.id for version in _VersionManager._get_all()]      production_version = _VersionManager._get_production_versions()      assert len(all_versions) == 4      assert \"1.1\" in all_versions and \"1.1\" not in production_version        # Test delete a non-existed production version      with pytest.raises(SystemExit) as e:          with patch(\"sys.argv\", [\"prog\", \"manage-versions\", \"--delete-production\", \"non_exist_version\"]):              _VersionCLI.parse_arguments()        assert str(e.value) == \"Version 'non_exist_version' is not a production version.\"      def test_list_versions(capsys, init_sql_repo):      _ScenarioManagerFactory._build_manager()        with patch(\"sys.argv\", [\"prog\", \"--development\"]):          core = Core()          core.run()          core.stop()      sleep(0.05)      with patch(\"sys.argv\", [\"prog\", \"--experiment\", \"1.0\"]):          core = Core()          core.run()          core.stop()      sleep(0.05)      with patch(\"sys.argv\", [\"prog\", \"--experiment\", \"1.1\"]):          core = Core()          core.run()          core.stop()      sleep(0.05)      with patch(\"sys.argv\", [\"prog\", \"--production\", \"1.1\"]):          core = Core()          core.run()          core.stop()      sleep(0.05)      with patch(\"sys.argv\", [\"prog\", \"--experiment\", \"2.0\"]):          core = Core()          core.run()          core.stop()      sleep(0.05)      with patch(\"sys.argv\", [\"prog\", \"--experiment\", \"2.1\"]):          core = Core()          core.run()          core.stop()      sleep(0.05)      with patch(\"sys.argv\", [\"prog\", \"--production\", \"2.1\"]):          core = Core()          core.run()          core.stop()        _VersionCLI.create_parser()      with pytest.raises(SystemExit):          with patch(\"sys.argv\", [\"prog\", \"manage-versions\", \"--list\"]):              _VersionCLI.parse_arguments()        out, _ = capsys.readouterr()      version_list = str(out).strip().split(\"\\n\")      assert len(version_list) == 6  # 5 versions with the header      assert all(column in version_list[0] for column in [\"Version number\", \"Mode\", \"Creation date\"])      assert all(column in version_list[1] for column in [\"2.1\", \"Production\", \"latest\"])      assert all(column in version_list[2] for column in [\"2.0\", \"Experiment\"]) and \"latest\" not in version_list[2]      assert all(column in version_list[3] for column in [\"1.1\", \"Production\"]) and \"latest\" not in version_list[3]      assert all(column in version_list[4] for column in [\"1.0\", \"Experiment\"]) and \"latest\" not in version_list[4]      assert \"Development\" in version_list[5] and \"latest\" not in version_list[5]      def test_rename_version(caplog, init_sql_repo):      _ScenarioManagerFactory._build_manager()        scenario_config = config_scenario()        with patch(\"sys.argv\", [\"prog\", \"--experiment\", \"1.0\"]):          core = Core()          core.run()          scenario = _ScenarioManager._create(scenario_config)          _ScenarioManager._submit(scenario)          core.stop()        with patch(\"sys.argv\", [\"prog\", \"--production\", \"2.0\"]):          core = Core()          core.run()          scenario = _ScenarioManager._create(scenario_config)          _ScenarioManager._submit(scenario)          core.stop()        dev_ver = _VersionManager._get_development_version()        _VersionCLI.create_parser()      with pytest.raises(SystemExit):          with patch(\"sys.argv\", [\"prog\", \"manage-versions\", \"--rename\", \"non_exist_version\", \"1.1\"]):              # This should raise an exception since version \"non_exist_version\" does not exist              _VersionCLI.parse_arguments()      assert \"Version 'non_exist_version' does not exist.\" in caplog.text        _VersionCLI.create_parser()      with pytest.raises(SystemExit):          with patch(\"sys.argv\", [\"prog\", \"manage-versions\", \"--rename\", \"1.0\", \"2.0\"]):              # This should raise an exception since 2.0 already exists              _VersionCLI.parse_arguments()      assert \"Version name '2.0' is already used.\" in caplog.text        _VersionCLI.create_parser()      with pytest.raises(SystemExit):          with patch(\"sys.argv\", [\"prog\", \"manage-versions\", \"--rename\", \"1.0\", \"1.1\"]):              _VersionCLI.parse_arguments()      assert _VersionManager._get(\"1.0\") is None      assert [version.id for version in _VersionManager._get_all()].sort() == [dev_ver, \"1.1\", \"2.0\"].sort()      # All entities are assigned to the new version      assert len(_DataManager._get_all(\"1.1\")) == 2      assert len(_TaskManager._get_all(\"1.1\")) == 1      assert len(_SequenceManager._get_all(\"1.1\")) == 0      assert len(_ScenarioManager._get_all(\"1.1\")) == 1      assert len(_JobManager._get_all(\"1.1\")) == 1        _VersionCLI.create_parser()      with pytest.raises(SystemExit):          with patch(\"sys.argv\", [\"prog\", \"manage-versions\", \"--rename\", \"2.0\", \"2.1\"]):              _VersionCLI.parse_arguments()      assert _VersionManager._get(\"2.0\") is None      assert [version.id for version in _VersionManager._get_all()].sort() == [dev_ver, \"1.1\", \"2.1\"].sort()      assert _VersionManager._get_production_versions() == [\"2.1\"]      # All entities are assigned to the new version      assert len(_DataManager._get_all(\"2.1\")) == 2      assert len(_TaskManager._get_all(\"2.1\")) == 1      assert len(_SequenceManager._get_all(\"2.1\")) == 0      assert len(_ScenarioManager._get_all(\"2.1\")) == 1      assert len(_JobManager._get_all(\"2.1\")) == 1      def test_compare_version_config(caplog, init_sql_repo):      _ScenarioManagerFactory._build_manager()        scenario_config_1 = config_scenario()        with patch(\"sys.argv\", [\"prog\", \"--experiment\", \"1.0\"]):          core = Core()          core.run()          scenario = _ScenarioManager._create(scenario_config_1)          _ScenarioManager._submit(scenario)          core.stop()        init_config()      Config.configure_core(repository_type=\"sql\", repository_properties={\"db_location\": init_sql_repo})      _ScenarioManagerFactory._build_manager()        scenario_config_2 = config_scenario()      Config.configure_data_node(id=\"d2\", storage_type=\"csv\", default_path=\"bar.csv\")        with patch(\"sys.argv\", [\"prog\", \"--experiment\", \"2.0\"]):          core = Core()          core.run()          scenario = _ScenarioManager._create(scenario_config_2)          _ScenarioManager._submit(scenario)          core.stop()        _VersionCLI.create_parser()      with pytest.raises(SystemExit):          with patch(\"sys.argv\", [\"prog\", \"manage-versions\", \"--compare-config\", \"non_exist_version\", \"2.0\"]):              # This should raise an exception since version \"non_exist_version\" does not exist              _VersionCLI.parse_arguments()      assert \"Version 'non_exist_version' does not exist.\" in caplog.text        with pytest.raises(SystemExit):          with patch(\"sys.argv\", [\"prog\", \"manage-versions\", \"--compare-config\", \"1.0\", \"non_exist_version\"]):              # This should raise an exception since 2.0 already exists              _VersionCLI.parse_arguments()      assert \"Version 'non_exist_version' does not exist.\" in caplog.text        with pytest.raises(SystemExit):          with patch(\"sys.argv\", [\"prog\", \"manage-versions\", \"--compare-config\", \"1.0\", \"1.0\"]):              _VersionCLI.parse_arguments()      assert \"There is no difference between version 1.0 Configuration and version 1.0 Configuration.\" in caplog.text        with pytest.raises(SystemExit):          with patch(\"sys.argv\", [\"prog\", \"manage-versions\", \"--compare-config\", \"1.0\", \"2.0\"]):              _VersionCLI.parse_arguments()      expected_message = \"\"\"Differences between version 1.0 Configuration and version 2.0 Configuration:  \\tDATA_NODE \"d2\" has attribute \"default_path\" modified: foo.csv -> bar.csv\"\"\"      assert expected_message in caplog.text      def twice(a):      return a * 2      def config_scenario():      data_node_1_config = Config.configure_data_node(          id=\"d1\", storage_type=\"pickle\", default_data=\"abc\", scope=Scope.SCENARIO      )      data_node_2_config = Config.configure_data_node(id=\"d2\", storage_type=\"csv\", default_path=\"foo.csv\")      task_config = Config.configure_task(\"my_task\", twice, data_node_1_config, data_node_2_config)      scenario_config = Config.configure_scenario(\"my_scenario\", [task_config], frequency=Frequency.DAILY)        return scenario_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": "import multiprocessing  import random  import string  from concurrent.futures import ProcessPoolExecutor  from datetime import datetime, timedelta  from functools import partial  from time import sleep    import pytest    from src.taipy.core import taipy  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.data._data_manager import _DataManager  from src.taipy.core.data.pickle import PickleDataNode  from src.taipy.core.scenario._scenario_manager import _ScenarioManager  from src.taipy.core.scenario.scenario import Scenario  from src.taipy.core.sequence.sequence import Sequence  from src.taipy.core.submission._submission_manager import _SubmissionManager  from src.taipy.core.submission.submission_status import SubmissionStatus  from src.taipy.core.task._task_manager import _TaskManager  from src.taipy.core.task.task import Task  from taipy.config import Config  from taipy.config.common.scope import Scope  from taipy.config.exceptions.exceptions import ConfigurationUpdateBlocked  from tests.core.utils import assert_true_after_time      # ################################  USER FUNCTIONS  ##################################      def multiply(nb1: float, nb2: float):      sleep(0.1)      return nb1 * nb2      def lock_multiply(lock, nb1: float, nb2: float):      with lock:          return multiply(nb1, nb2)      def mult_by_2(n):      return n * 2      def nothing():      return True      def concat(a, b):      return a + b      def _error():      raise Exception      # ################################  TEST METHODS    ##################################      def test_submit_task():      Config.configure_job_executions(mode=JobConfig._DEVELOPMENT_MODE)        before_creation = datetime.now()      sleep(0.1)      task = _create_task(multiply)      output_dn_id = task.output[f\"{task.config_id}_output0\"].id        _OrchestratorFactory._build_dispatcher()        assert _DataManager._get(output_dn_id).last_edit_date > before_creation      assert _DataManager._get(output_dn_id).job_ids == []      assert _DataManager._get(output_dn_id).is_ready_for_reading        before_submission_creation = datetime.now()      sleep(0.1)      job = _Orchestrator.submit_task(task)      sleep(0.1)      after_submission_creation = datetime.now()      assert _DataManager._get(output_dn_id).read() == 42      assert _DataManager._get(output_dn_id).last_edit_date > before_submission_creation      assert _DataManager._get(output_dn_id).last_edit_date < after_submission_creation      assert _DataManager._get(output_dn_id).job_ids == [job.id]      assert _DataManager._get(output_dn_id).is_ready_for_reading      assert job.is_completed()      assert _SubmissionManager._get(job.submit_id).submission_status == SubmissionStatus.COMPLETED      def test_submit_sequence_generate_unique_submit_id():      dn_1 = PickleDataNode(\"dn_config_id_1\", Scope.SCENARIO)      dn_2 = PickleDataNode(\"dn_config_id_2\", Scope.SCENARIO)      task_1 = Task(\"task_config_id_1\", {}, print, [dn_1])      task_2 = Task(\"task_config_id_2\", {}, print, [dn_1], [dn_2])        _DataManager._set(dn_1)      _DataManager._set(dn_2)      _TaskManager._set(task_1)      _TaskManager._set(task_2)        scenario = Scenario(\"scenario\", [task_1, task_2], {}, sequences={\"sequence\": {\"tasks\": [task_1, task_2]}})      _ScenarioManager._set(scenario)        sequence = scenario.sequences[\"sequence\"]        jobs_1 = taipy.submit(sequence)      jobs_2 = taipy.submit(sequence)      assert len(jobs_1) == 2      assert len(jobs_2) == 2      submit_ids_1 = [job.submit_id for job in jobs_1]      submit_ids_2 = [job.submit_id for job in jobs_2]      assert len(set(submit_ids_1)) == 1      assert len(set(submit_ids_2)) == 1      assert set(submit_ids_1) != set(submit_ids_2)      def test_submit_scenario_generate_unique_submit_id():      dn_1 = PickleDataNode(\"dn_config_id_1\", Scope.SCENARIO)      dn_2 = PickleDataNode(\"dn_config_id_2\", Scope.SCENARIO)      dn_3 = PickleDataNode(\"dn_config_id_3\", Scope.SCENARIO)      task_1 = Task(\"task_config_id_1\", {}, print, [dn_1])      task_2 = Task(\"task_config_id_2\", {}, print, [dn_2])      task_3 = Task(\"task_config_id_3\", {}, print, [dn_3])      scenario = Scenario(\"scenario_config_id\", [task_1, task_2, task_3], {})        _DataManager._set(dn_1)      _DataManager._set(dn_2)      _TaskManager._set(task_1)      _TaskManager._set(task_2)      _TaskManager._set(task_3)      _ScenarioManager._set(scenario)        jobs_1 = taipy.submit(scenario)      jobs_2 = taipy.submit(scenario)        assert len(jobs_1) == 3      assert len(jobs_2) == 3      def test_submit_entity_store_entity_id_in_job():      dn_1 = PickleDataNode(\"dn_config_id_1\", Scope.SCENARIO)      dn_2 = PickleDataNode(\"dn_config_id_2\", Scope.SCENARIO)      dn_3 = PickleDataNode(\"dn_config_id_3\", Scope.SCENARIO)      task_1 = Task(\"task_config_id_1\", {}, print, [dn_1])      task_2 = Task(\"task_config_id_2\", {}, print, [dn_2])      task_3 = Task(\"task_config_id_3\", {}, print, [dn_3])      scenario = Scenario(\"scenario_config_id\", [task_1, task_2, task_3], {})        _DataManager._set(dn_1)      _DataManager._set(dn_2)      _TaskManager._set(task_1)      _TaskManager._set(task_2)      _TaskManager._set(task_3)      _ScenarioManager._set(scenario)        jobs_1 = taipy.submit(scenario)      assert all(job.submit_entity_id == scenario.id for job in jobs_1)        job_1 = taipy.submit(task_1)      assert job_1.submit_entity_id == task_1.id      def test_submit_task_that_return_multiple_outputs():      Config.configure_job_executions(mode=JobConfig._DEVELOPMENT_MODE)        def return_2tuple(nb1, nb2):          return multiply(nb1, nb2), multiply(nb1, nb2) / 2        def return_list(nb1, nb2):          return [multiply(nb1, nb2), multiply(nb1, nb2) / 2]        with_tuple = _create_task(return_2tuple, 2)      with_list = _create_task(return_list, 2)        _OrchestratorFactory._build_dispatcher()        _Orchestrator.submit_task(with_tuple)      _Orchestrator.submit_task(with_list)        assert (          with_tuple.output[f\"{with_tuple.config_id}_output0\"].read()          == with_list.output[f\"{with_list.config_id}_output0\"].read()          == 42      )      assert (          with_tuple.output[f\"{with_tuple.config_id}_output1\"].read()          == with_list.output[f\"{with_list.config_id}_output1\"].read()          == 21      )      def test_submit_task_returns_single_iterable_output():      Config.configure_job_executions(mode=JobConfig._DEVELOPMENT_MODE)        def return_2tuple(nb1, nb2):          return multiply(nb1, nb2), multiply(nb1, nb2) / 2        def return_list(nb1, nb2):          return [multiply(nb1, nb2), multiply(nb1, nb2) / 2]        task_with_tuple = _create_task(return_2tuple, 1)      task_with_list = _create_task(return_list, 1)        _OrchestratorFactory._build_dispatcher()        _Orchestrator.submit_task(task_with_tuple)      assert task_with_tuple.output[f\"{task_with_tuple.config_id}_output0\"].read() == (42, 21)      assert len(_OrchestratorFactory._dispatcher._dispatched_processes) == 0      _Orchestrator.submit_task(task_with_list)      assert task_with_list.output[f\"{task_with_list.config_id}_output0\"].read() == [42, 21]      assert len(_OrchestratorFactory._dispatcher._dispatched_processes) == 0      def test_data_node_not_written_due_to_wrong_result_nb():      Config.configure_job_executions(mode=JobConfig._DEVELOPMENT_MODE)        def return_2tuple():          return lambda nb1, nb2: (multiply(nb1, nb2), multiply(nb1, nb2) / 2)        task = _create_task(return_2tuple(), 3)        _OrchestratorFactory._build_dispatcher()        job = _Orchestrator.submit_task(task)      assert task.output[f\"{task.config_id}_output0\"].read() == 0      assert job.is_failed()      assert len(_OrchestratorFactory._dispatcher._dispatched_processes) == 0      assert _SubmissionManager._get(job.submit_id).submission_status == SubmissionStatus.FAILED      def test_scenario_only_submit_same_task_once():      Config.configure_job_executions(mode=JobConfig._DEVELOPMENT_MODE)      _OrchestratorFactory._build_dispatcher()        dn_0 = PickleDataNode(\"dn_config_0\", Scope.SCENARIO, properties={\"default_data\": 0})      dn_1 = PickleDataNode(\"dn_config_1\", Scope.SCENARIO, properties={\"default_data\": 1})      dn_2 = PickleDataNode(\"dn_config_2\", Scope.SCENARIO, properties={\"default_data\": 2})      task_1 = Task(\"task_config_1\", {}, print, input=[dn_0], output=[dn_1], id=\"task_1\")      task_2 = Task(\"task_config_2\", {}, print, input=[dn_1], id=\"task_2\")      task_3 = Task(\"task_config_3\", {}, print, input=[dn_1], output=[dn_2], id=\"task_3\")      scenario_1 = Scenario(          \"scenario_config_1\",          [task_1, task_2, task_3],          {},          \"scenario_1\",          sequences={\"sequence_1\": {\"tasks\": [task_1, task_2]}, \"sequence_2\": {\"tasks\": [task_1, task_3]}},      )      sequence_1 = scenario_1.sequences[\"sequence_1\"]      sequence_2 = scenario_1.sequences[\"sequence_2\"]        jobs = _Orchestrator.submit(scenario_1)      assert len(jobs) == 3      assert all([job.is_completed() for job in jobs])      assert all(not _Orchestrator._is_blocked(job) for job in jobs)      assert _SubmissionManager._get(jobs[0].submit_id).submission_status == SubmissionStatus.COMPLETED        jobs = _Orchestrator.submit(sequence_1)      assert len(jobs) == 2      assert all([job.is_completed() for job in jobs])      assert all(not _Orchestrator._is_blocked(job) for job in jobs)      assert _SubmissionManager._get(jobs[0].submit_id).submission_status == SubmissionStatus.COMPLETED        jobs = _Orchestrator.submit(sequence_2)      assert len(jobs) == 2      assert all([job.is_completed() for job in jobs])      assert all(not _Orchestrator._is_blocked(job) for job in jobs)      assert _SubmissionManager._get(jobs[0].submit_id).submission_status == SubmissionStatus.COMPLETED      def test_update_status_fail_job():      Config.configure_job_executions(mode=JobConfig._DEVELOPMENT_MODE)      _OrchestratorFactory._build_dispatcher()        dn_0 = PickleDataNode(\"dn_config_0\", Scope.SCENARIO, properties={\"default_data\": 0})      dn_1 = PickleDataNode(\"dn_config_1\", Scope.SCENARIO, properties={\"default_data\": 1})      dn_2 = PickleDataNode(\"dn_config_2\", Scope.SCENARIO, properties={\"default_data\": 2})      task_0 = Task(\"task_config_0\", {}, _error, output=[dn_0], id=\"task_0\")      task_1 = Task(\"task_config_1\", {}, print, input=[dn_0], output=[dn_1], id=\"task_1\")      task_2 = Task(\"task_config_2\", {}, print, input=[dn_1], id=\"task_2\")      task_3 = Task(\"task_config_3\", {}, print, input=[dn_2], id=\"task_3\")      scenario_1 = Scenario(\"scenario_config_1\", [task_0, task_1, task_2, task_3], {}, \"scenario_1\")      scenario_2 = Scenario(\"scenario_config_2\", [task_0, task_1, task_2, task_3], {}, \"scenario_2\")        _DataManager._set(dn_0)      _DataManager._set(dn_1)      _DataManager._set(dn_2)      _TaskManager._set(task_0)      _TaskManager._set(task_1)      _TaskManager._set(task_2)      _TaskManager._set(task_3)      _ScenarioManager._set(scenario_1)      _ScenarioManager._set(scenario_2)        job = _Orchestrator.submit_task(task_0)      assert job.is_failed()      assert _SubmissionManager._get(job.submit_id).submission_status == SubmissionStatus.FAILED        jobs = _Orchestrator.submit(scenario_1)      tasks_jobs = {job._task.id: job for job in jobs}      assert tasks_jobs[\"task_0\"].is_failed()      assert all([job.is_abandoned() for job in [tasks_jobs[\"task_1\"], tasks_jobs[\"task_2\"]]])      assert tasks_jobs[\"task_3\"].is_completed()      assert all(not _Orchestrator._is_blocked(job) for job in jobs)      assert _SubmissionManager._get(jobs[0].submit_id).submission_status == SubmissionStatus.FAILED        jobs = _Orchestrator.submit(scenario_2)      tasks_jobs = {job._task.id: job for job in jobs}      assert tasks_jobs[\"task_0\"].is_failed()      assert all([job.is_abandoned() for job in [tasks_jobs[\"task_1\"], tasks_jobs[\"task_2\"]]])      assert tasks_jobs[\"task_3\"].is_completed()      assert all(not _Orchestrator._is_blocked(job) for job in jobs)      assert _SubmissionManager._get(jobs[0].submit_id).submission_status == SubmissionStatus.FAILED      def test_update_status_fail_job_in_parallel_one_job():      Config.configure_job_executions(mode=JobConfig._STANDALONE_MODE, max_nb_of_workers=2)      _OrchestratorFactory._build_dispatcher()        dn = PickleDataNode(\"dn_config_0\", Scope.SCENARIO, properties={\"default_data\": 0})      task = Task(\"task_config_0\", {}, _error, output=[dn], id=\"task_0\")      _DataManager._set(dn)      _TaskManager._set(task)      job = _Orchestrator.submit_task(task)      assert_true_after_time(job.is_failed)      assert_true_after_time(lambda: _SubmissionManager._get(job.submit_id).submission_status == SubmissionStatus.FAILED)      def test_update_status_fail_job_in_parallel_one_sequence():      Config.configure_job_executions(mode=JobConfig._STANDALONE_MODE, max_nb_of_workers=2)      _OrchestratorFactory._build_dispatcher()        dn_0 = PickleDataNode(\"dn_config_0\", Scope.SCENARIO, properties={\"default_data\": 0})      dn_1 = PickleDataNode(\"dn_config_1\", Scope.SCENARIO, properties={\"default_data\": 1})      dn_2 = PickleDataNode(\"dn_config_2\", Scope.SCENARIO, properties={\"default_data\": 2})      task_0 = Task(\"task_config_0\", {}, _error, output=[dn_0], id=\"task_0\")      task_1 = Task(\"task_config_1\", {}, print, input=[dn_0], output=[dn_1], id=\"task_1\")      task_2 = Task(\"task_config_2\", {}, print, input=[dn_1], id=\"task_2\")      task_3 = Task(\"task_config_3\", {}, print, input=[dn_2], id=\"task_3\")      sc = Scenario(          \"scenario_config_1\",          set([task_0, task_1, task_2, task_3]),          {},          set(),          \"scenario_1\",          sequences={\"sequence_1\": {\"tasks\": [task_0, task_1, task_2]}},      )      _DataManager._set(dn_0)      _DataManager._set(dn_1)      _DataManager._set(dn_2)      _TaskManager._set(task_0)      _TaskManager._set(task_1)      _TaskManager._set(task_2)      _TaskManager._set(task_3)      _ScenarioManager._set(sc)        jobs = _Orchestrator.submit(sc.sequences[\"sequence_1\"])        tasks_jobs = {job._task.id: job for job in jobs}      assert_true_after_time(tasks_jobs[\"task_0\"].is_failed)      assert_true_after_time(lambda: all([job.is_abandoned() for job in [tasks_jobs[\"task_1\"], tasks_jobs[\"task_2\"]]]))      assert_true_after_time(lambda: all(not _Orchestrator._is_blocked(job) for job in jobs))      submit_id = jobs[0].submit_id      submission = _SubmissionManager._get(submit_id)      assert_true_after_time(lambda: submission.submission_status == SubmissionStatus.FAILED)      def test_update_status_fail_job_in_parallel_one_scenario():      Config.configure_job_executions(mode=JobConfig._STANDALONE_MODE, max_nb_of_workers=2)      _OrchestratorFactory._build_dispatcher()        dn_0 = PickleDataNode(\"dn_config_0\", Scope.SCENARIO, properties={\"default_data\": 0})      dn_1 = PickleDataNode(\"dn_config_1\", Scope.SCENARIO, properties={\"default_data\": 1})      dn_2 = PickleDataNode(\"dn_config_2\", Scope.SCENARIO, properties={\"default_data\": 2})      task_0 = Task(\"task_config_0\", {}, _error, output=[dn_0], id=\"task_0\")      task_1 = Task(\"task_config_1\", {}, print, input=[dn_0], output=[dn_1], id=\"task_1\")      task_2 = Task(\"task_config_2\", {}, print, input=[dn_1], id=\"task_2\")      task_3 = Task(\"task_config_3\", {}, print, input=[dn_2], id=\"task_3\")      sc = Scenario(\"scenario_config_1\", set([task_0, task_1, task_2, task_3]), {}, set(), \"scenario_1\")        _DataManager._set(dn_0)      _DataManager._set(dn_1)      _DataManager._set(dn_2)      _TaskManager._set(task_0)      _TaskManager._set(task_1)      _TaskManager._set(task_2)      _TaskManager._set(task_3)      _ScenarioManager._set(sc)        jobs = _Orchestrator.submit(sc)        tasks_jobs = {job._task.id: job for job in jobs}      assert_true_after_time(tasks_jobs[\"task_0\"].is_failed)      assert_true_after_time(tasks_jobs[\"task_3\"].is_completed)      assert_true_after_time(lambda: all([job.is_abandoned() for job in [tasks_jobs[\"task_1\"], tasks_jobs[\"task_2\"]]]))      assert_true_after_time(lambda: all(not _Orchestrator._is_blocked(job) for job in jobs))      submit_id = jobs[0].submit_id      submission = _SubmissionManager._get(submit_id)      assert_true_after_time(lambda: submission.submission_status == SubmissionStatus.FAILED)      def test_submit_task_in_parallel():      m = multiprocessing.Manager()      lock = m.Lock()        Config.configure_job_executions(mode=JobConfig._STANDALONE_MODE, max_nb_of_workers=2)        task = _create_task(partial(lock_multiply, lock))        _OrchestratorFactory._build_dispatcher()        with lock:          assert task.output[f\"{task.config_id}_output0\"].read() == 0          job = _Orchestrator.submit_task(task)          assert_true_after_time(job.is_running)          assert_true_after_time(lambda: len(_OrchestratorFactory._dispatcher._dispatched_processes) == 1)          assert_true_after_time(              lambda: _SubmissionManager._get(job.submit_id).submission_status == SubmissionStatus.RUNNING          )        assert_true_after_time(lambda: task.output[f\"{task.config_id}_output0\"].read() == 42)      assert_true_after_time(job.is_completed)      assert_true_after_time(          lambda: _SubmissionManager._get(job.submit_id).submission_status == SubmissionStatus.COMPLETED      )      assert len(_OrchestratorFactory._dispatcher._dispatched_processes) == 0      def test_submit_sequence_in_parallel():      m = multiprocessing.Manager()      lock = m.Lock()        Config.configure_job_executions(mode=JobConfig._STANDALONE_MODE, max_nb_of_workers=2)        task = _create_task(partial(lock_multiply, lock))      sequence = Sequence({}, [task], \"sequence_id\")        _OrchestratorFactory._build_dispatcher()        with lock:          assert task.output[f\"{task.config_id}_output0\"].read() == 0          job = _Orchestrator.submit(sequence)[0]          assert_true_after_time(job.is_running)          assert_true_after_time(lambda: len(_OrchestratorFactory._dispatcher._dispatched_processes) == 1)          assert_true_after_time(              lambda: _SubmissionManager._get(job.submit_id).submission_status == SubmissionStatus.RUNNING          )        assert_true_after_time(lambda: task.output[f\"{task.config_id}_output0\"].read() == 42)      assert_true_after_time(job.is_completed)      assert_true_after_time(          lambda: _SubmissionManager._get(job.submit_id).submission_status == SubmissionStatus.COMPLETED      )      assert len(_OrchestratorFactory._dispatcher._dispatched_processes) == 0      def test_submit_scenario_in_parallel():      m = multiprocessing.Manager()      lock = m.Lock()        Config.configure_job_executions(mode=JobConfig._STANDALONE_MODE, max_nb_of_workers=2)        task = _create_task(partial(lock_multiply, lock))      scenario = Scenario(\"scenario_config\", [task], {}, [], \"scenario_id\")        _OrchestratorFactory._build_dispatcher()        with lock:          assert task.output[f\"{task.config_id}_output0\"].read() == 0          job = _Orchestrator.submit(scenario)[0]          assert_true_after_time(job.is_running)          assert_true_after_time(lambda: len(_OrchestratorFactory._dispatcher._dispatched_processes) == 1)          assert_true_after_time(              lambda: _SubmissionManager._get(job.submit_id).submission_status == SubmissionStatus.RUNNING          )        assert_true_after_time(lambda: task.output[f\"{task.config_id}_output0\"].read() == 42)      assert_true_after_time(job.is_completed)      assert_true_after_time(          lambda: _SubmissionManager._get(job.submit_id).submission_status == SubmissionStatus.COMPLETED      )      assert len(_OrchestratorFactory._dispatcher._dispatched_processes) == 0      def sleep_fct(seconds):      sleep(seconds)      def sleep_and_raise_error_fct(seconds):      sleep(seconds)      raise Exception      def test_submit_task_synchronously_in_parallel():      Config.configure_job_executions(mode=JobConfig._STANDALONE_MODE, max_nb_of_workers=2)      _OrchestratorFactory._build_dispatcher()        sleep_period = 1      start_time = datetime.now()      task = Task(\"sleep_task\", {}, function=partial(sleep, sleep_period))      job = _Orchestrator.submit_task(task, wait=True)      assert (datetime.now() - start_time).seconds >= sleep_period      assert_true_after_time(job.is_completed)      assert_true_after_time(          lambda: _SubmissionManager._get(job.submit_id).submission_status == SubmissionStatus.COMPLETED      )      def test_submit_sequence_synchronously_in_parallel():      Config.configure_job_executions(mode=JobConfig._STANDALONE_MODE, max_nb_of_workers=2)      _OrchestratorFactory._build_dispatcher()        sleep_period = 1      start_time = datetime.now()      task = Task(\"sleep_task\", {}, function=partial(sleep, sleep_period))      sequence = Sequence({}, [task], \"sequence_id\")        job = _Orchestrator.submit(sequence, wait=True)[0]      assert (datetime.now() - start_time).seconds >= sleep_period      assert_true_after_time(job.is_completed)      assert_true_after_time(          lambda: _SubmissionManager._get(job.submit_id).submission_status == SubmissionStatus.COMPLETED      )      def test_submit_scenario_synchronously_in_parallel():      Config.configure_job_executions(mode=JobConfig._STANDALONE_MODE, max_nb_of_workers=2)      _OrchestratorFactory._build_dispatcher()        sleep_period = 1      start_time = datetime.now()      task = Task(\"sleep_task\", {}, function=partial(sleep, sleep_period))      scenario = Scenario(\"scenario_config\", [task], {})        job = _Orchestrator.submit(scenario, wait=True)[0]      assert (datetime.now() - start_time).seconds >= sleep_period      assert_true_after_time(job.is_completed)      assert_true_after_time(          lambda: _SubmissionManager._get(job.submit_id).submission_status == SubmissionStatus.COMPLETED      )      def test_submit_fail_task_synchronously_in_parallel():      Config.configure_job_executions(mode=JobConfig._STANDALONE_MODE, max_nb_of_workers=2)      _OrchestratorFactory._build_dispatcher()        sleep_period = 1.0      start_time = datetime.now()      task = Task(\"sleep_task\", {}, function=partial(sleep_and_raise_error_fct, sleep_period))      job = _Orchestrator.submit_task(task, wait=True)      assert (datetime.now() - start_time).seconds >= sleep_period      assert_true_after_time(job.is_failed)      assert_true_after_time(lambda: _SubmissionManager._get(job.submit_id).submission_status == SubmissionStatus.FAILED)      def test_submit_fail_sequence_synchronously_in_parallel():      Config.configure_job_executions(mode=JobConfig._STANDALONE_MODE, max_nb_of_workers=2)      _OrchestratorFactory._build_dispatcher()        sleep_period = 1.0      start_time = datetime.now()      task = Task(\"sleep_task\", {}, function=partial(sleep_and_raise_error_fct, sleep_period))      sequence = Sequence({}, [task], \"sequence_id\")        job = _Orchestrator.submit(sequence, wait=True)[0]      assert (datetime.now() - start_time).seconds >= sleep_period      assert_true_after_time(job.is_failed)      assert_true_after_time(lambda: _SubmissionManager._get(job.submit_id).submission_status == SubmissionStatus.FAILED)      def test_submit_fail_scenario_synchronously_in_parallel():      Config.configure_job_executions(mode=JobConfig._STANDALONE_MODE, max_nb_of_workers=2)      _OrchestratorFactory._build_dispatcher()        sleep_period = 1.0      start_time = datetime.now()      task = Task(\"sleep_task\", {}, function=partial(sleep_and_raise_error_fct, sleep_period))      scenario = Scenario(\"scenario_config\", [task], {})        job = _Orchestrator.submit(scenario, wait=True)[0]      assert (datetime.now() - start_time).seconds >= sleep_period      assert_true_after_time(job.is_failed)      assert_true_after_time(lambda: _SubmissionManager._get(job.submit_id).submission_status == SubmissionStatus.FAILED)      def test_submit_task_synchronously_in_parallel_with_timeout():      Config.configure_job_executions(mode=JobConfig._STANDALONE_MODE, max_nb_of_workers=2)      _OrchestratorFactory._build_dispatcher()        task_duration = 2      timeout_duration = task_duration - 1      task = Task(\"sleep_task\", {}, function=partial(sleep, task_duration))        start_time = datetime.now()      job = _Orchestrator.submit_task(task, wait=True, timeout=timeout_duration)      end_time = datetime.now()        assert timeout_duration <= (end_time - start_time).seconds      assert_true_after_time(job.is_completed)      assert_true_after_time(          lambda: _SubmissionManager._get(job.submit_id).submission_status == SubmissionStatus.COMPLETED      )      def test_submit_task_multithreading_multiple_task():      Config.configure_job_executions(mode=JobConfig._STANDALONE_MODE, max_nb_of_workers=2)        m = multiprocessing.Manager()      lock_1 = m.Lock()      lock_2 = m.Lock()        task_1 = _create_task(partial(lock_multiply, lock_1))      task_2 = _create_task(partial(lock_multiply, lock_2))        _OrchestratorFactory._build_dispatcher()        with lock_1:          with lock_2:              job_1 = _Orchestrator.submit_task(task_1)              job_2 = _Orchestrator.submit_task(task_2)                assert task_1.output[f\"{task_1.config_id}_output0\"].read() == 0              assert task_2.output[f\"{task_2.config_id}_output0\"].read() == 0              assert_true_after_time(job_1.is_running)              assert_true_after_time(job_2.is_running)              assert_true_after_time(lambda: len(_OrchestratorFactory._dispatcher._dispatched_processes) == 2)              assert_true_after_time(                  lambda: _SubmissionManager._get(job_1.submit_id).submission_status == SubmissionStatus.RUNNING              )              assert_true_after_time(                  lambda: _SubmissionManager._get(job_2.submit_id).submission_status == SubmissionStatus.RUNNING              )            assert_true_after_time(lambda: task_2.output[f\"{task_2.config_id}_output0\"].read() == 42)          assert task_1.output[f\"{task_1.config_id}_output0\"].read() == 0          assert_true_after_time(job_2.is_completed)          assert_true_after_time(job_1.is_running)          assert_true_after_time(lambda: len(_OrchestratorFactory._dispatcher._dispatched_processes) == 1)          assert_true_after_time(              lambda: _SubmissionManager._get(job_1.submit_id).submission_status == SubmissionStatus.RUNNING          )          assert_true_after_time(              lambda: _SubmissionManager._get(job_2.submit_id).submission_status == SubmissionStatus.COMPLETED          )        assert_true_after_time(lambda: task_1.output[f\"{task_1.config_id}_output0\"].read() == 42)      assert_true_after_time(job_1.is_completed)      assert_true_after_time(lambda: len(_OrchestratorFactory._dispatcher._dispatched_processes) == 0)      assert_true_after_time(          lambda: _SubmissionManager._get(job_1.submit_id).submission_status == SubmissionStatus.COMPLETED      )        assert job_2.is_completed()      assert _SubmissionManager._get(job_2.submit_id).submission_status == SubmissionStatus.COMPLETED      def test_submit_sequence_multithreading_multiple_task():      Config.configure_job_executions(mode=JobConfig._STANDALONE_MODE, max_nb_of_workers=2)        m = multiprocessing.Manager()      lock_1 = m.Lock()      lock_2 = m.Lock()        task_1 = _create_task(partial(lock_multiply, lock_1))      task_2 = _create_task(partial(lock_multiply, lock_2))        sequence = Sequence({}, [task_1, task_2], \"sequence_id\")        _OrchestratorFactory._build_dispatcher()        with lock_1:          with lock_2:              tasks_jobs = {job._task.id: job for job in _Orchestrator.submit(sequence)}              job_1 = tasks_jobs[task_1.id]              job_2 = tasks_jobs[task_2.id]                assert task_1.output[f\"{task_1.config_id}_output0\"].read() == 0              assert task_2.output[f\"{task_2.config_id}_output0\"].read() == 0              assert_true_after_time(job_1.is_running)              assert_true_after_time(job_2.is_running)              assert_true_after_time(lambda: len(_OrchestratorFactory._dispatcher._dispatched_processes) == 2)              assert_true_after_time(                  lambda: _SubmissionManager._get(job_1.submit_id).submission_status == SubmissionStatus.RUNNING              )            assert_true_after_time(lambda: task_2.output[f\"{task_2.config_id}_output0\"].read() == 42)          assert task_1.output[f\"{task_1.config_id}_output0\"].read() == 0          assert_true_after_time(job_2.is_completed)          assert_true_after_time(job_1.is_running)          assert_true_after_time(lambda: len(_OrchestratorFactory._dispatcher._dispatched_processes) == 1)          assert_true_after_time(              lambda: _SubmissionManager._get(job_1.submit_id).submission_status == SubmissionStatus.RUNNING          )        assert_true_after_time(lambda: task_1.output[f\"{task_1.config_id}_output0\"].read() == 42)      assert_true_after_time(job_1.is_completed)      assert_true_after_time(lambda: len(_OrchestratorFactory._dispatcher._dispatched_processes) == 0)      assert_true_after_time(          lambda: _SubmissionManager._get(job_1.submit_id).submission_status == SubmissionStatus.COMPLETED      )        assert job_2.is_completed()      assert _SubmissionManager._get(job_2.submit_id).submission_status == SubmissionStatus.COMPLETED      def test_submit_scenario_multithreading_multiple_task():      Config.configure_job_executions(mode=JobConfig._STANDALONE_MODE, max_nb_of_workers=2)        m = multiprocessing.Manager()      lock_1 = m.Lock()      lock_2 = m.Lock()        task_1 = _create_task(partial(lock_multiply, lock_1))      task_2 = _create_task(partial(lock_multiply, lock_2))        scenario = Scenario(\"scenario_config\", [task_1, task_2], {})        _OrchestratorFactory._build_dispatcher()        with lock_1:          with lock_2:              tasks_jobs = {job._task.id: job for job in _Orchestrator.submit(scenario)}              job_1 = tasks_jobs[task_1.id]              job_2 = tasks_jobs[task_2.id]                assert task_1.output[f\"{task_1.config_id}_output0\"].read() == 0              assert task_2.output[f\"{task_2.config_id}_output0\"].read() == 0              assert_true_after_time(job_1.is_running)              assert_true_after_time(job_2.is_running)              assert_true_after_time(lambda: len(_OrchestratorFactory._dispatcher._dispatched_processes) == 2)              assert_true_after_time(                  lambda: _SubmissionManager._get(job_1.submit_id).submission_status == SubmissionStatus.RUNNING              )          assert_true_after_time(lambda: task_2.output[f\"{task_2.config_id}_output0\"].read() == 42)          assert task_1.output[f\"{task_1.config_id}_output0\"].read() == 0          assert_true_after_time(job_2.is_completed)          assert_true_after_time(job_1.is_running)          assert_true_after_time(lambda: len(_OrchestratorFactory._dispatcher._dispatched_processes) == 1)          assert_true_after_time(              lambda: _SubmissionManager._get(job_1.submit_id).submission_status == SubmissionStatus.RUNNING          )        assert_true_after_time(lambda: task_1.output[f\"{task_1.config_id}_output0\"].read() == 42)      assert_true_after_time(job_1.is_completed)      assert_true_after_time(lambda: len(_OrchestratorFactory._dispatcher._dispatched_processes) == 0)      assert_true_after_time(job_2.is_completed)      assert_true_after_time(          lambda: _SubmissionManager._get(job_1.submit_id).submission_status == SubmissionStatus.COMPLETED      )      def test_submit_task_multithreading_multiple_task_in_sync_way_to_check_job_status():      # TODO      Config.configure_job_executions(mode=JobConfig._STANDALONE_MODE, max_nb_of_workers=2)        m = multiprocessing.Manager()      lock_0 = m.Lock()      lock_1 = m.Lock()      lock_2 = m.Lock()        task_0 = _create_task(partial(lock_multiply, lock_0))      task_1 = _create_task(partial(lock_multiply, lock_1))      task_2 = _create_task(partial(lock_multiply, lock_2))        _OrchestratorFactory._build_dispatcher()        with lock_0:          job_0 = _Orchestrator.submit_task(task_0)          assert_true_after_time(job_0.is_running)          assert_true_after_time(lambda: len(_OrchestratorFactory._dispatcher._dispatched_processes) == 1)          assert_true_after_time(              lambda: _SubmissionManager._get(job_0.submit_id).submission_status == SubmissionStatus.RUNNING          )          with lock_1:              with lock_2:                  assert task_1.output[f\"{task_1.config_id}_output0\"].read() == 0                  assert task_2.output[f\"{task_2.config_id}_output0\"].read() == 0                  job_2 = _Orchestrator.submit_task(task_2)                  job_1 = _Orchestrator.submit_task(task_1)                  assert_true_after_time(job_0.is_running)                  assert_true_after_time(job_1.is_pending)                  assert_true_after_time(job_2.is_running)                  assert_true_after_time(                      lambda: _SubmissionManager._get(job_0.submit_id).submission_status == SubmissionStatus.RUNNING                  )                  assert_true_after_time(                      lambda: _SubmissionManager._get(job_1.submit_id).submission_status == SubmissionStatus.PENDING                  )                  assert_true_after_time(                      lambda: _SubmissionManager._get(job_2.submit_id).submission_status == SubmissionStatus.RUNNING                  )                  assert_true_after_time(lambda: len(_OrchestratorFactory._dispatcher._dispatched_processes) == 2)                assert_true_after_time(lambda: task_2.output[f\"{task_2.config_id}_output0\"].read() == 42)              assert task_1.output[f\"{task_1.config_id}_output0\"].read() == 0              assert_true_after_time(job_0.is_running)              assert_true_after_time(job_1.is_running)              assert_true_after_time(job_2.is_completed)              assert_true_after_time(                  lambda: _SubmissionManager._get(job_0.submit_id).submission_status == SubmissionStatus.RUNNING              )              assert_true_after_time(                  lambda: _SubmissionManager._get(job_1.submit_id).submission_status == SubmissionStatus.RUNNING              )              assert_true_after_time(                  lambda: _SubmissionManager._get(job_2.submit_id).submission_status == SubmissionStatus.COMPLETED              )              assert_true_after_time(lambda: len(_OrchestratorFactory._dispatcher._dispatched_processes) == 2)            assert_true_after_time(lambda: task_1.output[f\"{task_1.config_id}_output0\"].read() == 42)          assert task_0.output[f\"{task_0.config_id}_output0\"].read() == 0          assert_true_after_time(job_0.is_running)          assert_true_after_time(job_1.is_completed)          assert_true_after_time(              lambda: _SubmissionManager._get(job_0.submit_id).submission_status == SubmissionStatus.RUNNING          )          assert_true_after_time(              lambda: _SubmissionManager._get(job_1.submit_id).submission_status == SubmissionStatus.COMPLETED          )            assert job_2.is_completed()          assert _SubmissionManager._get(job_2.submit_id).submission_status == SubmissionStatus.COMPLETED          assert_true_after_time(lambda: len(_OrchestratorFactory._dispatcher._dispatched_processes) == 1)        assert_true_after_time(lambda: len(_OrchestratorFactory._dispatcher._dispatched_processes) == 0)      assert task_0.output[f\"{task_0.config_id}_output0\"].read() == 42      assert job_0.is_completed()      assert job_1.is_completed()      assert job_2.is_completed()      assert _SubmissionManager._get(job_0.submit_id).submission_status == SubmissionStatus.COMPLETED      assert _SubmissionManager._get(job_1.submit_id).submission_status == SubmissionStatus.COMPLETED      assert _SubmissionManager._get(job_2.submit_id).submission_status == SubmissionStatus.COMPLETED      def test_blocked_task():      Config.configure_job_executions(mode=JobConfig._STANDALONE_MODE, max_nb_of_workers=2)        m = multiprocessing.Manager()      lock_1 = m.Lock()      lock_2 = m.Lock()        foo_cfg = Config.configure_data_node(\"foo\", default_data=1)      bar_cfg = Config.configure_data_node(\"bar\")      baz_cfg = Config.configure_data_node(\"baz\")        _OrchestratorFactory._build_dispatcher()        dns = _DataManager._bulk_get_or_create([foo_cfg, bar_cfg, baz_cfg])      foo = dns[foo_cfg]      bar = dns[bar_cfg]      baz = dns[baz_cfg]      task_1 = Task(\"by_2\", {}, partial(lock_multiply, lock_1, 2), [foo], [bar])      task_2 = Task(\"by_3\", {}, partial(lock_multiply, lock_2, 3), [bar], [baz])        assert task_1.foo.is_ready_for_reading  # foo is ready      assert not task_1.bar.is_ready_for_reading  # But bar is not ready      assert not task_2.baz.is_ready_for_reading  # neither does baz        assert len(_Orchestrator.blocked_jobs) == 0      job_2 = _Orchestrator.submit_task(task_2)  # job 2 is submitted first      assert job_2.is_blocked()  # since bar is not is_valid the job 2 is blocked      assert_true_after_time(lambda: len(_OrchestratorFactory._dispatcher._dispatched_processes) == 0)      assert _SubmissionManager._get(job_2.submit_id).submission_status == SubmissionStatus.BLOCKED      assert len(_Orchestrator.blocked_jobs) == 1      with lock_2:          with lock_1:              job_1 = _Orchestrator.submit_task(                  task_1,              )  # job 1 is submitted and locked              assert_true_after_time(job_1.is_running)  # so it is still running              assert_true_after_time(lambda: len(_OrchestratorFactory._dispatcher._dispatched_processes) == 1)              assert not _DataManager._get(task_1.bar.id).is_ready_for_reading  # And bar still not ready              assert_true_after_time(job_2.is_blocked)  # the job_2 remains blocked              assert_true_after_time(                  lambda: _SubmissionManager._get(job_1.submit_id).submission_status == SubmissionStatus.RUNNING              )              assert_true_after_time(                  lambda: _SubmissionManager._get(job_2.submit_id).submission_status == SubmissionStatus.BLOCKED              )          assert_true_after_time(job_1.is_completed)  # job1 unlocked and can complete          assert _DataManager._get(task_1.bar.id).is_ready_for_reading  # bar becomes ready          assert _DataManager._get(task_1.bar.id).read() == 2  # the data is computed and written          assert_true_after_time(job_2.is_running)  # And job 2 can start running          assert_true_after_time(lambda: len(_OrchestratorFactory._dispatcher._dispatched_processes) == 1)          assert len(_Orchestrator.blocked_jobs) == 0          assert_true_after_time(              lambda: _SubmissionManager._get(job_1.submit_id).submission_status == SubmissionStatus.COMPLETED          )          assert_true_after_time(              lambda: _SubmissionManager._get(job_2.submit_id).submission_status == SubmissionStatus.RUNNING          )      assert_true_after_time(job_2.is_completed)  # job 2 unlocked so it can complete      assert _DataManager._get(task_2.baz.id).is_ready_for_reading  # baz becomes ready      assert _DataManager._get(task_2.baz.id).read() == 6  # the data is computed and written      assert_true_after_time(lambda: len(_OrchestratorFactory._dispatcher._dispatched_processes) == 0)      assert _SubmissionManager._get(job_1.submit_id).submission_status == SubmissionStatus.COMPLETED      assert_true_after_time(          lambda: _SubmissionManager._get(job_2.submit_id).submission_status == SubmissionStatus.COMPLETED      )      def test_blocked_sequence():      Config.configure_job_executions(mode=JobConfig._STANDALONE_MODE, max_nb_of_workers=2)        m = multiprocessing.Manager()      lock_1 = m.Lock()      lock_2 = m.Lock()        foo_cfg = Config.configure_data_node(\"foo\", default_data=1)      bar_cfg = Config.configure_data_node(\"bar\")      baz_cfg = Config.configure_data_node(\"baz\")        _OrchestratorFactory._build_dispatcher()        dns = _DataManager._bulk_get_or_create([foo_cfg, bar_cfg, baz_cfg])      foo = dns[foo_cfg]      bar = dns[bar_cfg]      baz = dns[baz_cfg]      task_1 = Task(\"by_2\", {}, partial(lock_multiply, lock_1, 2), [foo], [bar])      task_2 = Task(\"by_3\", {}, partial(lock_multiply, lock_2, 3), [bar], [baz])      sequence = Sequence({}, [task_1, task_2], \"sequence_id\")        assert task_1.foo.is_ready_for_reading  # foo is ready      assert not task_1.bar.is_ready_for_reading  # But bar is not ready      assert not task_2.baz.is_ready_for_reading  # neither does baz        assert len(_Orchestrator.blocked_jobs) == 0      with lock_2:          with lock_1:              jobs = _Orchestrator.submit(sequence)  # sequence is submitted              tasks_jobs = {job._task.id: job for job in jobs}              job_1, job_2 = tasks_jobs[task_1.id], tasks_jobs[task_2.id]              assert_true_after_time(job_1.is_running)  # job 1 is submitted and locked so it is still running              assert_true_after_time(lambda: len(_OrchestratorFactory._dispatcher._dispatched_processes) == 1)              assert not _DataManager._get(task_1.bar.id).is_ready_for_reading  # And bar still not ready              assert_true_after_time(job_2.is_blocked)  # the job_2 remains blocked              assert_true_after_time(                  lambda: _SubmissionManager._get(job_1.submit_id).submission_status == SubmissionStatus.RUNNING              )          assert_true_after_time(job_1.is_completed)  # job1 unlocked and can complete          assert _DataManager._get(task_1.bar.id).is_ready_for_reading  # bar becomes ready          assert _DataManager._get(task_1.bar.id).read() == 2  # the data is computed and written          assert_true_after_time(job_2.is_running)  # And job 2 can start running          assert_true_after_time(lambda: len(_OrchestratorFactory._dispatcher._dispatched_processes) == 1)          assert len(_Orchestrator.blocked_jobs) == 0          assert_true_after_time(              lambda: _SubmissionManager._get(job_1.submit_id).submission_status == SubmissionStatus.RUNNING          )      assert_true_after_time(job_2.is_completed)  # job 2 unlocked so it can complete      assert _DataManager._get(task_2.baz.id).is_ready_for_reading  # baz becomes ready      assert _DataManager._get(task_2.baz.id).read() == 6  # the data is computed and written      assert_true_after_time(lambda: len(_OrchestratorFactory._dispatcher._dispatched_processes) == 0)      assert_true_after_time(          lambda: _SubmissionManager._get(job_1.submit_id).submission_status == SubmissionStatus.COMPLETED      )      def test_blocked_scenario():      Config.configure_job_executions(mode=JobConfig._STANDALONE_MODE, max_nb_of_workers=2)        m = multiprocessing.Manager()      lock_1 = m.Lock()      lock_2 = m.Lock()        foo_cfg = Config.configure_data_node(\"foo\", default_data=1)      bar_cfg = Config.configure_data_node(\"bar\")      baz_cfg = Config.configure_data_node(\"baz\")        _OrchestratorFactory._build_dispatcher()        dns = _DataManager._bulk_get_or_create([foo_cfg, bar_cfg, baz_cfg])      foo = dns[foo_cfg]      bar = dns[bar_cfg]      baz = dns[baz_cfg]      task_1 = Task(\"by_2\", {}, partial(lock_multiply, lock_1, 2), [foo], [bar])      task_2 = Task(\"by_3\", {}, partial(lock_multiply, lock_2, 3), [bar], [baz])      scenario = Scenario(\"scenario_config\", [task_1, task_2], {})        assert task_1.foo.is_ready_for_reading  # foo is ready      assert not task_1.bar.is_ready_for_reading  # But bar is not ready      assert not task_2.baz.is_ready_for_reading  # neither does baz        assert len(_Orchestrator.blocked_jobs) == 0      with lock_2:          with lock_1:              jobs = _Orchestrator.submit(scenario)  # scenario is submitted              tasks_jobs = {job._task.id: job for job in jobs}              job_1, job_2 = tasks_jobs[task_1.id], tasks_jobs[task_2.id]              assert_true_after_time(job_1.is_running)  # job 1 is submitted and locked so it is still running              assert_true_after_time(lambda: len(_OrchestratorFactory._dispatcher._dispatched_processes) == 1)              assert not _DataManager._get(task_1.bar.id).is_ready_for_reading  # And bar still not ready              assert_true_after_time(job_2.is_blocked)  # the job_2 remains blocked              assert_true_after_time(                  lambda: _SubmissionManager._get(job_1.submit_id).submission_status == SubmissionStatus.RUNNING              )          assert_true_after_time(job_1.is_completed)  # job1 unlocked and can complete          assert _DataManager._get(task_1.bar.id).is_ready_for_reading  # bar becomes ready          assert _DataManager._get(task_1.bar.id).read() == 2  # the data is computed and written          assert_true_after_time(job_2.is_running)  # And job 2 can start running          assert_true_after_time(lambda: len(_OrchestratorFactory._dispatcher._dispatched_processes) == 1)          assert len(_Orchestrator.blocked_jobs) == 0          assert_true_after_time(              lambda: _SubmissionManager._get(job_1.submit_id).submission_status == SubmissionStatus.RUNNING          )      assert_true_after_time(job_2.is_completed)  # job 2 unlocked so it can complete      assert _DataManager._get(task_2.baz.id).is_ready_for_reading  # baz becomes ready      assert _DataManager._get(task_2.baz.id).read() == 6  # the data is computed and written      assert_true_after_time(lambda: len(_OrchestratorFactory._dispatcher._dispatched_processes) == 0)      assert_true_after_time(          lambda: _SubmissionManager._get(job_1.submit_id).submission_status == SubmissionStatus.COMPLETED      )      def test_task_orchestrator_create_synchronous_dispatcher():      Config.configure_job_executions(mode=JobConfig._DEVELOPMENT_MODE)      _OrchestratorFactory._build_dispatcher()        assert _OrchestratorFactory._dispatcher._nb_available_workers == 1      def test_task_orchestrator_create_standalone_dispatcher():      Config.configure_job_executions(mode=JobConfig._STANDALONE_MODE, max_nb_of_workers=3)      _OrchestratorFactory._build_dispatcher()      assert isinstance(_OrchestratorFactory._dispatcher._executor, ProcessPoolExecutor)      assert _OrchestratorFactory._dispatcher._nb_available_workers == 3      def modified_config_task(n):      from taipy.config import Config        assert_true_after_time(lambda: Config.core.storage_folder == \".my_data/\")      assert_true_after_time(lambda: Config.core.custom_property == \"custom_property\")      return n * 2      def test_can_exec_task_with_modified_config():      Config.configure_job_executions(mode=JobConfig._STANDALONE_MODE, max_nb_of_workers=2)      Config.configure_core(storage_folder=\".my_data/\", custom_property=\"custom_property\")        dn_input_config = Config.configure_data_node(\"input\", \"pickle\", scope=Scope.SCENARIO, default_data=1)      dn_output_config = Config.configure_data_node(\"output\", \"pickle\")      task_config = Config.configure_task(\"task_config\", modified_config_task, dn_input_config, dn_output_config)      scenario_config = Config.configure_scenario(\"scenario_config\", [task_config])        _OrchestratorFactory._build_dispatcher()        scenario = _ScenarioManager._create(scenario_config)        jobs = scenario.submit()      assert_true_after_time(jobs[0].is_finished, time=120)      assert_true_after_time(          jobs[0].is_completed      )  # If the job is completed, that means the asserts in the task are successful      assert_true_after_time(          lambda: _SubmissionManager._get(jobs[0].submit_id).submission_status == SubmissionStatus.COMPLETED      )      def update_config_task(n):      from taipy.config import Config        # The exception will be saved to logger, and there is no way to check for it,      # so it will be checked here      with pytest.raises(ConfigurationUpdateBlocked):          Config.core.storage_folder = \".new_storage_folder/\"      with pytest.raises(ConfigurationUpdateBlocked):          Config.core.properties = {\"custom_property\": \"new_custom_property\"}        Config.core.storage_folder = \".new_storage_folder/\"      Config.core.properties = {\"custom_property\": \"new_custom_property\"}        return n * 2      def test_cannot_exec_task_that_update_config():      \"\"\"      _ConfigBlocker singleton is not passed to the subprocesses. That means in each subprocess,      the config update will not be blocked.        After rebuilding a new Config in each subprocess, the Config should be blocked.      \"\"\"      Config.configure_job_executions(mode=JobConfig._STANDALONE_MODE, max_nb_of_workers=2)        dn_input_config = Config.configure_data_node(\"input\", \"pickle\", scope=Scope.SCENARIO, default_data=1)      dn_output_config = Config.configure_data_node(\"output\", \"pickle\")      task_config = Config.configure_task(\"task_config\", update_config_task, dn_input_config, dn_output_config)      scenario_config = Config.configure_scenario(\"scenario_config\", [task_config])        _OrchestratorFactory._build_dispatcher()        scenario = _ScenarioManager._create(scenario_config)        jobs = scenario.submit()        # The job should fail due to an exception is raised      assert_true_after_time(jobs[0].is_failed)      assert_true_after_time(          lambda: _SubmissionManager._get(jobs[0].submit_id).submission_status == SubmissionStatus.FAILED      )      def test_can_execute_task_with_development_mode():      Config.configure_job_executions(mode=JobConfig._DEVELOPMENT_MODE)        dn_input_config = Config.configure_data_node(\"input\", \"pickle\", scope=Scope.SCENARIO, default_data=1)      dn_output_config = Config.configure_data_node(\"output\", \"pickle\")      task_config = Config.configure_task(\"task_config\", mult_by_2, dn_input_config, dn_output_config)      scenario_config = Config.configure_scenario(\"scenario_config\", [task_config])        _OrchestratorFactory._build_dispatcher()        scenario = _ScenarioManager._create(scenario_config)      scenario.submit()      while scenario.output.edit_in_progress:          sleep(1)      assert 2 == scenario.output.read()      def test_need_to_run_no_output():      hello_cfg = Config.configure_data_node(\"hello\", default_data=\"Hello \")      world_cfg = Config.configure_data_node(\"world\", default_data=\"world !\")      task_cfg = Config.configure_task(\"name\", input=[hello_cfg, world_cfg], function=concat, output=[])      task = _create_task_from_config(task_cfg)        assert _OrchestratorFactory._dispatcher._needs_to_run(task)      def test_need_to_run_task_not_skippable():      hello_cfg = Config.configure_data_node(\"hello\", default_data=\"Hello \")      world_cfg = Config.configure_data_node(\"world\", default_data=\"world !\")      hello_world_cfg = Config.configure_data_node(\"hello_world\")      task_cfg = Config.configure_task(          \"name\", input=[hello_cfg, world_cfg], function=concat, output=[hello_world_cfg], skippable=False      )      task = _create_task_from_config(task_cfg)        assert _OrchestratorFactory._dispatcher._needs_to_run(task)      def test_need_to_run_skippable_task_no_input():      Config.configure_job_executions(mode=JobConfig._DEVELOPMENT_MODE)        hello_world_cfg = Config.configure_data_node(\"hello_world\")      task_cfg = Config.configure_task(\"name\", input=[], function=nothing, output=[hello_world_cfg], skippable=True)        _OrchestratorFactory._build_dispatcher()        task = _create_task_from_config(task_cfg)      assert _OrchestratorFactory._dispatcher._needs_to_run(task)      _Orchestrator.submit_task(task)        assert not _OrchestratorFactory._dispatcher._needs_to_run(task)      def test_need_to_run_skippable_task_no_validity_period_on_output():      Config.configure_job_executions(mode=JobConfig._DEVELOPMENT_MODE)        hello_cfg = Config.configure_data_node(\"hello\", default_data=\"Hello \")      world_cfg = Config.configure_data_node(\"world\", default_data=\"world !\")      hello_world_cfg = Config.configure_data_node(\"hello_world\")      task_cfg = Config.configure_task(          \"name\", input=[hello_cfg, world_cfg], function=concat, output=[hello_world_cfg], skippable=True      )        _OrchestratorFactory._build_dispatcher()        task = _create_task_from_config(task_cfg)      assert _OrchestratorFactory._dispatcher._needs_to_run(task)      _Orchestrator.submit_task(task)        assert not _OrchestratorFactory._dispatcher._needs_to_run(task)      def test_need_to_run_skippable_task_with_validity_period_is_valid_on_output():      Config.configure_job_executions(mode=JobConfig._DEVELOPMENT_MODE)        hello_cfg = Config.configure_data_node(\"hello\", default_data=\"Hello \")      world_cfg = Config.configure_data_node(\"world\", default_data=\"world !\")      hello_world_cfg = Config.configure_data_node(\"hello_world\", validity_days=1)      task_cfg = Config.configure_task(          \"name\", input=[hello_cfg, world_cfg], function=concat, output=[hello_world_cfg], skippable=True      )      _OrchestratorFactory._build_dispatcher()        task = _create_task_from_config(task_cfg)        assert _OrchestratorFactory._dispatcher._needs_to_run(task)      job = _Orchestrator.submit_task(task)        assert not _OrchestratorFactory._dispatcher._needs_to_run(task)      job_skipped = _Orchestrator.submit_task(task)        assert job.is_completed()      assert job.is_finished()      assert job_skipped.is_skipped()      assert job_skipped.is_finished()      def test_need_to_run_skippable_task_with_validity_period_obsolete_on_output():      hello_cfg = Config.configure_data_node(\"hello\", default_data=\"Hello \")      world_cfg = Config.configure_data_node(\"world\", default_data=\"world !\")      hello_world_cfg = Config.configure_data_node(\"hello_world\", validity_days=1)      task_cfg = Config.configure_task(          \"name\", input=[hello_cfg, world_cfg], function=concat, output=[hello_world_cfg], skippable=True      )      task = _create_task_from_config(task_cfg)        assert _OrchestratorFactory._dispatcher._needs_to_run(task)      _Orchestrator.submit_task(task)        output = task.hello_world      output._last_edit_date = datetime.now() - timedelta(days=1, minutes=30)      _DataManager()._set(output)      assert _OrchestratorFactory._dispatcher._needs_to_run(task)      # ################################  UTIL METHODS    ##################################      def _create_task(function, nb_outputs=1):      output_dn_config_id = \"\".join(random.choice(string.ascii_lowercase) for _ in range(10))      dn_input_configs = [          Config.configure_data_node(\"input1\", \"pickle\", Scope.SCENARIO, default_data=21),          Config.configure_data_node(\"input2\", \"pickle\", Scope.SCENARIO, default_data=2),      ]      dn_output_configs = [          Config.configure_data_node(f\"{output_dn_config_id}_output{i}\", \"pickle\", Scope.SCENARIO, default_data=0)          for i in range(nb_outputs)      ]      input_dn = _DataManager._bulk_get_or_create(dn_input_configs).values()      output_dn = _DataManager._bulk_get_or_create(dn_output_configs).values()      return Task(          output_dn_config_id,          {},          function=function,          input=input_dn,          output=output_dn,      )      def _create_task_from_config(task_cfg):      return _TaskManager()._bulk_get_or_create([task_cfg])[0] "}
{"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": "from unittest import mock    import pytest    from src.taipy.core.config.data_node_config import DataNodeConfig  from src.taipy.core.data._data_manager import _DataManager  from src.taipy.core.data.csv import CSVDataNode  from src.taipy.core.data.data_node import DataNode  from src.taipy.core.data.in_memory import InMemoryDataNode  from src.taipy.core.task._task_manager import _TaskManager  from src.taipy.core.task.task import Task  from taipy.config.common.scope import Scope  from taipy.config.config import Config  from taipy.config.exceptions.exceptions import InvalidConfigurationId      @pytest.fixture  def output():      return [DataNode(\"name_1\"), DataNode(\"name_2\"), DataNode(\"name_3\")]      @pytest.fixture  def output_config():      return [DataNodeConfig(\"name_1\"), DataNodeConfig(\"name_2\"), DataNodeConfig(\"name_3\")]      @pytest.fixture  def input():      return [DataNode(\"input_name_1\"), DataNode(\"input_name_2\"), DataNode(\"input_name_3\")]      @pytest.fixture  def input_config():      return [DataNodeConfig(\"input_name_1\"), DataNodeConfig(\"input_name_2\"), DataNodeConfig(\"input_name_3\")]      def test_create_task():      name = \"name_1\"      task = Task(name, {}, print, [], [])      assert f\"TASK_{name}_\" in task.id      assert task.config_id == \"name_1\"        with pytest.raises(InvalidConfigurationId):          Task(\"foo bar\", {}, print, [], [])        path = \"my/csv/path\"      foo_dn = CSVDataNode(\"foo\", Scope.SCENARIO, properties={\"path\": path, \"has_header\": True})      task = Task(\"name_1\", {}, print, [foo_dn], [])      assert task.config_id == \"name_1\"      assert task.id is not None      assert task.owner_id is None      assert task.parent_ids == set()      assert task.foo == foo_dn      assert task.foo.path == path      with pytest.raises(AttributeError):          task.bar        task = Task(\"name_1\", {}, print, [foo_dn], [], parent_ids={\"parent_id\"})      assert task.parent_ids == {\"parent_id\"}        path = \"my/csv/path\"      abc_dn = InMemoryDataNode(\"name_1ea\", Scope.SCENARIO, properties={\"path\": path})        task = Task(\"name_1ea\", {}, print, [abc_dn], [], owner_id=\"owner_id\", parent_ids={\"parent_id_1\", \"parent_id_2\"})      assert task.config_id == \"name_1ea\"      assert task.id is not None      assert task.owner_id == \"owner_id\"      assert task.parent_ids == {\"parent_id_1\", \"parent_id_2\"}      assert task.name_1ea == abc_dn      assert task.name_1ea.path == path      with pytest.raises(AttributeError):          task.bar      with mock.patch(\"src.taipy.core.get\") as get_mck:            class MockOwner:              label = \"owner_label\"                def get_label(self):                  return self.label            get_mck.return_value = MockOwner()          assert task.get_label() == \"owner_label > \" + task.config_id          assert task.get_simple_label() == task.config_id      def test_can_not_change_task_output(output):      task = Task(\"name_1\", {}, print, output=output)        with pytest.raises(Exception):          task.output = {}        assert list(task.output.values()) == output      output.append(output[0])      assert list(task.output.values()) != output      def test_can_not_change_task_input(input):      task = Task(\"name_1\", {}, print, input=input)        with pytest.raises(Exception):          task.input = {}        assert list(task.input.values()) == input      input.append(input[0])      assert list(task.input.values()) != input      def test_can_not_change_task_config_output(output_config):      task_config = Config.configure_task(\"name_1\", print, [], output=output_config)        assert task_config.output_configs == output_config      with pytest.raises(Exception):          task_config.output_configs = []        output_config.append(output_config[0])      assert task_config._output != output_config      def test_can_not_update_task_output_values(output_config):      data_node_cfg = Config.configure_data_node(\"data_node_cfg\")      task_config = Config.configure_task(\"name_1\", print, [], output=output_config)        task_config.output_configs.append(data_node_cfg)      assert task_config.output_configs == output_config        task_config.output_configs[0] = data_node_cfg      assert task_config.output_configs[0] != data_node_cfg      def test_can_not_update_task_input_values(input_config):      data_node_config = DataNodeConfig(\"data_node\")      task_config = Config.configure_task(\"name_1\", print, input=input_config, output=[])        task_config.input_configs.append(data_node_config)      assert task_config.input_configs == input_config        task_config.input_configs[0] = data_node_config      assert task_config.input_configs[0] != data_node_config      def mock_func():      pass      def test_auto_set_and_reload(data_node):      task_1 = Task(          config_id=\"foo\", properties={}, function=print, input=None, output=None, owner_id=None, skippable=False      )        _DataManager._set(data_node)      _TaskManager._set(task_1)        task_2 = _TaskManager._get(task_1)        # auto set & reload on function attribute      assert task_1.function == print      assert task_2.function == print      task_1.function = sum      assert task_1.function == sum      assert task_2.function == sum      task_2.function = mock_func      assert task_1.function == mock_func      assert task_2.function == mock_func        # auto set & reload on skippable attribute      assert not task_1.skippable      assert not task_2.skippable      task_1.skippable = True      assert task_1.skippable      assert task_2.skippable      task_2.skippable = False      assert not task_1.skippable      assert not task_2.skippable        # auto set & reload on parent_ids attribute (set() object does not have auto set yet)      assert task_1.parent_ids == set()      assert task_2.parent_ids == set()      task_1._parent_ids.update([\"sc2\"])      _TaskManager._set(task_1)      assert task_1.parent_ids == {\"sc2\"}      assert task_2.parent_ids == {\"sc2\"}      task_2._parent_ids.clear()      task_2._parent_ids.update([\"sc1\"])      _TaskManager._set(task_2)      assert task_1.parent_ids == {\"sc1\"}      assert task_2.parent_ids == {\"sc1\"}        # auto set & reload on properties attribute      assert task_1.properties == {}      assert task_2.properties == {}      task_1._properties[\"qux\"] = 4      assert task_1.properties[\"qux\"] == 4      assert task_2.properties[\"qux\"] == 4        assert task_1.properties == {\"qux\": 4}      assert task_2.properties == {\"qux\": 4}      task_2._properties[\"qux\"] = 5      assert task_1.properties[\"qux\"] == 5      assert task_2.properties[\"qux\"] == 5        task_1.properties[\"temp_key_1\"] = \"temp_value_1\"      task_1.properties[\"temp_key_2\"] = \"temp_value_2\"      assert task_1.properties == {          \"qux\": 5,          \"temp_key_1\": \"temp_value_1\",          \"temp_key_2\": \"temp_value_2\",      }      assert task_2.properties == {          \"qux\": 5,          \"temp_key_1\": \"temp_value_1\",          \"temp_key_2\": \"temp_value_2\",      }      task_1.properties.pop(\"temp_key_1\")      assert \"temp_key_1\" not in task_1.properties.keys()      assert \"temp_key_1\" not in task_1.properties.keys()      assert task_1.properties == {          \"qux\": 5,          \"temp_key_2\": \"temp_value_2\",      }      assert task_2.properties == {          \"qux\": 5,          \"temp_key_2\": \"temp_value_2\",      }      task_2.properties.pop(\"temp_key_2\")      assert task_1.properties == {\"qux\": 5}      assert task_2.properties == {\"qux\": 5}      assert \"temp_key_2\" not in task_1.properties.keys()      assert \"temp_key_2\" not in task_2.properties.keys()        task_1.properties[\"temp_key_3\"] = 0      assert task_1.properties == {\"qux\": 5, \"temp_key_3\": 0}      assert task_2.properties == {\"qux\": 5, \"temp_key_3\": 0}      task_1.properties.update({\"temp_key_3\": 1})      assert task_1.properties == {\"qux\": 5, \"temp_key_3\": 1}      assert task_2.properties == {\"qux\": 5, \"temp_key_3\": 1}      task_1.properties.update(dict())      assert task_1.properties == {\"qux\": 5, \"temp_key_3\": 1}      assert task_2.properties == {\"qux\": 5, \"temp_key_3\": 1}      task_1.properties[\"temp_key_4\"] = 0      task_1.properties[\"temp_key_5\"] = 0        with task_1 as task:          assert task.config_id == \"foo\"          assert task.owner_id is None          assert task.function == mock_func          assert not task.skippable          assert task._is_in_context          assert task.properties[\"qux\"] == 5          assert task.properties[\"temp_key_3\"] == 1          assert task.properties[\"temp_key_4\"] == 0          assert task.properties[\"temp_key_5\"] == 0            task.function = print          task.skippable = True          task.properties[\"qux\"] = 9          task.properties.pop(\"temp_key_3\")          task.properties.pop(\"temp_key_4\")          task.properties.update({\"temp_key_4\": 1})          task.properties.update({\"temp_key_5\": 2})          task.properties.pop(\"temp_key_5\")          task.properties.update(dict())            assert task.config_id == \"foo\"          assert task.owner_id is None          assert task.function == mock_func          assert not task.skippable          assert task._is_in_context          assert task.properties[\"qux\"] == 5          assert task.properties[\"temp_key_3\"] == 1          assert task.properties[\"temp_key_4\"] == 0          assert task.properties[\"temp_key_5\"] == 0        assert task_1.config_id == \"foo\"      assert task_1.owner_id is None      assert task_1.function == print      assert task.skippable      assert not task_1._is_in_context      assert task_1.properties[\"qux\"] == 9      assert \"temp_key_3\" not in task_1.properties.keys()      assert task_1.properties[\"temp_key_4\"] == 1      assert \"temp_key_5\" not in task_1.properties.keys()      def test_get_parents(task):      with mock.patch(\"src.taipy.core.get_parents\") as mck:          task.get_parents()          mck.assert_called_once_with(task)      def test_submit_task(task: Task):      with mock.patch(\"src.taipy.core.task._task_manager._TaskManager._submit\") as mock_submit:          task.submit([], True)          mock_submit.assert_called_once_with(task, [], True, False, None) "}
{"text": "import os    import pytest    from src.taipy.core.data._data_sql_repository import _DataSQLRepository  from src.taipy.core.exceptions import ModelNotFound  from src.taipy.core.task._task_fs_repository import _TaskFSRepository  from src.taipy.core.task._task_sql_repository import _TaskSQLRepository  from src.taipy.core.task.task import Task, TaskId      class TestTaskFSRepository:      @pytest.mark.parametrize(\"repo\", [_TaskFSRepository, _TaskSQLRepository])      def test_save_and_load(self, data_node, repo, init_sql_repo):          repository = repo()          _DataSQLRepository()._save(data_node)          task = Task(\"task_config_id\", {}, print, [data_node], [data_node])            repository._save(task)            obj = repository._load(task.id)          assert isinstance(obj, Task)        @pytest.mark.parametrize(\"repo\", [_TaskFSRepository, _TaskSQLRepository])      def test_exists(self, data_node, repo, init_sql_repo):          repository = repo()          _DataSQLRepository()._save(data_node)          task = Task(\"task_config_id\", {}, print, [data_node], [data_node])            repository._save(task)            assert repository._exists(task.id)          assert not repository._exists(\"not-existed-task\")        @pytest.mark.parametrize(\"repo\", [_TaskFSRepository, _TaskSQLRepository])      def test_load_all(self, data_node, repo, init_sql_repo):          repository = repo()          _DataSQLRepository()._save(data_node)          task = Task(\"task_config_id\", {}, print, [data_node], [data_node])            for i in range(10):              task.id = TaskId(f\"task-{i}\")              repository._save(task)          data_nodes = repository._load_all()            assert len(data_nodes) == 10        @pytest.mark.parametrize(\"repo\", [_TaskFSRepository, _TaskSQLRepository])      def test_load_all_with_filters(self, data_node, repo, init_sql_repo):          repository = repo()          _DataSQLRepository()._save(data_node)          task = Task(\"task_config_id\", {}, print, [data_node], [data_node])            for i in range(10):              task.id = TaskId(f\"task-{i}\")              task.owner_id = f\"owner-{i}\"              repository._save(task)          objs = repository._load_all(filters=[{\"owner_id\": \"owner-2\"}])            assert len(objs) == 1        @pytest.mark.parametrize(\"repo\", [_TaskFSRepository, _TaskSQLRepository])      def test_delete(self, data_node, repo, init_sql_repo):          repository = repo()          _DataSQLRepository()._save(data_node)          task = Task(\"task_config_id\", {}, print, [data_node], [data_node])          repository._save(task)            repository._delete(task.id)            with pytest.raises(ModelNotFound):              repository._load(task.id)        @pytest.mark.parametrize(\"repo\", [_TaskFSRepository, _TaskSQLRepository])      def test_delete_all(self, data_node, repo, init_sql_repo):          repository = repo()          _DataSQLRepository()._save(data_node)          task = Task(\"task_config_id\", {}, print, [data_node], [data_node])            for i in range(10):              task.id = TaskId(f\"task-{i}\")              repository._save(task)            assert len(repository._load_all()) == 10            repository._delete_all()            assert len(repository._load_all()) == 0        @pytest.mark.parametrize(\"repo\", [_TaskFSRepository, _TaskSQLRepository])      def test_delete_many(self, data_node, repo, init_sql_repo):          repository = repo()          _DataSQLRepository()._save(data_node)          task = Task(\"task_config_id\", {}, print, [data_node], [data_node])            for i in range(10):              task.id = TaskId(f\"task-{i}\")              repository._save(task)            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\", [_TaskFSRepository, _TaskSQLRepository])      def test_delete_by(self, data_node, repo, init_sql_repo):          repository = repo()          _DataSQLRepository()._save(data_node)          task = Task(\"task_config_id\", {}, print, [data_node], [data_node])            # Create 5 entities with version 1.0 and 5 entities with version 2.0          for i in range(10):              task.id = TaskId(f\"task-{i}\")              task._version = f\"{(i+1) // 5}.0\"              repository._save(task)            objs = repository._load_all()          assert len(objs) == 10          repository._delete_by(\"version\", \"1.0\")            assert len(repository._load_all()) == 5        @pytest.mark.parametrize(\"repo\", [_TaskFSRepository, _TaskSQLRepository])      def test_search(self, data_node, repo, init_sql_repo):          repository = repo()          _DataSQLRepository()._save(data_node)          task = Task(\"task_config_id\", {}, print, [data_node], [data_node], version=\"random_version_number\")            for i in range(10):              task.id = TaskId(f\"task-{i}\")              task.owner_id = f\"owner-{i}\"              repository._save(task)            assert len(repository._load_all()) == 10            objs = repository._search(\"owner_id\", \"owner-2\")          assert len(objs) == 1          assert isinstance(objs[0], Task)            objs = repository._search(\"owner_id\", \"owner-2\", filters=[{\"version\": \"random_version_number\"}])          assert len(objs) == 1          assert isinstance(objs[0], Task)            assert repository._search(\"owner_id\", \"owner-2\", filters=[{\"version\": \"non_existed_version\"}]) == []        @pytest.mark.parametrize(\"repo\", [_TaskFSRepository, _TaskSQLRepository])      def test_export(self, tmpdir, data_node, repo, init_sql_repo):          repository = repo()          _DataSQLRepository()._save(data_node)          task = Task(\"task_config_id\", {}, print, [data_node], [data_node])          repository._save(task)            repository._export(task.id, tmpdir.strpath)          dir_path = repository.dir_path if repo == _TaskFSRepository else os.path.join(tmpdir.strpath, \"task\")            assert os.path.exists(os.path.join(dir_path, f\"{task.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 uuid  from unittest import mock    import pytest    from src.taipy.core import taipy  from src.taipy.core._orchestrator._orchestrator import _Orchestrator  from src.taipy.core._version._version_manager import _VersionManager  from src.taipy.core.data._data_manager import _DataManager  from src.taipy.core.data.in_memory import InMemoryDataNode  from src.taipy.core.exceptions.exceptions import ModelNotFound, NonExistingTask  from src.taipy.core.task._task_manager import _TaskManager  from src.taipy.core.task._task_manager_factory import _TaskManagerFactory  from src.taipy.core.task.task import Task  from src.taipy.core.task.task_id import TaskId  from taipy.config.common.scope import Scope  from taipy.config.config import Config      def test_create_and_save():      input_configs = [Config.configure_data_node(\"my_input\", \"in_memory\")]      output_configs = Config.configure_data_node(\"my_output\", \"in_memory\")      task_config = Config.configure_task(\"foo\", print, input_configs, output_configs)      task = _create_task_from_config(task_config)      assert task.id is not None      assert task.config_id == \"foo\"      assert len(task.input) == 1      assert len(_DataManager._get_all()) == 2      assert task.my_input.id is not None      assert task.my_input.config_id == \"my_input\"      assert task.my_output.id is not None      assert task.my_output.config_id == \"my_output\"      assert task.function == print      assert task.parent_ids == set()        task_retrieved_from_manager = _TaskManager._get(task.id)      assert task_retrieved_from_manager.id == task.id      assert task_retrieved_from_manager.config_id == task.config_id      assert len(task_retrieved_from_manager.input) == len(task.input)      assert task_retrieved_from_manager.my_input.id is not None      assert task_retrieved_from_manager.my_input.config_id == task.my_input.config_id      assert task_retrieved_from_manager.my_output.id is not None      assert task_retrieved_from_manager.my_output.config_id == task.my_output.config_id      assert task_retrieved_from_manager.function == task.function      assert task_retrieved_from_manager.parent_ids == set()      def test_do_not_recreate_existing_data_node():      input_config = Config.configure_data_node(\"my_input\", \"in_memory\", scope=Scope.SCENARIO)      output_config = Config.configure_data_node(\"my_output\", \"in_memory\", scope=Scope.SCENARIO)        _DataManager._create_and_set(input_config, \"scenario_id\", \"task_id\")      assert len(_DataManager._get_all()) == 1        task_config = Config.configure_task(\"foo\", print, input_config, output_config)      _create_task_from_config(task_config, scenario_id=\"scenario_id\")      assert len(_DataManager._get_all()) == 2      def test_assign_task_as_parent_of_datanode():      dn_config_1 = Config.configure_data_node(\"dn_1\", \"in_memory\", scope=Scope.SCENARIO)      dn_config_2 = Config.configure_data_node(\"dn_2\", \"in_memory\", scope=Scope.SCENARIO)      dn_config_3 = Config.configure_data_node(\"dn_3\", \"in_memory\", scope=Scope.SCENARIO)      task_config_1 = Config.configure_task(\"task_1\", print, dn_config_1, dn_config_2)      task_config_2 = Config.configure_task(\"task_2\", print, dn_config_2, dn_config_3)      tasks = _TaskManager._bulk_get_or_create([task_config_1, task_config_2], \"cycle_id\", \"scenario_id\")        assert len(_DataManager._get_all()) == 3      assert len(_TaskManager._get_all()) == 2      assert len(tasks) == 2        dns = {dn.config_id: dn for dn in _DataManager._get_all()}      assert dns[\"dn_1\"].parent_ids == {tasks[0].id}      assert dns[\"dn_2\"].parent_ids == set([tasks[0].id, tasks[1].id])      assert dns[\"dn_3\"].parent_ids == {tasks[1].id}      def test_do_not_recreate_existing_task():      input_config_scope_scenario = Config.configure_data_node(\"my_input_1\", \"in_memory\", Scope.SCENARIO)      output_config_scope_scenario = Config.configure_data_node(\"my_output_1\", \"in_memory\", Scope.SCENARIO)      task_config_1 = Config.configure_task(\"bar\", print, input_config_scope_scenario, output_config_scope_scenario)      # task_config_2 scope is Scenario        task_1 = _create_task_from_config(task_config_1)      assert len(_TaskManager._get_all()) == 1      task_2 = _create_task_from_config(task_config_1)  # Do not create. It already exists for None scenario      assert len(_TaskManager._get_all()) == 1      assert task_1.id == task_2.id      task_3 = _create_task_from_config(task_config_1, None, None)  # Do not create. It already exists for None scenario      assert len(_TaskManager._get_all()) == 1      assert task_1.id == task_2.id      assert task_2.id == task_3.id      task_4 = _create_task_from_config(task_config_1, None, \"scenario_1\")  # Create even if sequence is the same.      assert len(_TaskManager._get_all()) == 2      assert task_1.id == task_2.id      assert task_2.id == task_3.id      assert task_3.id != task_4.id      task_5 = _create_task_from_config(          task_config_1, None, \"scenario_1\"      )  # Do not create. It already exists for scenario_1      assert len(_TaskManager._get_all()) == 2      assert task_1.id == task_2.id      assert task_2.id == task_3.id      assert task_3.id != task_4.id      assert task_4.id == task_5.id      task_6 = _create_task_from_config(task_config_1, None, \"scenario_2\")      assert len(_TaskManager._get_all()) == 3      assert task_1.id == task_2.id      assert task_2.id == task_3.id      assert task_3.id != task_4.id      assert task_4.id == task_5.id      assert task_5.id != task_6.id      assert task_3.id != task_6.id        input_config_scope_cycle = Config.configure_data_node(\"my_input_2\", \"in_memory\", Scope.CYCLE)      output_config_scope_cycle = Config.configure_data_node(\"my_output_2\", \"in_memory\", Scope.CYCLE)      task_config_2 = Config.configure_task(\"xyz\", print, input_config_scope_cycle, output_config_scope_cycle)      # task_config_3 scope is Cycle        task_7 = _create_task_from_config(task_config_2)      assert len(_TaskManager._get_all()) == 4      task_8 = _create_task_from_config(task_config_2)  # Do not create. It already exists for None cycle      assert len(_TaskManager._get_all()) == 4      assert task_7.id == task_8.id      task_9 = _create_task_from_config(task_config_2, None, None)  # Do not create. It already exists for None cycle      assert len(_TaskManager._get_all()) == 4      assert task_7.id == task_8.id      assert task_8.id == task_9.id      task_10 = _create_task_from_config(          task_config_2, None, \"scenario\"      )  # Do not create. It already exists for None cycle      assert len(_TaskManager._get_all()) == 4      assert task_7.id == task_8.id      assert task_8.id == task_9.id      assert task_9.id == task_10.id      task_11 = _create_task_from_config(          task_config_2, None, \"scenario\"      )  # Do not create. It already exists for None cycle      assert len(_TaskManager._get_all()) == 4      assert task_7.id == task_8.id      assert task_8.id == task_9.id      assert task_9.id == task_10.id      assert task_10.id == task_11.id      task_12 = _create_task_from_config(task_config_2, \"cycle\", None)      assert len(_TaskManager._get_all()) == 5      assert task_7.id == task_8.id      assert task_8.id == task_9.id      assert task_9.id == task_10.id      assert task_10.id == task_11.id      assert task_11.id != task_12.id      task_13 = _create_task_from_config(task_config_2, \"cycle\", None)      assert len(_TaskManager._get_all()) == 5      assert task_7.id == task_8.id      assert task_8.id == task_9.id      assert task_9.id == task_10.id      assert task_10.id == task_11.id      assert task_11.id != task_12.id      assert task_12.id == task_13.id      def test_set_and_get_task():      task_id_1 = TaskId(\"id1\")      first_task = Task(\"name_1\", {}, print, [], [], task_id_1)      task_id_2 = TaskId(\"id2\")      second_task = Task(\"name_2\", {}, print, [], [], task_id_2)      third_task_with_same_id_as_first_task = Task(\"name_is_not_1_anymore\", {}, print, [], [], task_id_1)        # No task at initialization        assert len(_TaskManager._get_all()) == 0      assert _TaskManager._get(task_id_1) is None      assert _TaskManager._get(first_task) is None      assert _TaskManager._get(task_id_2) is None      assert _TaskManager._get(second_task) is None        # Save one task. We expect to have only one task stored      _TaskManager._set(first_task)      assert len(_TaskManager._get_all()) == 1      assert _TaskManager._get(task_id_1).id == first_task.id      assert _TaskManager._get(first_task).id == first_task.id      assert _TaskManager._get(task_id_2) is None      assert _TaskManager._get(second_task) is None        # Save a second task. Now, we expect to have a total of two tasks stored      _TaskManager._set(second_task)      assert len(_TaskManager._get_all()) == 2      assert _TaskManager._get(task_id_1).id == first_task.id      assert _TaskManager._get(first_task).id == first_task.id      assert _TaskManager._get(task_id_2).id == second_task.id      assert _TaskManager._get(second_task).id == second_task.id        # We save the first task again. We expect nothing to change      _TaskManager._set(first_task)      assert len(_TaskManager._get_all()) == 2      assert _TaskManager._get(task_id_1).id == first_task.id      assert _TaskManager._get(first_task).id == first_task.id      assert _TaskManager._get(task_id_2).id == second_task.id      assert _TaskManager._get(second_task).id == second_task.id        # We save a third task with same id as the first one.      # We expect the first task to be updated      _TaskManager._set(third_task_with_same_id_as_first_task)      assert len(_TaskManager._get_all()) == 2      assert _TaskManager._get(task_id_1).id == third_task_with_same_id_as_first_task.id      assert _TaskManager._get(task_id_1).config_id == third_task_with_same_id_as_first_task.config_id      assert _TaskManager._get(first_task).id == third_task_with_same_id_as_first_task.id      assert _TaskManager._get(task_id_2).id == second_task.id      assert _TaskManager._get(second_task).id == second_task.id      def test_get_all_on_multiple_versions_environment():      # Create 5 tasks with 2 versions each      # Only version 1.0 has the task with config_id = \"config_id_1\"      # Only version 2.0 has the task with config_id = \"config_id_6\"      for version in range(1, 3):          for i in range(5):              _TaskManager._set(                  Task(                      f\"config_id_{i+version}\", {}, print, [], [], id=TaskId(f\"id{i}_v{version}\"), version=f\"{version}.0\"                  )              )        _VersionManager._set_experiment_version(\"1.0\")      assert len(_TaskManager._get_all()) == 5      assert len(_TaskManager._get_all_by(filters=[{\"version\": \"1.0\", \"config_id\": \"config_id_1\"}])) == 1      assert len(_TaskManager._get_all_by(filters=[{\"version\": \"1.0\", \"config_id\": \"config_id_6\"}])) == 0        _VersionManager._set_experiment_version(\"2.0\")      assert len(_TaskManager._get_all()) == 5      assert len(_TaskManager._get_all_by(filters=[{\"version\": \"2.0\", \"config_id\": \"config_id_1\"}])) == 0      assert len(_TaskManager._get_all_by(filters=[{\"version\": \"2.0\", \"config_id\": \"config_id_6\"}])) == 1        _VersionManager._set_development_version(\"1.0\")      assert len(_TaskManager._get_all()) == 5      assert len(_TaskManager._get_all_by(filters=[{\"version\": \"1.0\", \"config_id\": \"config_id_1\"}])) == 1      assert len(_TaskManager._get_all_by(filters=[{\"version\": \"1.0\", \"config_id\": \"config_id_6\"}])) == 0        _VersionManager._set_development_version(\"2.0\")      assert len(_TaskManager._get_all()) == 5      assert len(_TaskManager._get_all_by(filters=[{\"version\": \"2.0\", \"config_id\": \"config_id_1\"}])) == 0      assert len(_TaskManager._get_all_by(filters=[{\"version\": \"2.0\", \"config_id\": \"config_id_6\"}])) == 1      def test_ensure_conservation_of_order_of_data_nodes_on_task_creation():      embedded_1 = Config.configure_data_node(\"dn_1\", \"in_memory\", scope=Scope.SCENARIO)      embedded_2 = Config.configure_data_node(\"dn_2\", \"in_memory\", scope=Scope.SCENARIO)      embedded_3 = Config.configure_data_node(\"a_dn_3\", \"in_memory\", scope=Scope.SCENARIO)      embedded_4 = Config.configure_data_node(\"dn_4\", \"in_memory\", scope=Scope.SCENARIO)      embedded_5 = Config.configure_data_node(\"dn_5\", \"in_memory\", scope=Scope.SCENARIO)        input = [embedded_1, embedded_2, embedded_3]      output = [embedded_4, embedded_5]        task_config_1 = Config.configure_task(\"name_1\", print, input, output)      task_config_2 = Config.configure_task(\"name_2\", print, input, output)        task_1, task_2 = _TaskManager._bulk_get_or_create([task_config_1, task_config_2])        assert [i.config_id for i in task_1.input.values()] == [embedded_1.id, embedded_2.id, embedded_3.id]      assert [o.config_id for o in task_1.output.values()] == [embedded_4.id, embedded_5.id]        assert [i.config_id for i in task_2.input.values()] == [embedded_1.id, embedded_2.id, embedded_3.id]      assert [o.config_id for o in task_2.output.values()] == [embedded_4.id, embedded_5.id]      def test_delete_raise_exception():      dn_input_config_1 = Config.configure_data_node(          \"my_input_1\", \"in_memory\", scope=Scope.SCENARIO, default_data=\"testing\"      )      dn_output_config_1 = Config.configure_data_node(\"my_output_1\", \"in_memory\")      task_config_1 = Config.configure_task(\"task_config_1\", print, dn_input_config_1, dn_output_config_1)      task_1 = _create_task_from_config(task_config_1)      _TaskManager._delete(task_1.id)        with pytest.raises(ModelNotFound):          _TaskManager._delete(task_1.id)      def test_hard_delete():      dn_input_config_1 = Config.configure_data_node(          \"my_input_1\", \"in_memory\", scope=Scope.SCENARIO, default_data=\"testing\"      )      dn_output_config_1 = Config.configure_data_node(\"my_output_1\", \"in_memory\")      task_config_1 = Config.configure_task(\"task_config_1\", print, dn_input_config_1, dn_output_config_1)      task_1 = _create_task_from_config(task_config_1)        assert len(_TaskManager._get_all()) == 1      assert len(_DataManager._get_all()) == 2      _TaskManager._hard_delete(task_1.id)      assert len(_TaskManager._get_all()) == 0      assert len(_DataManager._get_all()) == 2      def test_is_submittable():      assert len(_TaskManager._get_all()) == 0      dn_config = Config.configure_in_memory_data_node(\"dn\", 10)      task_config = Config.configure_task(\"task\", print, [dn_config])      task = _TaskManager._bulk_get_or_create([task_config])[0]        assert len(_TaskManager._get_all()) == 1      assert _TaskManager._is_submittable(task)      assert _TaskManager._is_submittable(task.id)      assert not _TaskManager._is_submittable(\"Task_temp\")        task.input[\"dn\"].edit_in_progress = True      assert not _TaskManager._is_submittable(task)      assert not _TaskManager._is_submittable(task.id)        task.input[\"dn\"].edit_in_progress = False      assert _TaskManager._is_submittable(task)      assert _TaskManager._is_submittable(task.id)      def test_submit_task():      data_node_1 = InMemoryDataNode(\"foo\", Scope.SCENARIO, \"s1\")      data_node_2 = InMemoryDataNode(\"bar\", Scope.SCENARIO, \"s2\")      task_1 = Task(          \"grault\",          {},          print,          [data_node_1],          [data_node_2],          TaskId(\"t1\"),      )        class MockOrchestrator(_Orchestrator):          submit_calls = []          submit_ids = []            def submit_task(self, task, callbacks=None, force=False, wait=False, timeout=None):              submit_id = f\"SUBMISSION_{str(uuid.uuid4())}\"              self.submit_calls.append(task)              self.submit_ids.append(submit_id)              return None        with mock.patch(\"src.taipy.core.task._task_manager._TaskManager._orchestrator\", new=MockOrchestrator):          # Task does not exist, we expect an exception          with pytest.raises(NonExistingTask):              _TaskManager._submit(task_1)          with pytest.raises(NonExistingTask):              _TaskManager._submit(task_1.id)            _TaskManager._set(task_1)          _TaskManager._submit(task_1)          call_ids = [call.id for call in MockOrchestrator.submit_calls]          assert call_ids == [task_1.id]          assert len(MockOrchestrator.submit_ids) == 1            _TaskManager._submit(task_1)          assert len(MockOrchestrator.submit_ids) == 2          assert len(MockOrchestrator.submit_ids) == len(set(MockOrchestrator.submit_ids))            _TaskManager._submit(task_1)          assert len(MockOrchestrator.submit_ids) == 3          assert len(MockOrchestrator.submit_ids) == len(set(MockOrchestrator.submit_ids))      def my_print(a, b):      print(a + b)      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\")      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\")      task_cfg = Config.configure_task(\"task\", my_print, [csv_dn_cfg, pickle_dn_cfg], parquet_dn_cfg)      task_manager = _TaskManagerFactory._build_manager()      tasks = task_manager._bulk_get_or_create([task_cfg])      task = tasks[0]      taipy.submit(task)        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 task.input.values()      ]      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 task.output.values()      ]      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_one_input_dn_wrong_file_path(caplog):      csv_dn_cfg = Config.configure_csv_data_node(\"wrong_csv_file_path\", default_path=\"wrong_path.csv\")      pickle_dn_cfg = Config.configure_pickle_data_node(\"pickle_file_path\", default_data=\"value\")      parquet_dn_cfg = Config.configure_parquet_data_node(\"wrong_parquet_file_path\", default_path=\"wrong_path.parquet\")      task_cfg = Config.configure_task(\"task\", my_print, [csv_dn_cfg, pickle_dn_cfg], parquet_dn_cfg)      task_manager = _TaskManagerFactory._build_manager()      tasks = task_manager._bulk_get_or_create([task_cfg])      task = tasks[0]      taipy.submit(task)        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 [task.input[\"wrong_csv_file_path\"]]      ]      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 [task.input[\"pickle_file_path\"], task.output[\"wrong_parquet_file_path\"]]      ]      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_get_tasks_by_config_id():      dn_config = Config.configure_data_node(\"dn\", scope=Scope.SCENARIO)      task_config_1 = Config.configure_task(\"t1\", print, dn_config)      task_config_2 = Config.configure_task(\"t2\", print, dn_config)      task_config_3 = Config.configure_task(\"t3\", print, dn_config)        t_1_1 = _TaskManager._bulk_get_or_create([task_config_1], scenario_id=\"scenario_1\")[0]      t_1_2 = _TaskManager._bulk_get_or_create([task_config_1], scenario_id=\"scenario_2\")[0]      t_1_3 = _TaskManager._bulk_get_or_create([task_config_1], scenario_id=\"scenario_3\")[0]      assert len(_TaskManager._get_all()) == 3        t_2_1 = _TaskManager._bulk_get_or_create([task_config_2], scenario_id=\"scenario_4\")[0]      t_2_2 = _TaskManager._bulk_get_or_create([task_config_2], scenario_id=\"scenario_5\")[0]      assert len(_TaskManager._get_all()) == 5        t_3_1 = _TaskManager._bulk_get_or_create([task_config_3], scenario_id=\"scenario_6\")[0]      assert len(_TaskManager._get_all()) == 6        t1_tasks = _TaskManager._get_by_config_id(task_config_1.id)      assert len(t1_tasks) == 3      assert sorted([t_1_1.id, t_1_2.id, t_1_3.id]) == sorted([task.id for task in t1_tasks])        t2_tasks = _TaskManager._get_by_config_id(task_config_2.id)      assert len(t2_tasks) == 2      assert sorted([t_2_1.id, t_2_2.id]) == sorted([task.id for task in t2_tasks])        t3_tasks = _TaskManager._get_by_config_id(task_config_3.id)      assert len(t3_tasks) == 1      assert sorted([t_3_1.id]) == sorted([task.id for task in t3_tasks])      def test_get_scenarios_by_config_id_in_multiple_versions_environment():      dn_config = Config.configure_data_node(\"dn\", scope=Scope.SCENARIO)      task_config_1 = Config.configure_task(\"t1\", print, dn_config)      task_config_2 = Config.configure_task(\"t2\", print, dn_config)        _VersionManager._set_experiment_version(\"1.0\")      _TaskManager._bulk_get_or_create([task_config_1], scenario_id=\"scenario_1\")[0]      _TaskManager._bulk_get_or_create([task_config_1], scenario_id=\"scenario_2\")[0]      _TaskManager._bulk_get_or_create([task_config_1], scenario_id=\"scenario_3\")[0]      _TaskManager._bulk_get_or_create([task_config_2], scenario_id=\"scenario_4\")[0]      _TaskManager._bulk_get_or_create([task_config_2], scenario_id=\"scenario_5\")[0]        assert len(_TaskManager._get_by_config_id(task_config_1.id)) == 3      assert len(_TaskManager._get_by_config_id(task_config_2.id)) == 2        _VersionManager._set_experiment_version(\"2.0\")      _TaskManager._bulk_get_or_create([task_config_1], scenario_id=\"scenario_1\")[0]      _TaskManager._bulk_get_or_create([task_config_1], scenario_id=\"scenario_2\")[0]      _TaskManager._bulk_get_or_create([task_config_1], scenario_id=\"scenario_3\")[0]      _TaskManager._bulk_get_or_create([task_config_2], scenario_id=\"scenario_4\")[0]      _TaskManager._bulk_get_or_create([task_config_2], scenario_id=\"scenario_5\")[0]        assert len(_TaskManager._get_by_config_id(task_config_1.id)) == 3      assert len(_TaskManager._get_by_config_id(task_config_2.id)) == 2      def _create_task_from_config(task_config, *args, **kwargs):      return _TaskManager._bulk_get_or_create([task_config], *args, **kwargs)[0] "}
{"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": "import uuid  from unittest import mock    import pytest    from src.taipy.core._orchestrator._orchestrator import _Orchestrator  from src.taipy.core._version._version_manager import _VersionManager  from src.taipy.core.data._data_manager import _DataManager  from src.taipy.core.data._data_manager_factory import _DataManagerFactory  from src.taipy.core.data.in_memory import InMemoryDataNode  from src.taipy.core.exceptions.exceptions import ModelNotFound, NonExistingTask  from src.taipy.core.job._job_manager_factory import _JobManagerFactory  from src.taipy.core.task._task_manager import _TaskManager  from src.taipy.core.task._task_manager_factory import _TaskManagerFactory  from src.taipy.core.task.task import Task  from src.taipy.core.task.task_id import TaskId  from taipy.config.common.scope import Scope  from taipy.config.config import Config      def init_managers():      _JobManagerFactory._build_manager()._delete_all()      _TaskManagerFactory._build_manager()._delete_all()      _DataManagerFactory._build_manager()._delete_all()      def test_create_and_save(init_sql_repo):      init_managers()        input_configs = [Config.configure_data_node(\"my_input\", \"in_memory\")]      output_configs = Config.configure_data_node(\"my_output\", \"in_memory\")      task_config = Config.configure_task(\"foo\", print, input_configs, output_configs)      task = _create_task_from_config(task_config)      assert task.id is not None      assert task.config_id == \"foo\"      assert len(task.input) == 1      assert len(_DataManager._get_all()) == 2      assert task.my_input.id is not None      assert task.my_input.config_id == \"my_input\"      assert task.my_output.id is not None      assert task.my_output.config_id == \"my_output\"      assert task.function == print      assert task.parent_ids == set()        task_retrieved_from_manager = _TaskManager._get(task.id)      assert task_retrieved_from_manager.id == task.id      assert task_retrieved_from_manager.config_id == task.config_id      assert len(task_retrieved_from_manager.input) == len(task.input)      assert task_retrieved_from_manager.my_input.id is not None      assert task_retrieved_from_manager.my_input.config_id == task.my_input.config_id      assert task_retrieved_from_manager.my_output.id is not None      assert task_retrieved_from_manager.my_output.config_id == task.my_output.config_id      assert task_retrieved_from_manager.function == task.function      assert task_retrieved_from_manager.parent_ids == set()      def test_do_not_recreate_existing_data_node(init_sql_repo):      init_managers()        input_config = Config.configure_data_node(\"my_input\", \"in_memory\", scope=Scope.SCENARIO)      output_config = Config.configure_data_node(\"my_output\", \"in_memory\", scope=Scope.SCENARIO)        _DataManager._create_and_set(input_config, \"scenario_id\", \"task_id\")      assert len(_DataManager._get_all()) == 1        task_config = Config.configure_task(\"foo\", print, input_config, output_config)      _create_task_from_config(task_config, scenario_id=\"scenario_id\")      assert len(_DataManager._get_all()) == 2      def test_do_not_recreate_existing_task(init_sql_repo):      init_managers()      assert len(_TaskManager._get_all()) == 0        input_config_scope_scenario = Config.configure_data_node(\"my_input_1\", \"in_memory\", Scope.SCENARIO)      output_config_scope_scenario = Config.configure_data_node(\"my_output_1\", \"in_memory\", Scope.SCENARIO)      task_config_1 = Config.configure_task(\"bar\", print, input_config_scope_scenario, output_config_scope_scenario)      # task_config_1 scope is Scenario        task_1 = _create_task_from_config(task_config_1)      assert len(_TaskManager._get_all()) == 1      task_2 = _create_task_from_config(task_config_1)  # Do not create. It already exists for None scenario      assert len(_TaskManager._get_all()) == 1      assert task_1.id == task_2.id      task_3 = _create_task_from_config(task_config_1, None, None)  # Do not create. It already exists for None scenario      assert len(_TaskManager._get_all()) == 1      assert task_1.id == task_2.id      assert task_2.id == task_3.id      task_4 = _create_task_from_config(task_config_1, None, \"scenario_1\")  # Create even if sequence is the same.      assert len(_TaskManager._get_all()) == 2      assert task_1.id == task_2.id      assert task_2.id == task_3.id      assert task_3.id != task_4.id      task_5 = _create_task_from_config(          task_config_1, None, \"scenario_1\"      )  # Do not create. It already exists for scenario_1      assert len(_TaskManager._get_all()) == 2      assert task_1.id == task_2.id      assert task_2.id == task_3.id      assert task_3.id != task_4.id      assert task_4.id == task_5.id      task_6 = _create_task_from_config(task_config_1, None, \"scenario_2\")      assert len(_TaskManager._get_all()) == 3      assert task_1.id == task_2.id      assert task_2.id == task_3.id      assert task_3.id != task_4.id      assert task_4.id == task_5.id      assert task_5.id != task_6.id      assert task_3.id != task_6.id        input_config_scope_cycle = Config.configure_data_node(\"my_input_2\", \"in_memory\", Scope.CYCLE)      output_config_scope_cycle = Config.configure_data_node(\"my_output_2\", \"in_memory\", Scope.CYCLE)      task_config_2 = Config.configure_task(\"xyz\", print, input_config_scope_cycle, output_config_scope_cycle)      # task_config_3 scope is Cycle        task_7 = _create_task_from_config(task_config_2)      assert len(_TaskManager._get_all()) == 4      task_8 = _create_task_from_config(task_config_2)  # Do not create. It already exists for None cycle      assert len(_TaskManager._get_all()) == 4      assert task_7.id == task_8.id      task_9 = _create_task_from_config(task_config_2, None, None)  # Do not create. It already exists for None cycle      assert len(_TaskManager._get_all()) == 4      assert task_7.id == task_8.id      assert task_8.id == task_9.id      task_10 = _create_task_from_config(          task_config_2, None, \"scenario\"      )  # Do not create. It already exists for None cycle      assert len(_TaskManager._get_all()) == 4      assert task_7.id == task_8.id      assert task_8.id == task_9.id      assert task_9.id == task_10.id      task_11 = _create_task_from_config(          task_config_2, None, \"scenario\"      )  # Do not create. It already exists for None cycle      assert len(_TaskManager._get_all()) == 4      assert task_7.id == task_8.id      assert task_8.id == task_9.id      assert task_9.id == task_10.id      assert task_10.id == task_11.id      task_12 = _create_task_from_config(task_config_2, \"cycle\", None)      assert len(_TaskManager._get_all()) == 5      assert task_7.id == task_8.id      assert task_8.id == task_9.id      assert task_9.id == task_10.id      assert task_10.id == task_11.id      assert task_11.id != task_12.id      task_13 = _create_task_from_config(task_config_2, \"cycle\", None)      assert len(_TaskManager._get_all()) == 5      assert task_7.id == task_8.id      assert task_8.id == task_9.id      assert task_9.id == task_10.id      assert task_10.id == task_11.id      assert task_11.id != task_12.id      assert task_12.id == task_13.id      def test_set_and_get_task(init_sql_repo):      init_managers()        task_id_1 = TaskId(\"id1\")      first_task = Task(\"name_1\", {}, print, [], [], task_id_1)      task_id_2 = TaskId(\"id2\")      second_task = Task(\"name_2\", {}, print, [], [], task_id_2)      third_task_with_same_id_as_first_task = Task(\"name_is_not_1_anymore\", {}, print, [], [], task_id_1)        # No task at initialization        assert len(_TaskManager._get_all()) == 0      assert _TaskManager._get(task_id_1) is None      assert _TaskManager._get(first_task) is None      assert _TaskManager._get(task_id_2) is None      assert _TaskManager._get(second_task) is None        # Save one task. We expect to have only one task stored      _TaskManager._set(first_task)      assert len(_TaskManager._get_all()) == 1      assert _TaskManager._get(task_id_1).id == first_task.id      assert _TaskManager._get(first_task).id == first_task.id      assert _TaskManager._get(task_id_2) is None      assert _TaskManager._get(second_task) is None        # Save a second task. Now, we expect to have a total of two tasks stored      _TaskManager._set(second_task)      assert len(_TaskManager._get_all()) == 2      assert _TaskManager._get(task_id_1).id == first_task.id      assert _TaskManager._get(first_task).id == first_task.id      assert _TaskManager._get(task_id_2).id == second_task.id      assert _TaskManager._get(second_task).id == second_task.id        # We save the first task again. We expect nothing to change      _TaskManager._set(first_task)      assert len(_TaskManager._get_all()) == 2      assert _TaskManager._get(task_id_1).id == first_task.id      assert _TaskManager._get(first_task).id == first_task.id      assert _TaskManager._get(task_id_2).id == second_task.id      assert _TaskManager._get(second_task).id == second_task.id        # We save a third task with same id as the first one.      # We expect the first task to be updated      _TaskManager._set(third_task_with_same_id_as_first_task)      assert len(_TaskManager._get_all()) == 2      assert _TaskManager._get(task_id_1).id == third_task_with_same_id_as_first_task.id      assert _TaskManager._get(task_id_1).config_id == third_task_with_same_id_as_first_task.config_id      assert _TaskManager._get(first_task).id == third_task_with_same_id_as_first_task.id      assert _TaskManager._get(task_id_2).id == second_task.id      assert _TaskManager._get(second_task).id == second_task.id      def test_get_all_on_multiple_versions_environment(init_sql_repo):      Config.configure_global_app(repository_type=\"sql\")      init_managers()        # Create 5 tasks with 2 versions each      # Only version 1.0 has the task with config_id = \"config_id_1\"      # Only version 2.0 has the task with config_id = \"config_id_6\"      for version in range(1, 3):          for i in range(5):              _TaskManager._set(                  Task(                      f\"config_id_{i+version}\", {}, print, [], [], id=TaskId(f\"id{i}_v{version}\"), version=f\"{version}.0\"                  )              )        _VersionManager._set_experiment_version(\"1.0\")      assert len(_TaskManager._get_all()) == 5      assert len(_TaskManager._get_all_by(filters=[{\"version\": \"1.0\", \"config_id\": \"config_id_1\"}])) == 1      assert len(_TaskManager._get_all_by(filters=[{\"version\": \"1.0\", \"config_id\": \"config_id_6\"}])) == 0        _VersionManager._set_experiment_version(\"2.0\")      assert len(_TaskManager._get_all()) == 5      assert len(_TaskManager._get_all_by(filters=[{\"version\": \"2.0\", \"config_id\": \"config_id_1\"}])) == 0      assert len(_TaskManager._get_all_by(filters=[{\"version\": \"2.0\", \"config_id\": \"config_id_6\"}])) == 1        _VersionManager._set_development_version(\"1.0\")      assert len(_TaskManager._get_all()) == 5      assert len(_TaskManager._get_all_by(filters=[{\"version\": \"1.0\", \"config_id\": \"config_id_1\"}])) == 1      assert len(_TaskManager._get_all_by(filters=[{\"version\": \"1.0\", \"config_id\": \"config_id_6\"}])) == 0        _VersionManager._set_development_version(\"2.0\")      assert len(_TaskManager._get_all()) == 5      assert len(_TaskManager._get_all_by(filters=[{\"version\": \"2.0\", \"config_id\": \"config_id_1\"}])) == 0      assert len(_TaskManager._get_all_by(filters=[{\"version\": \"2.0\", \"config_id\": \"config_id_6\"}])) == 1      def test_ensure_conservation_of_order_of_data_nodes_on_task_creation(init_sql_repo):      init_managers()        embedded_1 = Config.configure_data_node(\"dn_1\", \"in_memory\", scope=Scope.SCENARIO)      embedded_2 = Config.configure_data_node(\"dn_2\", \"in_memory\", scope=Scope.SCENARIO)      embedded_3 = Config.configure_data_node(\"a_dn_3\", \"in_memory\", scope=Scope.SCENARIO)      embedded_4 = Config.configure_data_node(\"dn_4\", \"in_memory\", scope=Scope.SCENARIO)      embedded_5 = Config.configure_data_node(\"dn_5\", \"in_memory\", scope=Scope.SCENARIO)        input = [embedded_1, embedded_2, embedded_3]      output = [embedded_4, embedded_5]        task_config_1 = Config.configure_task(\"name_1\", print, input, output)      task_config_2 = Config.configure_task(\"name_2\", print, input, output)        task_1, task_2 = _TaskManager._bulk_get_or_create([task_config_1, task_config_2])        assert [i.config_id for i in task_1.input.values()] == [embedded_1.id, embedded_2.id, embedded_3.id]      assert [o.config_id for o in task_1.output.values()] == [embedded_4.id, embedded_5.id]        assert [i.config_id for i in task_2.input.values()] == [embedded_1.id, embedded_2.id, embedded_3.id]      assert [o.config_id for o in task_2.output.values()] == [embedded_4.id, embedded_5.id]      def test_delete_raise_exception(init_sql_repo):      init_managers()        dn_input_config_1 = Config.configure_data_node(          \"my_input_1\", \"in_memory\", scope=Scope.SCENARIO, default_data=\"testing\"      )      dn_output_config_1 = Config.configure_data_node(\"my_output_1\", \"in_memory\")      task_config_1 = Config.configure_task(\"task_config_1\", print, dn_input_config_1, dn_output_config_1)      task_1 = _create_task_from_config(task_config_1)      _TaskManager._delete(task_1.id)        with pytest.raises(ModelNotFound):          _TaskManager._delete(task_1.id)      def test_hard_delete(init_sql_repo):      init_managers()        dn_input_config_1 = Config.configure_data_node(          \"my_input_1\", \"in_memory\", scope=Scope.SCENARIO, default_data=\"testing\"      )      dn_output_config_1 = Config.configure_data_node(\"my_output_1\", \"in_memory\")      task_config_1 = Config.configure_task(\"task_config_1\", print, dn_input_config_1, dn_output_config_1)      task_1 = _create_task_from_config(task_config_1)        assert len(_TaskManager._get_all()) == 1      assert len(_DataManager._get_all()) == 2      _TaskManager._hard_delete(task_1.id)      assert len(_TaskManager._get_all()) == 0      assert len(_DataManager._get_all()) == 2      def test_submit_task():      data_node_1 = InMemoryDataNode(\"foo\", Scope.SCENARIO, \"s1\")      data_node_2 = InMemoryDataNode(\"bar\", Scope.SCENARIO, \"s2\")      task_1 = Task(          \"grault\",          {},          print,          [data_node_1],          [data_node_2],          TaskId(\"t1\"),      )        class MockOrchestrator(_Orchestrator):          submit_calls = []          submit_ids = []            def submit_task(self, task, callbacks=None, force=False, wait=False, timeout=None):              submit_id = f\"SUBMISSION_{str(uuid.uuid4())}\"              self.submit_calls.append(task)              self.submit_ids.append(submit_id)              return None        with mock.patch(\"src.taipy.core.task._task_manager._TaskManager._orchestrator\", new=MockOrchestrator):          # Task does not exist, we expect an exception          with pytest.raises(NonExistingTask):              _TaskManager._submit(task_1)          with pytest.raises(NonExistingTask):              _TaskManager._submit(task_1.id)            _TaskManager._set(task_1)          _TaskManager._submit(task_1)          call_ids = [call.id for call in MockOrchestrator.submit_calls]          assert call_ids == [task_1.id]          assert len(MockOrchestrator.submit_ids) == 1            _TaskManager._submit(task_1)          assert len(MockOrchestrator.submit_ids) == 2          assert len(MockOrchestrator.submit_ids) == len(set(MockOrchestrator.submit_ids))            _TaskManager._submit(task_1)          assert len(MockOrchestrator.submit_ids) == 3          assert len(MockOrchestrator.submit_ids) == len(set(MockOrchestrator.submit_ids))      def test_get_tasks_by_config_id(init_sql_repo):      init_managers()        dn_config = Config.configure_data_node(\"dn\", scope=Scope.SCENARIO)      task_config_1 = Config.configure_task(\"t1\", print, dn_config)      task_config_2 = Config.configure_task(\"t2\", print, dn_config)      task_config_3 = Config.configure_task(\"t3\", print, dn_config)        t_1_1 = _TaskManager._bulk_get_or_create([task_config_1], scenario_id=\"scenario_1\")[0]      t_1_2 = _TaskManager._bulk_get_or_create([task_config_1], scenario_id=\"scenario_2\")[0]      t_1_3 = _TaskManager._bulk_get_or_create([task_config_1], scenario_id=\"scenario_3\")[0]      assert len(_TaskManager._get_all()) == 3        t_2_1 = _TaskManager._bulk_get_or_create([task_config_2], scenario_id=\"scenario_4\")[0]      t_2_2 = _TaskManager._bulk_get_or_create([task_config_2], scenario_id=\"scenario_5\")[0]      assert len(_TaskManager._get_all()) == 5        t_3_1 = _TaskManager._bulk_get_or_create([task_config_3], scenario_id=\"scenario_6\")[0]      assert len(_TaskManager._get_all()) == 6        t1_tasks = _TaskManager._get_by_config_id(task_config_1.id)      assert len(t1_tasks) == 3      assert sorted([t_1_1.id, t_1_2.id, t_1_3.id]) == sorted([task.id for task in t1_tasks])        t2_tasks = _TaskManager._get_by_config_id(task_config_2.id)      assert len(t2_tasks) == 2      assert sorted([t_2_1.id, t_2_2.id]) == sorted([task.id for task in t2_tasks])        t3_tasks = _TaskManager._get_by_config_id(task_config_3.id)      assert len(t3_tasks) == 1      assert sorted([t_3_1.id]) == sorted([task.id for task in t3_tasks])      def test_get_scenarios_by_config_id_in_multiple_versions_environment(init_sql_repo):      init_managers()        dn_config = Config.configure_data_node(\"dn\", scope=Scope.SCENARIO)      task_config_1 = Config.configure_task(\"t1\", print, dn_config)      task_config_2 = Config.configure_task(\"t2\", print, dn_config)        _VersionManager._set_experiment_version(\"1.0\")      _TaskManager._bulk_get_or_create([task_config_1], scenario_id=\"scenario_1\")[0]      _TaskManager._bulk_get_or_create([task_config_1], scenario_id=\"scenario_2\")[0]      _TaskManager._bulk_get_or_create([task_config_1], scenario_id=\"scenario_3\")[0]      _TaskManager._bulk_get_or_create([task_config_2], scenario_id=\"scenario_4\")[0]      _TaskManager._bulk_get_or_create([task_config_2], scenario_id=\"scenario_5\")[0]        assert len(_TaskManager._get_by_config_id(task_config_1.id)) == 3      assert len(_TaskManager._get_by_config_id(task_config_2.id)) == 2        _VersionManager._set_experiment_version(\"2.0\")      _TaskManager._bulk_get_or_create([task_config_1], scenario_id=\"scenario_1\")[0]      _TaskManager._bulk_get_or_create([task_config_1], scenario_id=\"scenario_2\")[0]      _TaskManager._bulk_get_or_create([task_config_1], scenario_id=\"scenario_3\")[0]      _TaskManager._bulk_get_or_create([task_config_2], scenario_id=\"scenario_4\")[0]      _TaskManager._bulk_get_or_create([task_config_2], scenario_id=\"scenario_5\")[0]        assert len(_TaskManager._get_by_config_id(task_config_1.id)) == 3      assert len(_TaskManager._get_by_config_id(task_config_2.id)) == 2      def _create_task_from_config(task_config, *args, **kwargs):      return _TaskManager._bulk_get_or_create([task_config], *args, **kwargs)[0] "}
{"text": "from datetime import timedelta  from time import sleep  from typing import Union  from unittest import mock  from unittest.mock import MagicMock    import pytest    from src.taipy.core import JobId, Sequence, SequenceId, 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.in_memory import InMemoryDataNode  from src.taipy.core.job._job_manager import _JobManager  from src.taipy.core.job.job import Job  from src.taipy.core.job.status import Status  from src.taipy.core.scenario.scenario import Scenario  from src.taipy.core.submission._submission_manager_factory import _SubmissionManagerFactory  from src.taipy.core.submission.submission import Submission  from src.taipy.core.task._task_manager import _TaskManager  from src.taipy.core.task.task import Task  from taipy.config.common.scope import Scope  from taipy.config.config import Config      @pytest.fixture  def task_id():      return TaskId(\"task_id1\")      @pytest.fixture  def task(task_id):      return Task(config_id=\"name\", properties={}, function=print, input=[], output=[], id=task_id)      @pytest.fixture  def job_id():      return JobId(\"id1\")      @pytest.fixture(scope=\"class\")  def scenario():      return Scenario(          \"scenario_config\",          [],          {},          [],          \"SCENARIO_scenario_config\",          version=\"random_version_number\",      )      @pytest.fixture  def job(task, job_id):      return Job(job_id, task, \"submit_id\", \"SCENARIO_scenario_config\")      @pytest.fixture  def replace_in_memory_write_fct():      default_write = InMemoryDataNode.write      InMemoryDataNode.write = _error      yield      InMemoryDataNode.write = default_write      def _foo():      return 42      def _error():      raise RuntimeError(\"Something bad has happened\")      def test_create_job(scenario, task, job):      from src.taipy.core.scenario._scenario_manager_factory import _ScenarioManagerFactory        _ScenarioManagerFactory._build_manager()._set(scenario)        assert job.id == \"id1\"      assert task in job      assert job.is_submitted()      assert job.submit_id is not None      assert job.submit_entity_id == \"SCENARIO_scenario_config\"      assert job.submit_entity == scenario      with mock.patch(\"src.taipy.core.get\") as get_mck:          get_mck.return_value = task          assert job.get_label() == \"name > \" + job.id      assert job.get_simple_label() == job.id      def test_comparison(task):      job_id_1 = JobId(\"id1\")      job_id_2 = JobId(\"id2\")        job_1 = Job(job_id_1, task, \"submit_id\", \"scenario_entity_id\")      sleep(0.01)  # Comparison is based on time, precision on Windows is not enough important      job_2 = Job(job_id_2, task, \"submit_id\", \"scenario_entity_id\")        assert job_1 < job_2      assert job_2 > job_1      assert job_1 <= job_2      assert job_1 <= job_1      assert job_2 >= job_1      assert job_1 >= job_1      assert job_1 == job_1      assert job_1 != job_2      def test_status_job(task):      submission = _SubmissionManagerFactory._build_manager()._create(task.id, task._ID_PREFIX)      job = Job(\"job_id\", task, submission.id, \"SCENARIO_scenario_config\")      submission.jobs = [job]        assert job.is_submitted()      assert job.is_skipped() is False      assert job.is_pending() is False      assert job.is_blocked() is False      assert job.is_canceled() is False      assert job.is_failed() is False      assert job.is_completed() is False      assert job.is_running() is False        job.canceled()      assert job.is_canceled()      job.failed()      assert job.is_failed()      job.running()      assert job.is_running()      job.completed()      assert job.is_completed()      job.pending()      assert job.is_pending()      job.blocked()      assert job.is_blocked()      job.skipped()      assert job.is_skipped()      def test_notification_job(task):      subscribe = MagicMock()      submission = _SubmissionManagerFactory._build_manager()._create(task.id, task._ID_PREFIX)      job = Job(\"job_id\", task, submission.id, \"SCENARIO_scenario_config\")      submission.jobs = [job]        job._on_status_change(subscribe)        job.running()      subscribe.assert_called_once_with(job)      subscribe.reset_mock()        job.completed()      subscribe.assert_called_once_with(job)      subscribe.reset_mock()        job.skipped()      subscribe.assert_called_once_with(job)      def test_handle_exception_in_user_function(task_id, job_id):      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, \"scenario_entity_id\")      submission.jobs = [job]        _dispatch(task, job)        job = _JobManager._get(job_id)      assert job.is_failed()      assert 'raise RuntimeError(\"Something bad has happened\")' in str(job.stacktrace[0])      def test_handle_exception_in_input_data_node(task_id, job_id):      data_node = InMemoryDataNode(\"data_node\", scope=Scope.SCENARIO)      task = Task(config_id=\"name\", properties={}, input=[data_node], function=print, output=[], id=task_id)      submission = _SubmissionManagerFactory._build_manager()._create(task.id, task._ID_PREFIX)      job = Job(job_id, task, submission.id, \"scenario_entity_id\")      submission.jobs = [job]        _dispatch(task, job)        job = _JobManager._get(job_id)      assert job.is_failed()      assert \"taipy.core.exceptions.exceptions.NoData\" in str(job.stacktrace[0])      def test_handle_exception_in_ouptut_data_node(replace_in_memory_write_fct, task_id, job_id):      data_node = InMemoryDataNode(\"data_node\", scope=Scope.SCENARIO)      task = Task(config_id=\"name\", properties={}, input=[], function=_foo, output=[data_node], id=task_id)      submission = _SubmissionManagerFactory._build_manager()._create(task.id, task._ID_PREFIX)      job = Job(job_id, task, submission.id, \"scenario_entity_id\")      submission.jobs = [job]        _dispatch(task, job)        job = _JobManager._get(job_id)        assert job.is_failed()      assert \"taipy.core.exceptions.exceptions.DataNodeWritingError\" in str(job.stacktrace[0])      def test_auto_set_and_reload(current_datetime, job_id):      task_1 = Task(config_id=\"name_1\", properties={}, function=_foo, id=TaskId(\"task_1\"))      task_2 = Task(config_id=\"name_2\", properties={}, function=_foo, id=TaskId(\"task_2\"))      submission = _SubmissionManagerFactory._build_manager()._create(task_1.id, task_1._ID_PREFIX)      job_1 = Job(job_id, task_1, submission.id, \"scenario_entity_id\")      submission.jobs = [job_1]        _TaskManager._set(task_1)      _TaskManager._set(task_2)      _JobManager._set(job_1)        job_2 = _JobManager._get(job_1, \"submit_id_2\")        # auto set & reload on task attribute      assert job_1.task.id == task_1.id      assert job_2.task.id == task_1.id      job_1.task = task_2      assert job_1.task.id == task_2.id      assert job_2.task.id == task_2.id      job_2.task = task_1      assert job_1.task.id == task_1.id      assert job_2.task.id == task_1.id        # auto set & reload on force attribute      assert not job_1.force      assert not job_2.force      job_1.force = True      assert job_1.force      assert job_2.force      job_2.force = False      assert not job_1.force      assert not job_2.force        # auto set & reload on status attribute      assert job_1.status == Status.SUBMITTED      assert job_2.status == Status.SUBMITTED      job_1.status = Status.CANCELED      assert job_1.status == Status.CANCELED      assert job_2.status == Status.CANCELED      job_2.status = Status.BLOCKED      assert job_1.status == Status.BLOCKED      assert job_2.status == Status.BLOCKED        # auto set & reload on creation_date attribute      new_datetime = current_datetime + timedelta(1)      new_datetime_1 = current_datetime + timedelta(1)      job_1.creation_date = new_datetime_1      assert job_1.creation_date == new_datetime_1      assert job_2.creation_date == new_datetime_1      job_2.creation_date = new_datetime      assert job_1.creation_date == new_datetime      assert job_2.creation_date == new_datetime        with job_1 as job:          assert job.task.id == task_1.id          assert not job.force          assert job.status == Status.BLOCKED          assert job.creation_date == new_datetime          assert job._is_in_context            new_datetime_2 = new_datetime + timedelta(1)          job.task = task_2          job.force = True          job.status = Status.COMPLETED          job.creation_date = new_datetime_2            assert job.task.id == task_1.id          assert not job.force          assert job.status == Status.BLOCKED          assert job.creation_date == new_datetime          assert job._is_in_context        assert job_1.task.id == task_2.id      assert job_1.force      assert job_1.status == Status.COMPLETED      assert job_1.creation_date == new_datetime_2      assert not job_1._is_in_context      def _dispatch(task: Task, job: Job, mode=JobConfig._DEVELOPMENT_MODE):      Config.configure_job_executions(mode=mode)      _OrchestratorFactory._build_dispatcher()      _TaskManager._set(task)      _JobManager._set(job)      dispatcher: Union[_StandaloneJobDispatcher, _DevelopmentJobDispatcher] = _StandaloneJobDispatcher(          _OrchestratorFactory._orchestrator      )      if mode == JobConfig._DEVELOPMENT_MODE:          dispatcher = _DevelopmentJobDispatcher(_OrchestratorFactory._orchestrator)      dispatcher._dispatch(job)      def test_is_deletable():      with mock.patch(\"src.taipy.core.job._job_manager._JobManager._is_deletable\") as mock_submit:          task = Task(config_id=\"name_1\", properties={}, function=_foo, id=TaskId(\"task_1\"))          job = Job(job_id, task, \"submit_id_1\", \"scenario_entity_id\")          job.is_deletable()          mock_submit.assert_called_once_with(job) "}
{"text": "import multiprocessing  import random  import string  from functools import partial  from time import sleep  from unittest import mock    import pytest    from src.taipy.core._orchestrator._dispatcher._job_dispatcher import _JobDispatcher  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.data._data_manager_factory import _DataManagerFactory  from src.taipy.core.data.in_memory import InMemoryDataNode  from src.taipy.core.exceptions.exceptions import JobNotDeletedException  from src.taipy.core.job._job_manager import _JobManager  from src.taipy.core.job.job_id import JobId  from src.taipy.core.job.status import Status  from src.taipy.core.scenario.scenario import Scenario  from src.taipy.core.submission._submission_manager_factory import _SubmissionManagerFactory  from src.taipy.core.task._task_manager import _TaskManager  from src.taipy.core.task.task import Task  from taipy.config.common.scope import Scope  from taipy.config.config import Config  from tests.core.utils import assert_true_after_time      def multiply(nb1: float, nb2: float):      return nb1 * nb2      def lock_multiply(lock, nb1: float, nb2: float):      with lock:          return multiply(1 or nb1, 2 or nb2)      def test_create_jobs():      Config.configure_job_executions(mode=JobConfig._DEVELOPMENT_MODE)      task = _create_task(multiply, name=\"get_job\")        _OrchestratorFactory._build_dispatcher()        job_1 = _JobManager._create(task, [print], \"submit_id\", \"secnario_id\", True)      assert _JobManager._get(job_1.id) == job_1      assert job_1.is_submitted()      assert task.config_id in job_1.id      assert job_1.task.id == task.id      assert job_1.submit_id == \"submit_id\"      assert job_1.submit_entity_id == \"secnario_id\"      assert job_1.force        job_2 = _JobManager._create(task, [print], \"submit_id_1\", \"secnario_id\", False)      assert _JobManager._get(job_2.id) == job_2      assert job_2.is_submitted()      assert task.config_id in job_2.id      assert job_2.task.id == task.id      assert job_2.submit_id == \"submit_id_1\"      assert job_2.submit_entity_id == \"secnario_id\"      assert not job_2.force      def test_get_job():      Config.configure_job_executions(mode=JobConfig._DEVELOPMENT_MODE)        task = _create_task(multiply, name=\"get_job\")        _OrchestratorFactory._build_dispatcher()        job_1 = _OrchestratorFactory._orchestrator.submit_task(task)      assert _JobManager._get(job_1.id) == job_1      assert _JobManager._get(job_1.id).submit_entity_id == task.id        job_2 = _OrchestratorFactory._orchestrator.submit_task(task)      assert job_1 != job_2      assert _JobManager._get(job_1.id).id == job_1.id      assert _JobManager._get(job_2.id).id == job_2.id      assert _JobManager._get(job_2.id).submit_entity_id == task.id      def test_get_latest_job():      Config.configure_job_executions(mode=JobConfig._DEVELOPMENT_MODE)        task = _create_task(multiply, name=\"get_latest_job\")      task_2 = _create_task(multiply, name=\"get_latest_job_2\")        _OrchestratorFactory._build_dispatcher()        job_1 = _OrchestratorFactory._orchestrator.submit_task(task)      assert _JobManager._get_latest(task) == job_1      assert _JobManager._get_latest(task_2) is None        sleep(0.01)  # Comparison is based on time, precision on Windows is not enough important      job_2 = _OrchestratorFactory._orchestrator.submit_task(task_2)      assert _JobManager._get_latest(task).id == job_1.id      assert _JobManager._get_latest(task_2).id == job_2.id        sleep(0.01)  # Comparison is based on time, precision on Windows is not enough important      job_1_bis = _OrchestratorFactory._orchestrator.submit_task(task)      assert _JobManager._get_latest(task).id == job_1_bis.id      assert _JobManager._get_latest(task_2).id == job_2.id      def test_get_job_unknown():      assert _JobManager._get(JobId(\"Unknown\")) is None      def test_get_jobs():      Config.configure_job_executions(mode=JobConfig._DEVELOPMENT_MODE)        task = _create_task(multiply, name=\"get_all_jobs\")        _OrchestratorFactory._build_dispatcher()        job_1 = _OrchestratorFactory._orchestrator.submit_task(task)      job_2 = _OrchestratorFactory._orchestrator.submit_task(task)        assert {job.id for job in _JobManager._get_all()} == {job_1.id, job_2.id}      def test_delete_job():      Config.configure_job_executions(mode=JobConfig._DEVELOPMENT_MODE)        task = _create_task(multiply, name=\"delete_job\")        _OrchestratorFactory._build_dispatcher()        job_1 = _OrchestratorFactory._orchestrator.submit_task(task)      job_2 = _OrchestratorFactory._orchestrator.submit_task(task)        _JobManager._delete(job_1)        assert [job.id for job in _JobManager._get_all()] == [job_2.id]      assert _JobManager._get(job_1.id) is None      m = multiprocessing.Manager()  lock = m.Lock()      def inner_lock_multiply(nb1: float, nb2: float):      with lock:          return multiply(1 or nb1, 2 or nb2)      def test_raise_when_trying_to_delete_unfinished_job():      Config.configure_job_executions(mode=JobConfig._STANDALONE_MODE, max_nb_of_workers=2)      m = multiprocessing.Manager()      lock = m.Lock()      dnm = _DataManagerFactory._build_manager()      dn_1 = InMemoryDataNode(\"dn_config_1\", Scope.SCENARIO, properties={\"default_data\": 1})      dnm._set(dn_1)      dn_2 = InMemoryDataNode(\"dn_config_2\", Scope.SCENARIO, properties={\"default_data\": 2})      dnm._set(dn_2)      dn_3 = InMemoryDataNode(\"dn_config_3\", Scope.SCENARIO)      dnm._set(dn_3)      task = Task(          \"task_config_1\", {}, partial(lock_multiply, lock), [dn_1, dn_2], [dn_3], id=\"raise_when_delete_unfinished\"      )      _OrchestratorFactory._build_dispatcher()      with lock:          job = _OrchestratorFactory._orchestrator.submit_task(task)            assert_true_after_time(lambda: len(_JobDispatcher._dispatched_processes) == 1)          assert_true_after_time(job.is_running)          with pytest.raises(JobNotDeletedException):              _JobManager._delete(job)          with pytest.raises(JobNotDeletedException):              _JobManager._delete(job, force=False)      assert_true_after_time(job.is_completed)      _JobManager._delete(job)      def test_force_deleting_unfinished_job():      Config.configure_job_executions(mode=JobConfig._STANDALONE_MODE, max_nb_of_workers=2)      m = multiprocessing.Manager()      lock = m.Lock()      dnm = _DataManagerFactory._build_manager()      dn_1 = InMemoryDataNode(\"dn_config_1\", Scope.SCENARIO, properties={\"default_data\": 1})      dnm._set(dn_1)      dn_2 = InMemoryDataNode(\"dn_config_2\", Scope.SCENARIO, properties={\"default_data\": 2})      dnm._set(dn_2)      dn_3 = InMemoryDataNode(\"dn_config_3\", Scope.SCENARIO)      dnm._set(dn_3)      task = Task(          \"task_config_1\", {}, partial(lock_multiply, lock), [dn_1, dn_2], [dn_3], id=\"force_deleting_unfinished_job\"      )      _OrchestratorFactory._build_dispatcher()      with lock:          job = _OrchestratorFactory._orchestrator.submit_task(task)          assert_true_after_time(job.is_running)          with pytest.raises(JobNotDeletedException):              _JobManager._delete(job, force=False)          _JobManager._delete(job, force=True)      assert _JobManager._get(job.id) is None      def test_cancel_single_job():      Config.configure_job_executions(mode=JobConfig._STANDALONE_MODE, max_nb_of_workers=1)        task = _create_task(multiply, name=\"cancel_single_job\")        _OrchestratorFactory._build_dispatcher()        assert_true_after_time(_OrchestratorFactory._dispatcher.is_running)      _OrchestratorFactory._dispatcher.stop()      assert_true_after_time(lambda: not _OrchestratorFactory._dispatcher.is_running())        job = _OrchestratorFactory._orchestrator.submit_task(task)        assert_true_after_time(job.is_pending)      assert_true_after_time(lambda: len(_JobDispatcher._dispatched_processes) == 0)      _JobManager._cancel(job.id)      assert_true_after_time(job.is_canceled)      assert_true_after_time(job.is_canceled)      @mock.patch(      \"src.taipy.core._orchestrator._orchestrator._Orchestrator._orchestrate_job_to_run_or_block\",      return_value=\"orchestrated_job\",  )  @mock.patch(\"src.taipy.core._orchestrator._orchestrator._Orchestrator._cancel_jobs\")  def test_cancel_canceled_abandoned_failed_jobs(cancel_jobs, orchestrated_job):      Config.configure_job_executions(mode=JobConfig._STANDALONE_MODE, max_nb_of_workers=1)        task = _create_task(multiply, name=\"test_cancel_canceled_abandoned_failed_jobs\")        _OrchestratorFactory._build_dispatcher()        assert_true_after_time(_OrchestratorFactory._dispatcher.is_running)      _OrchestratorFactory._dispatcher.stop()      assert_true_after_time(lambda: not _OrchestratorFactory._dispatcher.is_running())        job = _OrchestratorFactory._orchestrator.submit_task(task)      job.canceled()      assert job.is_canceled()      _JobManager._cancel(job)      cancel_jobs.assert_not_called()      assert job.is_canceled()        job = _OrchestratorFactory._orchestrator.submit_task(task)      job.failed()      assert job.is_failed()      _JobManager._cancel(job)      cancel_jobs.assert_not_called()      assert job.is_failed()        job = _OrchestratorFactory._orchestrator.submit_task(task)      job.abandoned()      assert job.is_abandoned()      _JobManager._cancel(job)      cancel_jobs.assert_not_called()      assert job.is_abandoned()      @mock.patch(      \"src.taipy.core._orchestrator._orchestrator._Orchestrator._orchestrate_job_to_run_or_block\",      return_value=\"orchestrated_job\",  )  @mock.patch(\"src.taipy.core.job.job.Job.canceled\")  def test_cancel_completed_skipped_jobs(cancel_jobs, orchestrated_job):      Config.configure_job_executions(mode=JobConfig._STANDALONE_MODE, max_nb_of_workers=1)      task = _create_task(multiply, name=\"cancel_single_job\")        _OrchestratorFactory._build_dispatcher()        assert_true_after_time(_OrchestratorFactory._dispatcher.is_running)      _OrchestratorFactory._dispatcher.stop()      assert_true_after_time(lambda: not _OrchestratorFactory._dispatcher.is_running())        job = _OrchestratorFactory._orchestrator.submit_task(task)      job.completed()      assert job.is_completed()      cancel_jobs.assert_not_called()      _JobManager._cancel(job)      assert job.is_completed()        job = _OrchestratorFactory._orchestrator.submit_task(task)      job.failed()      assert job.is_failed()      cancel_jobs.assert_not_called()      _JobManager._cancel(job)      assert job.is_failed()        job = _OrchestratorFactory._orchestrator.submit_task(task)      job.skipped()      assert job.is_skipped()      cancel_jobs.assert_not_called()      _JobManager._cancel(job)      assert job.is_skipped()      def test_cancel_single_running_job():      Config.configure_job_executions(mode=JobConfig._STANDALONE_MODE, max_nb_of_workers=2)        m = multiprocessing.Manager()      lock = m.Lock()      dnm = _DataManagerFactory._build_manager()      dn_1 = InMemoryDataNode(\"dn_config_1\", Scope.SCENARIO, properties={\"default_data\": 1})      dnm._set(dn_1)      dn_2 = InMemoryDataNode(\"dn_config_2\", Scope.SCENARIO, properties={\"default_data\": 2})      dnm._set(dn_2)      dn_3 = InMemoryDataNode(\"dn_config_3\", Scope.SCENARIO)      dnm._set(dn_3)      task = Task(\"task_config_1\", {}, partial(lock_multiply, lock), [dn_1, dn_2], [dn_3], id=\"cancel_single_job\")        _OrchestratorFactory._build_dispatcher()        assert_true_after_time(_OrchestratorFactory._dispatcher.is_running)      assert_true_after_time(lambda: _OrchestratorFactory._dispatcher._nb_available_workers == 2)        with lock:          job = _OrchestratorFactory._orchestrator.submit_task(task)            assert_true_after_time(lambda: len(_JobDispatcher._dispatched_processes) == 1)          assert_true_after_time(lambda: _OrchestratorFactory._dispatcher._nb_available_workers == 1)          assert_true_after_time(job.is_running)          _JobManager._cancel(job)          assert_true_after_time(job.is_running)      assert_true_after_time(lambda: len(_JobDispatcher._dispatched_processes) == 0)      assert_true_after_time(lambda: _OrchestratorFactory._dispatcher._nb_available_workers == 2)      assert_true_after_time(job.is_completed)      def test_cancel_subsequent_jobs():      Config.configure_job_executions(mode=JobConfig._STANDALONE_MODE, max_nb_of_workers=1)      _OrchestratorFactory._build_dispatcher()      orchestrator = _OrchestratorFactory._orchestrator      submission_manager = _SubmissionManagerFactory._build_manager()        lock_0 = m.Lock()        dn_1 = InMemoryDataNode(\"dn_config_1\", Scope.SCENARIO, properties={\"default_data\": 1})      dn_2 = InMemoryDataNode(\"dn_config_2\", Scope.SCENARIO, properties={\"default_data\": 2})      dn_3 = InMemoryDataNode(\"dn_config_3\", Scope.SCENARIO, properties={\"default_data\": 3})      dn_4 = InMemoryDataNode(\"dn_config_4\", Scope.SCENARIO, properties={\"default_data\": 4})      task_1 = Task(\"task_config_1\", {}, partial(lock_multiply, lock_0), [dn_1, dn_2], [dn_3], id=\"task_1\")      task_2 = Task(\"task_config_2\", {}, multiply, [dn_1, dn_3], [dn_4], id=\"task_2\")      task_3 = Task(\"task_config_3\", {}, print, [dn_4], id=\"task_3\")        # Can't get tasks under 1 scenario due to partial not serializable      submission_1 = submission_manager._create(\"scenario_id\", Scenario._ID_PREFIX)      submission_2 = submission_manager._create(\"scenario_id\", Scenario._ID_PREFIX)        _DataManager._set(dn_1)      _DataManager._set(dn_2)      _DataManager._set(dn_3)      _DataManager._set(dn_4)        with lock_0:          job_1 = orchestrator._lock_dn_output_and_create_job(              task_1, submit_id=submission_1.id, submit_entity_id=submission_1.entity_id          )          orchestrator._orchestrate_job_to_run_or_block([job_1])          job_2 = orchestrator._lock_dn_output_and_create_job(              task_2, submit_id=submission_1.id, submit_entity_id=submission_1.entity_id          )          orchestrator._orchestrate_job_to_run_or_block([job_2])          job_3 = orchestrator._lock_dn_output_and_create_job(              task_3, submit_id=submission_1.id, submit_entity_id=submission_1.entity_id          )          orchestrator._orchestrate_job_to_run_or_block([job_3])            submission_1.jobs = [job_1, job_2, job_3]            assert_true_after_time(lambda: _OrchestratorFactory._orchestrator.jobs_to_run.qsize() == 0)          assert_true_after_time(lambda: len(_OrchestratorFactory._orchestrator.blocked_jobs) == 2)          assert_true_after_time(job_1.is_running)          assert_true_after_time(job_2.is_blocked)          assert_true_after_time(job_3.is_blocked)            job_4 = _OrchestratorFactory._orchestrator._lock_dn_output_and_create_job(              task_1, submit_id=submission_2.id, submit_entity_id=submission_2.entity_id          )          orchestrator._orchestrate_job_to_run_or_block([job_4])          job_5 = _OrchestratorFactory._orchestrator._lock_dn_output_and_create_job(              task_2, submit_id=submission_2.id, submit_entity_id=submission_2.entity_id          )          orchestrator._orchestrate_job_to_run_or_block([job_5])          job_6 = _OrchestratorFactory._orchestrator._lock_dn_output_and_create_job(              task_3, submit_id=submission_2.id, submit_entity_id=submission_2.entity_id          )          orchestrator._orchestrate_job_to_run_or_block([job_6])            submission_2.jobs = [job_4, job_5, job_6]            assert_true_after_time(job_4.is_pending)          assert_true_after_time(job_5.is_blocked)          assert_true_after_time(job_6.is_blocked)          assert _OrchestratorFactory._orchestrator.jobs_to_run.qsize() == 1          assert len(_OrchestratorFactory._orchestrator.blocked_jobs) == 4            _JobManager._cancel(job_4)          assert_true_after_time(job_4.is_canceled)          assert_true_after_time(job_5.is_abandoned)          assert_true_after_time(job_6.is_abandoned)          assert _OrchestratorFactory._orchestrator.jobs_to_run.qsize() == 0          assert len(_OrchestratorFactory._orchestrator.blocked_jobs) == 2            _JobManager._cancel(job_1)          assert_true_after_time(job_1.is_running)          assert_true_after_time(job_2.is_abandoned)          assert_true_after_time(job_3.is_abandoned)        assert_true_after_time(job_1.is_completed)      assert_true_after_time(job_2.is_abandoned)      assert_true_after_time(job_3.is_abandoned)      assert_true_after_time(job_4.is_canceled)      assert_true_after_time(job_5.is_abandoned)      assert_true_after_time(job_6.is_abandoned)      assert_true_after_time(          lambda: all(              not _OrchestratorFactory._orchestrator._is_blocked(job)              for job in [job_1, job_2, job_3, job_4, job_5, job_6]          )      )      assert_true_after_time(lambda: _OrchestratorFactory._orchestrator.jobs_to_run.qsize() == 0)      def test_is_deletable():      assert len(_JobManager._get_all()) == 0      task = _create_task(print, 0, \"task\")      job = _OrchestratorFactory._orchestrator.submit_task(task)        assert job.is_completed()      assert _JobManager._is_deletable(job)      assert _JobManager._is_deletable(job.id)        job.abandoned()      assert job.is_abandoned()      assert _JobManager._is_deletable(job)      assert _JobManager._is_deletable(job.id)        job.canceled()      assert job.is_canceled()      assert _JobManager._is_deletable(job)      assert _JobManager._is_deletable(job.id)        job.failed()      assert job.is_failed()      assert _JobManager._is_deletable(job)      assert _JobManager._is_deletable(job.id)        job.skipped()      assert job.is_skipped()      assert _JobManager._is_deletable(job)      assert _JobManager._is_deletable(job.id)        job.blocked()      assert job.is_blocked()      assert not _JobManager._is_deletable(job)      assert not _JobManager._is_deletable(job.id)        job.running()      assert job.is_running()      assert not _JobManager._is_deletable(job)      assert not _JobManager._is_deletable(job.id)        job.pending()      assert job.is_pending()      assert not _JobManager._is_deletable(job)      assert not _JobManager._is_deletable(job.id)        job.status = Status.SUBMITTED      assert job.is_submitted()      assert not _JobManager._is_deletable(job)      assert not _JobManager._is_deletable(job.id)      def _create_task(function, nb_outputs=1, name=None):      input1_dn_config = Config.configure_data_node(\"input1\", \"pickle\", Scope.SCENARIO, default_data=21)      input2_dn_config = Config.configure_data_node(\"input2\", \"pickle\", Scope.SCENARIO, default_data=2)      output_dn_configs = [          Config.configure_data_node(f\"output{i}\", \"pickle\", Scope.SCENARIO, default_data=0) for i in range(nb_outputs)      ]      _DataManager._bulk_get_or_create({cfg for cfg in output_dn_configs})      name = name or \"\".join(random.choice(string.ascii_lowercase) for _ in range(10))      task_config = Config.configure_task(          id=name,          function=function,          input=[input1_dn_config, input2_dn_config],          output=output_dn_configs,      )      return _TaskManager._bulk_get_or_create([task_config])[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 multiprocessing  import random  import string  from functools import partial  from time import sleep    import pytest    from src.taipy.core import Task  from src.taipy.core._orchestrator._dispatcher._job_dispatcher import _JobDispatcher  from src.taipy.core._orchestrator._orchestrator_factory import _OrchestratorFactory  from src.taipy.core._repository.db._sql_connection import _build_connection, _SQLConnection  from src.taipy.core.config.job_config import JobConfig  from src.taipy.core.data import InMemoryDataNode  from src.taipy.core.data._data_manager import _DataManager  from src.taipy.core.data._data_manager_factory import _DataManagerFactory  from src.taipy.core.exceptions.exceptions import JobNotDeletedException  from src.taipy.core.job._job_manager import _JobManager  from src.taipy.core.job._job_manager_factory import _JobManagerFactory  from src.taipy.core.job.job_id import JobId  from src.taipy.core.job.status import Status  from src.taipy.core.task._task_manager import _TaskManager  from src.taipy.core.task._task_manager_factory import _TaskManagerFactory  from taipy.config.common.scope import Scope  from taipy.config.config import Config  from tests.core.utils import assert_true_after_time      def multiply(nb1: float, nb2: float):      return nb1 * nb2      def lock_multiply(lock, nb1: float, nb2: float):      with lock:          return multiply(nb1 or 1, nb2 or 2)      def init_managers():      _TaskManagerFactory._build_manager()._delete_all()      _DataManagerFactory._build_manager()._delete_all()      _JobManagerFactory._build_manager()._delete_all()      def test_create_jobs(init_sql_repo):      Config.configure_job_executions(mode=JobConfig._DEVELOPMENT_MODE)      init_managers()        task = _create_task(multiply, name=\"get_job\")        _OrchestratorFactory._build_dispatcher()        job_1 = _JobManager._create(task, [print], \"submit_id\", \"secnario_id\", True)      assert _JobManager._get(job_1.id) == job_1      assert job_1.is_submitted()      assert task.config_id in job_1.id      assert job_1.task.id == task.id      assert job_1.submit_id == \"submit_id\"      assert job_1.submit_entity_id == \"secnario_id\"      assert job_1.force        job_2 = _JobManager._create(task, [print], \"submit_id_1\", \"secnario_id\", False)      assert _JobManager._get(job_2.id) == job_2      assert job_2.is_submitted()      assert task.config_id in job_2.id      assert job_2.task.id == task.id      assert job_2.submit_id == \"submit_id_1\"      assert job_2.submit_entity_id == \"secnario_id\"      assert not job_2.force      def test_get_job(init_sql_repo):      Config.configure_job_executions(mode=JobConfig._DEVELOPMENT_MODE)      init_managers()        task = _create_task(multiply, name=\"get_job\")        _OrchestratorFactory._build_dispatcher()        job_1 = _OrchestratorFactory._orchestrator.submit_task(task)      assert _JobManager._get(job_1.id) == job_1      assert _JobManager._get(job_1.id).submit_entity_id == task.id        job_2 = _OrchestratorFactory._orchestrator.submit_task(task)      assert job_1 != job_2      assert _JobManager._get(job_1.id).id == job_1.id      assert _JobManager._get(job_2.id).id == job_2.id      assert _JobManager._get(job_2.id).submit_entity_id == task.id      def test_get_latest_job(init_sql_repo):      Config.configure_job_executions(mode=JobConfig._DEVELOPMENT_MODE)      init_managers()        task = _create_task(multiply, name=\"get_latest_job\")      task_2 = _create_task(multiply, name=\"get_latest_job_2\")        _OrchestratorFactory._build_dispatcher()        job_1 = _OrchestratorFactory._orchestrator.submit_task(task)      assert _JobManager._get_latest(task) == job_1      assert _JobManager._get_latest(task_2) is None        sleep(0.01)  # Comparison is based on time, precision on Windows is not enough important      job_2 = _OrchestratorFactory._orchestrator.submit_task(task_2)      assert _JobManager._get_latest(task).id == job_1.id      assert _JobManager._get_latest(task_2).id == job_2.id        sleep(0.01)  # Comparison is based on time, precision on Windows is not enough important      job_1_bis = _OrchestratorFactory._orchestrator.submit_task(task)      assert _JobManager._get_latest(task).id == job_1_bis.id      assert _JobManager._get_latest(task_2).id == job_2.id      def test_get_job_unknown(init_sql_repo):      init_managers()      assert _JobManager._get(JobId(\"Unknown\")) is None      def test_get_jobs(init_sql_repo):      Config.configure_job_executions(mode=JobConfig._DEVELOPMENT_MODE)      init_managers()        task = _create_task(multiply, name=\"get_all_jobs\")        _OrchestratorFactory._build_dispatcher()        job_1 = _OrchestratorFactory._orchestrator.submit_task(task)      job_2 = _OrchestratorFactory._orchestrator.submit_task(task)        assert {job.id for job in _JobManager._get_all()} == {job_1.id, job_2.id}      def test_delete_job(init_sql_repo):      Config.configure_job_executions(mode=JobConfig._DEVELOPMENT_MODE)        init_managers()        task = _create_task(multiply, name=\"delete_job\")        _OrchestratorFactory._build_dispatcher()        job_1 = _OrchestratorFactory._orchestrator.submit_task(task)      job_2 = _OrchestratorFactory._orchestrator.submit_task(task)        _JobManager._delete(job_1)        assert [job.id for job in _JobManager._get_all()] == [job_2.id]      assert _JobManager._get(job_1.id) is None      def test_raise_when_trying_to_delete_unfinished_job(init_sql_repo):      Config.configure_job_executions(mode=JobConfig._STANDALONE_MODE, max_nb_of_workers=2)      init_managers()        m = multiprocessing.Manager()      lock = m.Lock()      dnm = _DataManagerFactory._build_manager()      dn_1 = InMemoryDataNode(\"dn_config_1\", Scope.SCENARIO, properties={\"default_data\": 1})      dnm._set(dn_1)      dn_2 = InMemoryDataNode(\"dn_config_2\", Scope.SCENARIO, properties={\"default_data\": 2})      dnm._set(dn_2)      dn_3 = InMemoryDataNode(\"dn_config_3\", Scope.SCENARIO)      dnm._set(dn_3)      task = Task(\"task_cfg\", {}, partial(lock_multiply, lock), [dn_1, dn_2], [dn_3], id=\"raise_when_delete_unfinished\")      _OrchestratorFactory._build_dispatcher()        with lock:          job = _OrchestratorFactory._orchestrator.submit_task(task)            assert_true_after_time(lambda: len(_JobDispatcher._dispatched_processes) == 1)          assert_true_after_time(job.is_running)          with pytest.raises(JobNotDeletedException):              _JobManager._delete(job)          with pytest.raises(JobNotDeletedException):              _JobManager._delete(job, force=False)      assert_true_after_time(job.is_completed)      _JobManager._delete(job)      def test_force_deleting_unfinished_job(init_sql_repo):      Config.configure_job_executions(mode=JobConfig._STANDALONE_MODE, max_nb_of_workers=2)      init_managers()        m = multiprocessing.Manager()      lock = m.Lock()      dnm = _DataManagerFactory._build_manager()      dn_1 = InMemoryDataNode(\"dn_config_1\", Scope.SCENARIO, properties={\"default_data\": 1})      dnm._set(dn_1)      dn_2 = InMemoryDataNode(\"dn_config_2\", Scope.SCENARIO, properties={\"default_data\": 2})      dnm._set(dn_2)      dn_3 = InMemoryDataNode(\"dn_config_3\", Scope.SCENARIO)      dnm._set(dn_3)      task_1 = Task(          \"task_config_1\", {}, partial(lock_multiply, lock), [dn_1, dn_2], [dn_3], id=\"delete_force_unfinished_job\"      )      reference_last_edit_date = dn_3.last_edit_date      _OrchestratorFactory._build_dispatcher()        with lock:          job = _OrchestratorFactory._orchestrator.submit_task(task_1)          assert_true_after_time(job.is_running)          with pytest.raises(JobNotDeletedException):              _JobManager._delete(job, force=False)          _JobManager._delete(job, force=True)      assert _JobManager._get(job.id) is None      assert_true_after_time(lambda: reference_last_edit_date != dn_3.last_edit_date)      def test_is_deletable(init_sql_repo):      init_managers()        assert len(_JobManager._get_all()) == 0      task = _create_task(print, 0, \"task\")      job = _OrchestratorFactory._orchestrator.submit_task(task)        assert job.is_completed()      assert _JobManager._is_deletable(job)      assert _JobManager._is_deletable(job.id)        job.abandoned()      assert job.is_abandoned()      assert _JobManager._is_deletable(job)      assert _JobManager._is_deletable(job.id)        job.canceled()      assert job.is_canceled()      assert _JobManager._is_deletable(job)      assert _JobManager._is_deletable(job.id)        job.failed()      assert job.is_failed()      assert _JobManager._is_deletable(job)      assert _JobManager._is_deletable(job.id)        job.skipped()      assert job.is_skipped()      assert _JobManager._is_deletable(job)      assert _JobManager._is_deletable(job.id)        job.blocked()      assert job.is_blocked()      assert not _JobManager._is_deletable(job)      assert not _JobManager._is_deletable(job.id)        job.running()      assert job.is_running()      assert not _JobManager._is_deletable(job)      assert not _JobManager._is_deletable(job.id)        job.pending()      assert job.is_pending()      assert not _JobManager._is_deletable(job)      assert not _JobManager._is_deletable(job.id)        job.status = Status.SUBMITTED      assert job.is_submitted()      assert not _JobManager._is_deletable(job)      assert not _JobManager._is_deletable(job.id)      def _create_task(function, nb_outputs=1, name=None):      input1_dn_config = Config.configure_data_node(\"input1\", scope=Scope.SCENARIO, default_data=21)      input2_dn_config = Config.configure_data_node(\"input2\", scope=Scope.SCENARIO, default_data=2)      output_dn_configs = [          Config.configure_data_node(f\"output{i}\", scope=Scope.SCENARIO, default_data=0) for i in range(nb_outputs)      ]      _DataManager._bulk_get_or_create({cfg for cfg in output_dn_configs})      name = name or \"\".join(random.choice(string.ascii_lowercase) for _ in range(10))      task_config = Config.configure_task(          id=name,          function=function,          input=[input1_dn_config, input2_dn_config],          output=output_dn_configs,      )      return _TaskManager._bulk_get_or_create([task_config])[0] "}
{"text": "import os    import pytest    from src.taipy.core.data._data_sql_repository import _DataSQLRepository  from src.taipy.core.exceptions import ModelNotFound  from src.taipy.core.job._job_fs_repository import _JobFSRepository  from src.taipy.core.job._job_sql_repository import _JobSQLRepository  from src.taipy.core.job.job import Job, JobId, Task  from src.taipy.core.task._task_sql_repository import _TaskSQLRepository      class TestJobRepository:      @pytest.mark.parametrize(\"repo\", [_JobFSRepository, _JobSQLRepository])      def test_save_and_load(self, data_node, job, repo, init_sql_repo):          _DataSQLRepository()._save(data_node)          task = Task(\"task_config_id\", {}, print, [data_node], [data_node])          _TaskSQLRepository()._save(task)          job._task = task            repository = repo()          repository._save(job)            obj = repository._load(job.id)          assert isinstance(obj, Job)        @pytest.mark.parametrize(\"repo\", [_JobFSRepository, _JobSQLRepository])      def test_exists(self, data_node, job, repo, init_sql_repo):          _DataSQLRepository()._save(data_node)          task = Task(\"task_config_id\", {}, print, [data_node], [data_node])          _TaskSQLRepository()._save(task)          job._task = task          repository = repo()          repository._save(job)            assert repository._exists(job.id)          assert not repository._exists(\"not-existed-job\")        @pytest.mark.parametrize(\"repo\", [_JobFSRepository, _JobSQLRepository])      def test_load_all(self, data_node, job, repo, init_sql_repo):          _DataSQLRepository()._save(data_node)          task = Task(\"task_config_id\", {}, print, [data_node], [data_node])          _TaskSQLRepository()._save(task)          job._task = task          repository = repo()          for i in range(10):              job.id = JobId(f\"job-{i}\")              repository._save(job)          jobs = repository._load_all()            assert len(jobs) == 10        @pytest.mark.parametrize(\"repo\", [_JobFSRepository, _JobSQLRepository])      def test_load_all_with_filters(self, data_node, job, repo, init_sql_repo):          repository = repo()          _DataSQLRepository()._save(data_node)          task = Task(\"task_config_id\", {}, print, [data_node], [data_node])          _TaskSQLRepository()._save(task)          job._task = task            for i in range(10):              job.id = JobId(f\"job-{i}\")              repository._save(job)          objs = repository._load_all(filters=[{\"id\": \"job-2\"}])            assert len(objs) == 1        @pytest.mark.parametrize(\"repo\", [_JobFSRepository, _JobSQLRepository])      def test_delete(self, data_node, job, repo, init_sql_repo):          repository = repo()          _DataSQLRepository()._save(data_node)          task = Task(\"task_config_id\", {}, print, [data_node], [data_node])          _TaskSQLRepository()._save(task)          job._task = task          repository._save(job)            repository._delete(job.id)            with pytest.raises(ModelNotFound):              repository._load(job.id)        @pytest.mark.parametrize(\"repo\", [_JobFSRepository, _JobSQLRepository])      def test_delete_all(self, data_node, job, repo, init_sql_repo):          repository = repo()          _DataSQLRepository()._save(data_node)          task = Task(\"task_config_id\", {}, print, [data_node], [data_node])          _TaskSQLRepository()._save(task)          job._task = task            for i in range(10):              job.id = JobId(f\"job-{i}\")              repository._save(job)            assert len(repository._load_all()) == 10            repository._delete_all()            assert len(repository._load_all()) == 0        @pytest.mark.parametrize(\"repo\", [_JobFSRepository, _JobSQLRepository])      def test_delete_many(self, data_node, job, repo, init_sql_repo):          repository = repo()          _DataSQLRepository()._save(data_node)          task = Task(\"task_config_id\", {}, print, [data_node], [data_node])          _TaskSQLRepository()._save(task)          job._task = task            for i in range(10):              job.id = JobId(f\"job-{i}\")              repository._save(job)            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\", [_JobFSRepository, _JobSQLRepository])      def test_delete_by(self, data_node, job, repo, init_sql_repo):          repository = repo()          _DataSQLRepository()._save(data_node)          task = Task(\"task_config_id\", {}, print, [data_node], [data_node])          _TaskSQLRepository()._save(task)          job._task = task            # Create 5 entities with version 1.0 and 5 entities with version 2.0          for i in range(10):              job.id = JobId(f\"job-{i}\")              job._version = f\"{(i+1) // 5}.0\"              repository._save(job)            objs = repository._load_all()          assert len(objs) == 10          repository._delete_by(\"version\", \"1.0\")            assert len(repository._load_all()) == 5        @pytest.mark.parametrize(\"repo\", [_JobFSRepository, _JobSQLRepository])      def test_search(self, data_node, job, repo, init_sql_repo):          repository = repo()          _DataSQLRepository()._save(data_node)          task = Task(\"task_config_id\", {}, print, [data_node], [data_node])          _TaskSQLRepository()._save(task)          job._task = task            for i in range(10):              job.id = JobId(f\"job-{i}\")              repository._save(job)            assert len(repository._load_all()) == 10            objs = repository._search(\"id\", \"job-2\")          assert len(objs) == 1          assert isinstance(objs[0], Job)            objs = repository._search(\"id\", \"job-2\", filters=[{\"version\": \"random_version_number\"}])          assert len(objs) == 1          assert isinstance(objs[0], Job)            assert repository._search(\"id\", \"job-2\", filters=[{\"version\": \"non_existed_version\"}]) == []        @pytest.mark.parametrize(\"repo\", [_JobFSRepository, _JobSQLRepository])      def test_export(self, tmpdir, job, repo, init_sql_repo):          repository = repo()          repository._save(job)            repository._export(job.id, tmpdir.strpath)          dir_path = repository.dir_path if repo == _JobFSRepository else os.path.join(tmpdir.strpath, \"job\")            assert os.path.exists(os.path.join(dir_path, f\"{job.id}.json\")) "}
{"text": "from unittest import mock    import pytest    from src.taipy.core.common._utils import _Subscriber  from src.taipy.core.data._data_manager_factory import _DataManagerFactory  from src.taipy.core.data.data_node import DataNode  from src.taipy.core.data.in_memory import InMemoryDataNode  from src.taipy.core.data.pickle import PickleDataNode  from src.taipy.core.scenario._scenario_manager import _ScenarioManager  from src.taipy.core.scenario.scenario import Scenario  from src.taipy.core.sequence._sequence_manager import _SequenceManager  from src.taipy.core.sequence.sequence import Sequence  from src.taipy.core.sequence.sequence_id import SequenceId  from src.taipy.core.task._task_manager import _TaskManager  from src.taipy.core.task.task import Task, TaskId  from taipy.config.common.scope import Scope      def test_create_sequence():      input = InMemoryDataNode(\"foo\", Scope.SCENARIO)      output = InMemoryDataNode(\"bar\", Scope.SCENARIO)      task = Task(\"baz\", {}, print, [input], [output], TaskId(\"task_id\"))        sequence = Sequence({\"description\": \"description\"}, [task], sequence_id=SequenceId(\"name_1\"))      assert sequence.id == \"name_1\"      assert sequence.owner_id is None      assert sequence.description == \"description\"      assert sequence.foo == input      assert sequence.bar == output      assert sequence.baz.id == task.id      assert sequence.tasks == {task.config_id: task}      assert sequence.data_nodes == {\"foo\": input, \"bar\": output}      assert sequence.parent_ids == set()      with pytest.raises(AttributeError):          sequence.qux      assert sequence.get_label() == sequence.id      assert sequence.get_simple_label() == sequence.id        input_1 = InMemoryDataNode(\"input\", Scope.SCENARIO)      output_1 = InMemoryDataNode(\"output\", Scope.SCENARIO)      task_1 = Task(\"task_1\", {}, print, [input_1], [output_1], TaskId(\"task_id_1\"))      sequence_1 = Sequence(          {\"description\": \"description\"},          [task_1],          owner_id=\"owner_id\",          parent_ids={\"scenario_id\"},          sequence_id=SequenceId(\"name_1\"),      )      assert sequence_1.id == \"name_1\"      assert sequence_1.owner_id == \"owner_id\"      assert sequence_1.description == \"description\"      assert sequence_1.input == input_1      assert sequence_1.output == output_1      assert sequence_1.task_1 == task_1      assert sequence_1.tasks == {task_1.config_id: task_1}      assert sequence_1.data_nodes == {\"input\": input_1, \"output\": output_1}      assert sequence_1.parent_ids == {\"scenario_id\"}      assert sequence_1.id is not None      with mock.patch(\"src.taipy.core.get\") as get_mck:            class MockOwner:              label = \"owner_label\"                def get_label(self):                  return self.label            get_mck.return_value = MockOwner()          assert sequence_1.get_label() == \"owner_label > \" + sequence_1.id          assert sequence_1.get_simple_label() == sequence_1.id        sequence_2 = Sequence(          {\"description\": \"description\", \"name\": \"Name\"},          [task, task_1],          owner_id=\"owner_id\",          parent_ids={\"parent_id_1\", \"parent_id_2\"},          sequence_id=SequenceId(\"name_2\"),      )      assert sequence_2.owner_id == \"owner_id\"      assert sequence_2.id == \"name_2\"      assert sequence_2.description == \"description\"      assert sequence_2.tasks == {task.config_id: task, task_1.config_id: task_1}      assert sequence_2.data_nodes == {\"foo\": input, \"bar\": output, \"input\": input_1, \"output\": output_1}      assert sequence_2.parent_ids == {\"parent_id_1\", \"parent_id_2\"}      with mock.patch(\"src.taipy.core.get\") as get_mck:            class MockOwner:              label = \"owner_label\"                def get_label(self):                  return self.label            get_mck.return_value = MockOwner()          assert sequence_2.get_label() == \"owner_label > \" + sequence_2.name          assert sequence_2.get_simple_label() == sequence_2.name      def test_check_consistency():      sequence_1 = Sequence({}, [], \"name_1\")      assert sequence_1._is_consistent()        input_2 = InMemoryDataNode(\"foo\", Scope.SCENARIO)      output_2 = InMemoryDataNode(\"bar\", Scope.SCENARIO)      task_2 = Task(\"tfoo\", {}, print, [input_2], [output_2], TaskId(\"task_id_2\"))      sequence_2 = Sequence({}, [task_2], \"name_2\")      assert sequence_2._is_consistent()        data_node_3 = InMemoryDataNode(\"foo\", Scope.SCENARIO)      task_3 = Task(\"tfoo\", {}, print, [data_node_3], [data_node_3], TaskId(\"task_id_3\"))      sequence_3 = Sequence({}, [task_3], \"name_3\")      assert not sequence_3._is_consistent()  # Not a dag        input_4 = InMemoryDataNode(\"foo\", Scope.SCENARIO)      output_4 = InMemoryDataNode(\"bar\", Scope.SCENARIO)      task_4_1 = Task(\"tfoo\", {}, print, [input_4], [output_4], TaskId(\"task_id_4_1\"))      task_4_2 = Task(\"tbar\", {}, print, [output_4], [input_4], TaskId(\"task_id_4_2\"))      sequence_4 = Sequence({}, [task_4_1, task_4_2], \"name_4\")      assert not sequence_4._is_consistent()  # Not a Dag        class FakeDataNode:          config_id = \"config_id_of_a_fake_dn\"        input_6 = DataNode(\"foo\", Scope.SCENARIO, \"input_id_5\")      output_6 = DataNode(\"bar\", Scope.SCENARIO, \"output_id_5\")      task_6_1 = Task(\"tfoo\", {}, print, [input_6], [output_6], TaskId(\"task_id_5_1\"))      task_6_2 = Task(\"tbar\", {}, print, [output_6], [FakeDataNode()], TaskId(\"task_id_5_2\"))      sequence_6 = Sequence({}, [task_6_1, task_6_2], \"name_5\")      assert not sequence_6._is_consistent()  # Not a DataNode        intermediate_7 = DataNode(\"foo\", Scope.SCENARIO, \"intermediate_id_7\")      output_7 = DataNode(\"bar\", Scope.SCENARIO, \"output_id_7\")      task_7_1 = Task(\"tfoo\", {}, print, [], [intermediate_7], TaskId(\"task_id_7_1\"))      task_7_2 = Task(\"tbar\", {}, print, [intermediate_7], [output_7], TaskId(\"task_id_7_2\"))      sequence_7 = Sequence({}, [task_7_1, task_7_2], \"name_7\")      assert sequence_7._is_consistent()        input_8 = DataNode(\"foo\", Scope.SCENARIO, \"output_id_8\")      intermediate_8 = DataNode(\"bar\", Scope.SCENARIO, \"intermediate_id_8\")      task_8_1 = Task(\"tfoo\", {}, print, [input_8], [intermediate_8], TaskId(\"task_id_8_1\"))      task_8_2 = Task(\"tbar\", {}, print, [intermediate_8], [], TaskId(\"task_id_8_2\"))      sequence_8 = Sequence({}, [task_8_1, task_8_2], \"name_8\")      assert sequence_8._is_consistent()        input_9_1 = DataNode(\"foo\", Scope.SCENARIO, \"input_id_9_1\")      output_9_1 = DataNode(\"bar\", Scope.SCENARIO, \"output_id_9_1\")      input_9_2 = DataNode(\"baz\", Scope.SCENARIO, \"input_id_9_2\")      output_9_2 = DataNode(\"qux\", Scope.SCENARIO, \"output_id_9_2\")      task_9_1 = Task(\"tfoo\", {}, print, [input_9_1], [output_9_1], TaskId(\"task_id_9_1\"))      task_9_2 = Task(\"tbar\", {}, print, [input_9_2], [output_9_2], TaskId(\"task_id_9_2\"))      sequence_9 = Sequence({}, [task_9_1, task_9_2], \"name_9\")      assert not sequence_9._is_consistent()  # Not connected        input_10_1 = DataNode(\"foo\", Scope.SCENARIO, \"output_id_10_1\")      intermediate_10_1 = DataNode(\"bar\", Scope.SCENARIO, \"intermediate_id_10_1\")      intermediate_10_2 = DataNode(\"baz\", Scope.SCENARIO, \"intermediate_id_10_2\")      output_10 = DataNode(\"qux\", Scope.SCENARIO, \"output_id_10\")      post_10 = DataNode(\"quux\", Scope.SCENARIO, \"post_id_10\")      task_10_1 = Task(\"tfoo\", {}, print, [input_10_1], [intermediate_10_1], TaskId(\"task_id_10_1\"))      task_10_2 = Task(\"tbar\", {}, print, [], [intermediate_10_2], TaskId(\"task_id_10_2\"))      task_10_3 = Task(\"tbaz\", {}, print, [intermediate_10_1, intermediate_10_2], [output_10], TaskId(\"task_id_10_3\"))      task_10_4 = Task(\"tqux\", {}, print, [output_10], [post_10], TaskId(\"task_id_10_4\"))      task_10_5 = Task(\"tquux\", {}, print, [output_10], [], TaskId(\"task_id_10_5\"))      sequence_10 = Sequence({}, [task_10_1, task_10_2, task_10_3, task_10_4, task_10_5], \"name_10\")      assert sequence_10._is_consistent()      def test_get_sorted_tasks():      def assert_equal(tasks_a, tasks_b) -> bool:          if len(tasks_a) != len(tasks_b):              return False          for i in range(len(tasks_a)):              task_a, task_b = tasks_a[i], tasks_b[i]              if isinstance(task_a, list) and isinstance(task_b, list):                  if not assert_equal(task_a, task_b):                      return False              elif isinstance(task_a, list) or isinstance(task_b, list):                  return False              else:                  index_task_b = tasks_b.index(task_a)                  if any([isinstance(task_b, list) for task_b in tasks_b[i : index_task_b + 1]]):                      return False          return True        data_node_1 = DataNode(\"foo\", Scope.SCENARIO, \"s1\")      data_node_2 = DataNode(\"bar\", Scope.SCENARIO, \"s2\")      data_node_3 = DataNode(\"baz\", Scope.SCENARIO, \"s3\")      data_node_4 = DataNode(\"qux\", Scope.SCENARIO, \"s4\")      data_node_5 = DataNode(\"quux\", Scope.SCENARIO, \"s5\")      data_node_6 = DataNode(\"quuz\", Scope.SCENARIO, \"s6\")      data_node_7 = DataNode(\"corge\", Scope.SCENARIO, \"s7\")      task_1 = Task(          \"grault\",          {},          print,          [data_node_1, data_node_2],          [data_node_3, data_node_4],          TaskId(\"t1\"),      )      task_2 = Task(\"garply\", {}, print, [data_node_3], [data_node_5], TaskId(\"t2\"))      task_3 = Task(\"waldo\", {}, print, [data_node_5, data_node_4], [data_node_6], TaskId(\"t3\"))      task_4 = Task(\"fred\", {}, print, [data_node_4], [data_node_7], TaskId(\"t4\"))      sequence = Sequence({}, [task_4, task_2, task_1, task_3], SequenceId(\"p1\"))      # s1 ---             ---> s3 ---> t2 ---> s5 ----      #       |           |                           |      #       |---> t1 ---|      -------------------------> t3 ---> s6      #       |           |      |      # s2 ---             ---> s4 ---> t4 ---> s7      assert assert_equal(sequence._get_sorted_tasks(), [[task_1], [task_2, task_4], [task_3]])        data_node_1 = DataNode(\"foo\", Scope.SCENARIO, \"s1\")      data_node_2 = DataNode(\"bar\", Scope.SCENARIO, \"s2\")      data_node_4 = DataNode(\"qux\", Scope.SCENARIO, \"s4\")      data_node_5 = DataNode(\"quux\", Scope.SCENARIO, \"s5\")      data_node_6 = DataNode(\"quuz\", Scope.SCENARIO, \"s6\")      data_node_7 = DataNode(\"corge\", Scope.SCENARIO, \"s7\")      task_1 = Task(          \"grault\",          {},          print,          [data_node_1, data_node_2],          [data_node_4],          TaskId(\"t1\"),      )      task_2 = Task(\"garply\", {}, print, None, [data_node_5], TaskId(\"t2\"))      task_3 = Task(\"waldo\", {}, print, [data_node_5, data_node_4], [data_node_6], TaskId(\"t3\"))      task_4 = Task(\"fred\", {}, print, [data_node_4], [data_node_7], TaskId(\"t4\"))      sequence = Sequence({}, [task_4, task_2, task_1, task_3], SequenceId(\"p1\"))      # s1 ---      t2 ---> s5 ------      #       |                     |      #       |---> t1 ---|      -----> t3 ---> s6      #       |           |      |      # s2 ---             ---> s4 ---> t4 ---> s7      assert assert_equal(sequence._get_sorted_tasks(), [[task_2, task_1], [task_4, task_3]])        data_node_1 = DataNode(\"foo\", Scope.SCENARIO, \"s1\")      data_node_2 = DataNode(\"bar\", Scope.SCENARIO, \"s2\")      data_node_4 = DataNode(\"qux\", Scope.SCENARIO, \"s4\")      data_node_5 = DataNode(\"quux\", Scope.SCENARIO, \"s5\")      data_node_6 = DataNode(\"quuz\", Scope.SCENARIO, \"s6\")      data_node_7 = DataNode(\"corge\", Scope.SCENARIO, \"s7\")      task_1 = Task(          \"grault\",          {},          print,          [data_node_1, data_node_2],          [data_node_4],          TaskId(\"t1\"),      )      task_2 = Task(\"garply\", {}, print, [data_node_6], [data_node_5], TaskId(\"t2\"))      task_3 = Task(\"waldo\", {}, print, [data_node_5, data_node_4], id=TaskId(\"t3\"))      task_4 = Task(\"fred\", {}, print, [data_node_4], [data_node_7], TaskId(\"t4\"))      sequence = Sequence({}, [task_4, task_2, task_1, task_3], SequenceId(\"p1\"))      # s1 ---      s6 ---> t2 ---> s5      #       |                     |      #       |---> t1 ---|      -----> t3      #       |           |      |      # s2 ---             ---> s4 ---> t4 ---> s7      assert assert_equal(sequence._get_sorted_tasks(), [[task_2, task_1], [task_4, task_3]])        data_node_1 = DataNode(\"foo\", Scope.SCENARIO, \"s1\")      data_node_2 = DataNode(\"bar\", Scope.SCENARIO, \"s2\")      data_node_4 = DataNode(\"qux\", Scope.SCENARIO, \"s4\")      data_node_5 = DataNode(\"quux\", Scope.SCENARIO, \"s5\")      data_node_6 = DataNode(\"quuz\", Scope.SCENARIO, \"s6\")      data_node_7 = DataNode(\"corge\", Scope.SCENARIO, \"s7\")      task_1 = Task(          \"grault\",          {},          print,          [data_node_1, data_node_2],          [data_node_4],          TaskId(\"t1\"),      )      task_2 = Task(\"garply\", {}, print, output=[data_node_5], id=TaskId(\"t2\"))      task_3 = Task(\"waldo\", {}, print, [data_node_5, data_node_4], None, id=TaskId(\"t3\"))      task_4 = Task(\"fred\", {}, print, [data_node_4], [data_node_7], TaskId(\"t4\"))      sequence = Sequence({}, [task_4, task_2, task_1, task_3], SequenceId(\"p1\"))      # s1 ---              t2 ---> s5      #       |                     |      #       |---> t1 ---|      -----> t3      #       |           |      |      # s2 ---             ---> s4 ---> t4 ---> s7      assert assert_equal(sequence._get_sorted_tasks(), [[task_2, task_1], [task_4, task_3]])        data_node_1 = DataNode(\"foo\", Scope.SCENARIO, \"s1\")      data_node_2 = DataNode(\"bar\", Scope.SCENARIO, \"s2\")      data_node_4 = DataNode(\"qux\", Scope.SCENARIO, \"s4\")      data_node_5 = DataNode(\"quux\", Scope.SCENARIO, \"s5\")      data_node_6 = DataNode(\"quuz\", Scope.SCENARIO, \"s6\")      data_node_7 = DataNode(\"corge\", Scope.SCENARIO, \"s7\")      data_node_8 = DataNode(\"hugh\", Scope.SCENARIO, \"s8\")        task_1 = Task(          \"grault\",          {},          print,          [data_node_1, data_node_2],          [data_node_4],          TaskId(\"t1\"),      )      task_2 = Task(\"garply\", {}, print, output=[data_node_5], id=TaskId(\"t2\"))      task_3 = Task(\"waldo\", {}, print, [data_node_4], None, id=TaskId(\"t3\"))      task_4 = Task(\"fred\", {}, print, [data_node_4], [data_node_7], TaskId(\"t4\"))      task_5 = Task(\"bob\", {}, print, [data_node_8], None, TaskId(\"t5\"))      sequence = Sequence({}, [task_5, task_4, task_2, task_1, task_3], SequenceId(\"p1\"))      # s1 ---      #       |      #       |---> t1 ---|      -----> t3      #       |           |      |      # s2 ---             ---> s4 ---> t4 ---> s7      # t2 ---> s5      # s8 ---> t5      assert assert_equal(sequence._get_sorted_tasks(), [[task_5, task_2, task_1], [task_4, task_3]])      def test_get_inputs():      data_node_1 = DataNode(\"foo\", Scope.SCENARIO, \"s1\")      data_node_2 = DataNode(\"bar\", Scope.SCENARIO, \"s2\")      data_node_3 = DataNode(\"baz\", Scope.SCENARIO, \"s3\")      data_node_4 = DataNode(\"qux\", Scope.SCENARIO, \"s4\")      data_node_5 = DataNode(\"quux\", Scope.SCENARIO, \"s5\")      data_node_6 = DataNode(\"quuz\", Scope.SCENARIO, \"s6\")      data_node_7 = DataNode(\"corge\", Scope.SCENARIO, \"s7\")      task_1 = Task(\"grault\", {}, print, [data_node_1, data_node_2], [data_node_3, data_node_4], TaskId(\"t1\"))      task_2 = Task(\"garply\", {}, print, [data_node_3], [data_node_5], TaskId(\"t2\"))      task_3 = Task(\"waldo\", {}, print, [data_node_5, data_node_4], [data_node_6], TaskId(\"t3\"))      task_4 = Task(\"fred\", {}, print, [data_node_4], [data_node_7], TaskId(\"t4\"))      sequence = Sequence({}, [task_4, task_2, task_1, task_3], SequenceId(\"p1\"))      # s1 ---             ---> s3 ---> t2 ---> s5 ----      #       |           |                           |      #       |---> t1 ---|      -------------------------> t3 ---> s6      #       |           |      |      # s2 ---             ---> s4 ---> t4 ---> s7      assert sequence.get_inputs() == {data_node_1, data_node_2}      assert sequence.get_outputs() == {data_node_6, data_node_7}      assert sequence.get_intermediate() == {data_node_3, data_node_4, data_node_5}        data_node_1 = DataNode(\"foo\", Scope.SCENARIO, \"s1\")      data_node_2 = DataNode(\"bar\", Scope.SCENARIO, \"s2\")      data_node_4 = DataNode(\"qux\", Scope.SCENARIO, \"s4\")      data_node_5 = DataNode(\"quux\", Scope.SCENARIO, \"s5\")      data_node_6 = DataNode(\"quuz\", Scope.SCENARIO, \"s6\")      data_node_7 = DataNode(\"corge\", Scope.SCENARIO, \"s7\")      task_1 = Task(\"grault\", {}, print, [data_node_1, data_node_2], [data_node_4], TaskId(\"t1\"))      task_2 = Task(\"garply\", {}, print, None, [data_node_5], TaskId(\"t2\"))      task_3 = Task(\"waldo\", {}, print, [data_node_5, data_node_4], [data_node_6], TaskId(\"t3\"))      task_4 = Task(\"fred\", {}, print, [data_node_4], [data_node_7], TaskId(\"t4\"))      sequence = Sequence({}, [task_4, task_2, task_1, task_3], SequenceId(\"p1\"))      # s1 ---      t2 ---> s5 ------      #       |                     |      #       |---> t1 ---|      -----> t3 ---> s6      #       |           |      |      # s2 ---             ---> s4 ---> t4 ---> s7      assert sequence.get_inputs() == {data_node_1, data_node_2}      assert sequence.get_outputs() == {data_node_6, data_node_7}      assert sequence.get_intermediate() == {data_node_4, data_node_5}        data_node_1 = DataNode(\"foo\", Scope.SCENARIO, \"s1\")      data_node_2 = DataNode(\"bar\", Scope.SCENARIO, \"s2\")      data_node_4 = DataNode(\"qux\", Scope.SCENARIO, \"s4\")      data_node_5 = DataNode(\"quux\", Scope.SCENARIO, \"s5\")      data_node_6 = DataNode(\"quuz\", Scope.SCENARIO, \"s6\")      data_node_7 = DataNode(\"corge\", Scope.SCENARIO, \"s7\")      task_1 = Task(\"grault\", {}, print, [data_node_1, data_node_2], [data_node_4], TaskId(\"t1\"))      task_2 = Task(\"garply\", {}, print, [data_node_6], [data_node_5], TaskId(\"t2\"))      task_3 = Task(\"waldo\", {}, print, [data_node_5, data_node_4], id=TaskId(\"t3\"))      task_4 = Task(\"fred\", {}, print, [data_node_4], [data_node_7], TaskId(\"t4\"))      sequence = Sequence({}, [task_4, task_2, task_1, task_3], SequenceId(\"p1\"))      # s1 ---      s6 ---> t2 ---> s5      #       |                     |      #       |---> t1 ---|      -----> t3      #       |           |      |      # s2 ---             ---> s4 ---> t4 ---> s7      assert sequence.get_inputs() == {data_node_1, data_node_2, data_node_6}      assert sequence.get_outputs() == {data_node_7}      assert sequence.get_intermediate() == {data_node_4, data_node_5}        data_node_1 = DataNode(\"foo\", Scope.SCENARIO, \"s1\")      data_node_2 = DataNode(\"bar\", Scope.SCENARIO, \"s2\")      data_node_4 = DataNode(\"qux\", Scope.SCENARIO, \"s4\")      data_node_5 = DataNode(\"quux\", Scope.SCENARIO, \"s5\")      data_node_6 = DataNode(\"quuz\", Scope.SCENARIO, \"s6\")      data_node_7 = DataNode(\"corge\", Scope.SCENARIO, \"s7\")      data_node_8 = DataNode(\"hugh\", Scope.SCENARIO, \"s8\")      task_1 = Task(\"grault\", {}, print, [data_node_1, data_node_2], [data_node_4], TaskId(\"t1\"))      task_2 = Task(\"garply\", {}, print, output=[data_node_5], id=TaskId(\"t2\"))      task_3 = Task(\"waldo\", {}, print, [data_node_4], None, id=TaskId(\"t3\"))      task_4 = Task(\"fred\", {}, print, [data_node_4, data_node_6], [data_node_7], TaskId(\"t4\"))      task_5 = Task(\"bob\", {}, print, [data_node_8], None, TaskId(\"t5\"))      sequence = Sequence({}, [task_5, task_4, task_2, task_1, task_3], SequenceId(\"p1\"))      # s1 ---      #       |      #       |---> t1 ---|      -----> t3      #       |           |      |      # s2 ---             ---> s4 ---> t4 ---> s7      # t2 ---> s5                   |      # s8 ---> t5              s6 --|      assert sequence.get_inputs() == {data_node_1, data_node_2, data_node_8, data_node_6}      assert sequence.get_outputs() == {data_node_5, data_node_7}      assert sequence.get_intermediate() == {data_node_4}      def test_is_ready_to_run():      data_node_1 = PickleDataNode(\"foo\", Scope.SCENARIO, \"s1\", properties={\"default_data\": 1})      data_node_2 = PickleDataNode(\"bar\", Scope.SCENARIO, \"s2\", properties={\"default_data\": 2})      data_node_4 = PickleDataNode(\"qux\", Scope.SCENARIO, \"s4\", properties={\"default_data\": 4})      data_node_5 = PickleDataNode(\"quux\", Scope.SCENARIO, \"s5\", properties={\"default_data\": 5})      data_node_6 = PickleDataNode(\"quuz\", Scope.SCENARIO, \"s6\", properties={\"default_data\": 6})      data_node_7 = PickleDataNode(\"corge\", Scope.SCENARIO, \"s7\", properties={\"default_data\": 7})      task_1 = Task(\"grault\", {}, print, [data_node_1, data_node_2], [data_node_4], TaskId(\"t1\"))      task_2 = Task(\"garply\", {}, print, [data_node_6], [data_node_5], TaskId(\"t2\"))      task_3 = Task(\"waldo\", {}, print, [data_node_5, data_node_4], id=TaskId(\"t3\"))      task_4 = Task(\"fred\", {}, print, [data_node_4], [data_node_7], TaskId(\"t4\"))      sequence = Sequence({}, [task_4, task_2, task_1, task_3], SequenceId(\"p1\"))      # s1 ---      s6 ---> t2 ---> s5      #       |                     |      #       |---> t1 ---|      -----> t3      #       |           |      |      # s2 ---             ---> s4 ---> t4 ---> s7        data_manager = _DataManagerFactory._build_manager()      for dn in [data_node_1, data_node_2, data_node_4, data_node_5, data_node_6, data_node_7]:          data_manager._set(dn)        assert sequence.is_ready_to_run()        data_node_1.edit_in_progress = True      assert not sequence.is_ready_to_run()        data_node_2.edit_in_progress = True      data_node_6.edit_in_progress = True      assert not sequence.is_ready_to_run()        data_node_1.edit_in_progress = False      data_node_2.edit_in_progress = False      data_node_6.edit_in_progress = False      assert sequence.is_ready_to_run()      def test_data_nodes_being_edited():      data_node_1 = PickleDataNode(\"foo\", Scope.SCENARIO, \"s1\", properties={\"default_data\": 1})      data_node_2 = PickleDataNode(\"bar\", Scope.SCENARIO, \"s2\", properties={\"default_data\": 2})      data_node_4 = PickleDataNode(\"qux\", Scope.SCENARIO, \"s4\", properties={\"default_data\": 4})      data_node_5 = PickleDataNode(\"quux\", Scope.SCENARIO, \"s5\", properties={\"default_data\": 5})      data_node_6 = PickleDataNode(\"quuz\", Scope.SCENARIO, \"s6\", properties={\"default_data\": 6})      data_node_7 = PickleDataNode(\"corge\", Scope.SCENARIO, \"s7\", properties={\"default_data\": 7})      task_1 = Task(\"grault\", {}, print, [data_node_1, data_node_2], [data_node_4], TaskId(\"t1\"))      task_2 = Task(\"garply\", {}, print, [data_node_6], [data_node_5], TaskId(\"t2\"))      task_3 = Task(\"waldo\", {}, print, [data_node_5, data_node_4], id=TaskId(\"t3\"))      task_4 = Task(\"fred\", {}, print, [data_node_4], [data_node_7], TaskId(\"t4\"))      sequence = Sequence({}, [task_4, task_2, task_1, task_3], SequenceId(\"p1\"))      # s1 ---      s6 ---> t2 ---> s5      #       |                     |      #       |---> t1 ---|      -----> t3      #       |           |      |      # s2 ---             ---> s4 ---> t4 ---> s7        data_manager = _DataManagerFactory._build_manager()      for dn in [data_node_1, data_node_2, data_node_4, data_node_5, data_node_6, data_node_7]:          data_manager._set(dn)        assert len(sequence.data_nodes_being_edited()) == 0      assert sequence.data_nodes_being_edited() == set()        data_node_1.edit_in_progress = True      assert len(sequence.data_nodes_being_edited()) == 1      assert sequence.data_nodes_being_edited() == {data_node_1}        data_node_2.edit_in_progress = True      data_node_6.edit_in_progress = True      assert len(sequence.data_nodes_being_edited()) == 3      assert sequence.data_nodes_being_edited() == {data_node_1, data_node_2, data_node_6}        data_node_4.edit_in_progress = True      data_node_5.edit_in_progress = True      assert len(sequence.data_nodes_being_edited()) == 5      assert sequence.data_nodes_being_edited() == {data_node_1, data_node_2, data_node_4, data_node_5, data_node_6}        data_node_1.edit_in_progress = False      data_node_2.edit_in_progress = False      data_node_6.edit_in_progress = False      assert len(sequence.data_nodes_being_edited()) == 2      assert sequence.data_nodes_being_edited() == {data_node_4, data_node_5}        data_node_4.edit_in_progress = False      data_node_5.edit_in_progress = False      data_node_7.edit_in_progress = True      assert len(sequence.data_nodes_being_edited()) == 1      assert sequence.data_nodes_being_edited() == {data_node_7}        data_node_7.edit_in_progress = False      assert len(sequence.data_nodes_being_edited()) == 0      assert sequence.data_nodes_being_edited() == set()      def test_get_tasks():      task_1 = Task(\"grault\", {}, print, id=TaskId(\"t1\"))      task_2 = Task(\"garply\", {}, print, id=TaskId(\"t2\"))      task_3 = Task(\"waldo\", {}, print, id=TaskId(\"t3\"))      sequence_1 = Sequence({}, [task_1, task_2, task_3], SequenceId(\"p1\"))      assert sequence_1.tasks == {\"grault\": task_1, \"garply\": task_2, \"waldo\": task_3}      def test_get_set_of_tasks():      task_1 = Task(\"grault\", {}, print, id=TaskId(\"t1\"))      task_2 = Task(\"garply\", {}, print, id=TaskId(\"t2\"))      task_3 = Task(\"waldo\", {}, print, id=TaskId(\"t3\"))      sequence_1 = Sequence({}, [task_1, task_2, task_3], SequenceId(\"p1\"))      assert sequence_1._get_set_of_tasks() == {task_1, task_2, task_3}      def test_auto_set_and_reload(task):      tmp_task = Task(\"tmp_task_config_id\", {}, print, list(task.output.values()), [], TaskId(\"tmp_task_id\"))      scenario = Scenario(\"scenario\", [task, tmp_task], {}, sequences={\"foo\": {}})        _TaskManager._set(task)      _TaskManager._set(tmp_task)      _ScenarioManager._set(scenario)        sequence_1 = scenario.sequences[\"foo\"]      sequence_2 = _SequenceManager._get(sequence_1)        # auto set & reload on tasks attribute      assert len(sequence_1.tasks) == 0      assert len(sequence_2.tasks) == 0      sequence_1.tasks = [tmp_task]      assert len(sequence_1.tasks) == 1      assert sequence_1.tasks[tmp_task.config_id].id == tmp_task.id      assert len(sequence_2.tasks) == 1      assert sequence_2.tasks[tmp_task.config_id].id == tmp_task.id      sequence_2.tasks = [task]      assert len(sequence_1.tasks) == 1      assert sequence_1.tasks[task.config_id].id == task.id      assert len(sequence_2.tasks) == 1      assert sequence_2.tasks[task.config_id].id == task.id        assert sequence_1.owner_id == scenario.id      assert sequence_2.owner_id == scenario.id        # auto set & reload on subscribers attribute      assert len(sequence_1.subscribers) == 0      assert len(sequence_2.subscribers) == 0      sequence_1.subscribers.append(print)      assert len(sequence_1.subscribers) == 1      assert len(sequence_2.subscribers) == 1      sequence_2.subscribers.append(print)      assert len(sequence_1.subscribers) == 2      assert len(sequence_2.subscribers) == 2        sequence_1.subscribers.clear()      assert len(sequence_1.subscribers) == 0      assert len(sequence_2.subscribers) == 0        sequence_1.subscribers.extend([print, map])      assert len(sequence_1.subscribers) == 2      assert len(sequence_2.subscribers) == 2        sequence_1.subscribers.remove(_Subscriber(print, []))      assert len(sequence_1.subscribers) == 1      assert len(sequence_2.subscribers) == 1        sequence_2.subscribers.clear()      assert len(sequence_1.subscribers) == 0      assert len(sequence_2.subscribers) == 0        sequence_1.subscribers + print + len      assert len(sequence_1.subscribers) == 2      assert len(sequence_2.subscribers) == 2        sequence_1.subscribers = []      assert len(sequence_1.subscribers) == 0      assert len(sequence_2.subscribers) == 0        # auto set & reload on properties attribute      assert sequence_1.properties == {\"name\": \"foo\"}      assert sequence_2.properties == {\"name\": \"foo\"}      sequence_1.properties[\"qux\"] = 4      assert sequence_1.properties[\"qux\"] == 4      assert sequence_2.properties[\"qux\"] == 4      sequence_2.properties[\"qux\"] = 5      assert sequence_1.properties[\"qux\"] == 5      assert sequence_2.properties[\"qux\"] == 5        sequence_1.properties[\"temp_key_1\"] = \"temp_value_1\"      sequence_1.properties[\"temp_key_2\"] = \"temp_value_2\"      assert sequence_1.properties == {          \"qux\": 5,          \"name\": \"foo\",          \"temp_key_1\": \"temp_value_1\",          \"temp_key_2\": \"temp_value_2\",      }      assert sequence_2.properties == {          \"qux\": 5,          \"name\": \"foo\",          \"temp_key_1\": \"temp_value_1\",          \"temp_key_2\": \"temp_value_2\",      }      sequence_1.properties.pop(\"temp_key_1\")      assert \"temp_key_1\" not in sequence_1.properties.keys()      assert \"temp_key_1\" not in sequence_1.properties.keys()      assert sequence_1.properties == {          \"qux\": 5,          \"name\": \"foo\",          \"temp_key_2\": \"temp_value_2\",      }      assert sequence_2.properties == {          \"qux\": 5,          \"name\": \"foo\",          \"temp_key_2\": \"temp_value_2\",      }      sequence_2.properties.pop(\"temp_key_2\")      assert sequence_1.properties == {\"name\": \"foo\", \"qux\": 5}      assert sequence_2.properties == {\"name\": \"foo\", \"qux\": 5}      assert \"temp_key_2\" not in sequence_1.properties.keys()      assert \"temp_key_2\" not in sequence_2.properties.keys()        sequence_1.properties[\"temp_key_3\"] = 0      assert sequence_1.properties == {\"name\": \"foo\", \"qux\": 5, \"temp_key_3\": 0}      assert sequence_2.properties == {\"name\": \"foo\", \"qux\": 5, \"temp_key_3\": 0}      sequence_1.properties.update({\"temp_key_3\": 1})      assert sequence_1.properties == {\"name\": \"foo\", \"qux\": 5, \"temp_key_3\": 1}      assert sequence_2.properties == {\"name\": \"foo\", \"qux\": 5, \"temp_key_3\": 1}      sequence_1.properties.update(dict())      assert sequence_1.properties == {\"name\": \"foo\", \"qux\": 5, \"temp_key_3\": 1}      assert sequence_2.properties == {\"name\": \"foo\", \"qux\": 5, \"temp_key_3\": 1}      sequence_1.properties[\"temp_key_4\"] = 0      sequence_1.properties[\"temp_key_5\"] = 0        with sequence_1 as sequence:          assert len(sequence.tasks) == 1          assert sequence.tasks[task.config_id].id == task.id          assert len(sequence.subscribers) == 0          assert sequence._is_in_context          assert sequence.properties[\"qux\"] == 5          assert sequence.properties[\"temp_key_3\"] == 1          assert sequence.properties[\"temp_key_4\"] == 0          assert sequence.properties[\"temp_key_5\"] == 0            sequence.tasks = []          sequence.subscribers = [print]          sequence.properties[\"qux\"] = 9          sequence.properties.pop(\"temp_key_3\")          sequence.properties.pop(\"temp_key_4\")          sequence.properties.update({\"temp_key_4\": 1})          sequence.properties.update({\"temp_key_5\": 2})          sequence.properties.pop(\"temp_key_5\")          sequence.properties.update(dict())            assert len(sequence.tasks) == 1          assert sequence.tasks[task.config_id].id == task.id          assert len(sequence.subscribers) == 0          assert sequence._is_in_context          assert sequence.properties[\"qux\"] == 5          assert sequence.properties[\"temp_key_3\"] == 1          assert sequence.properties[\"temp_key_4\"] == 0          assert sequence.properties[\"temp_key_5\"] == 0        assert len(sequence_1.tasks) == 0      assert len(sequence_1.subscribers) == 1      assert not sequence_1._is_in_context      assert sequence_1.properties[\"qux\"] == 9      assert \"temp_key_3\" not in sequence_1.properties.keys()      assert sequence_1.properties[\"temp_key_4\"] == 1      assert \"temp_key_5\" not in sequence_1.properties.keys()      def test_get_parents(sequence):      with mock.patch(\"src.taipy.core.get_parents\") as mck:          sequence.get_parents()          mck.assert_called_once_with(sequence)      def test_subscribe_sequence():      with mock.patch(\"src.taipy.core.subscribe_sequence\") as mck:          sequence = Sequence({}, [], \"id\")          sequence.subscribe(None)          mck.assert_called_once_with(None, None, sequence)      def test_unsubscribe_sequence():      with mock.patch(\"src.taipy.core.unsubscribe_sequence\") as mck:          sequence = Sequence({}, [], \"id\")          sequence.unsubscribe(None)          mck.assert_called_once_with(None, None, sequence)      def test_submit_sequence():      with mock.patch(\"src.taipy.core.sequence._sequence_manager._SequenceManager._submit\") as mck:          sequence = Sequence({}, [], \"id\")          sequence.submit(None, False)          mck.assert_called_once_with(sequence, None, False, False, None) "}
{"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": "import pytest    from src.taipy.core._orchestrator._orchestrator_factory import _OrchestratorFactory  from src.taipy.core._version._version_manager import _VersionManager  from src.taipy.core.config.job_config import JobConfig  from src.taipy.core.data._data_manager import _DataManager  from src.taipy.core.data.in_memory import InMemoryDataNode  from src.taipy.core.job._job_manager import _JobManager  from src.taipy.core.scenario._scenario_manager import _ScenarioManager  from src.taipy.core.scenario.scenario import Scenario  from src.taipy.core.sequence._sequence_manager import _SequenceManager  from src.taipy.core.sequence.sequence_id import SequenceId  from src.taipy.core.task._task_manager import _TaskManager  from src.taipy.core.task.task import Task  from src.taipy.core.task.task_id import TaskId  from taipy.config.common.scope import Scope  from taipy.config.config import Config  from tests.core.conftest import init_managers      def test_set_and_get_sequence(init_sql_repo):      Config.configure_job_executions(mode=JobConfig._DEVELOPMENT_MODE)        init_managers()      _OrchestratorFactory._build_dispatcher()        input_dn = InMemoryDataNode(\"foo\", Scope.SCENARIO)      output_dn = InMemoryDataNode(\"foo\", Scope.SCENARIO)      task = Task(\"task\", {}, print, [input_dn], [output_dn], TaskId(\"task_id\"))        scenario = Scenario(\"scenario\", {task}, {}, set())      _ScenarioManager._set(scenario)        sequence_name_1 = \"p1\"      sequence_id_1 = SequenceId(f\"SEQUENCE_{sequence_name_1}_{scenario.id}\")      sequence_name_2 = \"p2\"      sequence_id_2 = SequenceId(f\"SEQUENCE_{sequence_name_2}_{scenario.id}\")        # No existing Sequence      assert _SequenceManager._get(sequence_id_1) is None      assert _SequenceManager._get(sequence_id_2) is None        scenario.add_sequences({sequence_name_1: []})      sequence_1 = scenario.sequences[sequence_name_1]        # Save one sequence. We expect to have only one sequence stored      _SequenceManager._set(sequence_1)      assert _SequenceManager._get(sequence_id_1).id == sequence_1.id      assert len(_SequenceManager._get(sequence_id_1).tasks) == 0      assert _SequenceManager._get(sequence_1).id == sequence_1.id      assert len(_SequenceManager._get(sequence_1).tasks) == 0      assert _SequenceManager._get(sequence_id_2) is None        # Save a second sequence. Now, we expect to have a total of two sequences stored      _TaskManager._set(task)      scenario.add_sequences({sequence_name_2: [task]})      sequence_2 = scenario.sequences[sequence_name_2]      assert _SequenceManager._get(sequence_id_1).id == sequence_1.id      assert len(_SequenceManager._get(sequence_id_1).tasks) == 0      assert _SequenceManager._get(sequence_1).id == sequence_1.id      assert len(_SequenceManager._get(sequence_1).tasks) == 0      assert _SequenceManager._get(sequence_id_2).id == sequence_2.id      assert len(_SequenceManager._get(sequence_id_2).tasks) == 1      assert _SequenceManager._get(sequence_2).id == sequence_2.id      assert len(_SequenceManager._get(sequence_2).tasks) == 1        # We save the first sequence again. We expect nothing to change      scenario.add_sequences({sequence_name_1: {}})      sequence_1 = scenario.sequences[sequence_name_1]      assert _SequenceManager._get(sequence_id_1).id == sequence_1.id      assert len(_SequenceManager._get(sequence_id_1).tasks) == 0      assert _SequenceManager._get(sequence_1).id == sequence_1.id      assert len(_SequenceManager._get(sequence_1).tasks) == 0      assert _SequenceManager._get(sequence_id_2).id == sequence_2.id      assert len(_SequenceManager._get(sequence_id_2).tasks) == 1      assert _SequenceManager._get(sequence_2).id == sequence_2.id      assert len(_SequenceManager._get(sequence_2).tasks) == 1        # We save a third sequence with same id as the first one.      # We expect the first sequence to be updated      scenario.add_sequences({sequence_name_1: [task]})      sequence_3 = scenario.sequences[sequence_name_1]      assert _SequenceManager._get(sequence_id_1).id == sequence_1.id      assert _SequenceManager._get(sequence_id_1).id == sequence_3.id      assert len(_SequenceManager._get(sequence_id_1).tasks) == 1      assert _SequenceManager._get(sequence_1).id == sequence_1.id      assert len(_SequenceManager._get(sequence_1).tasks) == 1      assert _SequenceManager._get(sequence_id_2).id == sequence_2.id      assert len(_SequenceManager._get(sequence_id_2).tasks) == 1      assert _SequenceManager._get(sequence_2).id == sequence_2.id      assert len(_SequenceManager._get(sequence_2).tasks) == 1      assert _TaskManager._get(task.id).id == task.id      def test_get_all_on_multiple_versions_environment(init_sql_repo):      init_managers()        # Create 5 sequences from Scenario with 2 versions each      for version in range(1, 3):          for i in range(5):              _ScenarioManager._set(                  Scenario(                      f\"config_id_{i+version}\",                      [],                      {},                      [],                      f\"SCENARIO_id_{i}_v{version}\",                      version=f\"{version}.0\",                      sequences={\"sequence\": {}},                  )              )        _VersionManager._set_experiment_version(\"1.0\")      assert len(_SequenceManager._get_all()) == 5      assert (          len(_SequenceManager._get_all_by(filters=[{\"version\": \"1.0\", \"id\": \"SEQUENCE_sequence_SCENARIO_id_1_v1\"}])) == 1      )      assert (          len(_SequenceManager._get_all_by(filters=[{\"version\": \"2.0\", \"id\": \"SEQUENCE_sequence_SCENARIO_id_1_v1\"}])) == 0      )        _VersionManager._set_experiment_version(\"2.0\")      assert len(_SequenceManager._get_all()) == 5      assert (          len(_SequenceManager._get_all_by(filters=[{\"version\": \"2.0\", \"id\": \"SEQUENCE_sequence_SCENARIO_id_1_v1\"}])) == 0      )      assert (          len(_SequenceManager._get_all_by(filters=[{\"version\": \"2.0\", \"id\": \"SEQUENCE_sequence_SCENARIO_id_1_v2\"}])) == 1      )        _VersionManager._set_development_version(\"1.0\")      assert len(_SequenceManager._get_all()) == 5      assert (          len(_SequenceManager._get_all_by(filters=[{\"version\": \"1.0\", \"id\": \"SEQUENCE_sequence_SCENARIO_id_1_v1\"}])) == 1      )      assert (          len(_SequenceManager._get_all_by(filters=[{\"version\": \"1.0\", \"id\": \"SEQUENCE_sequence_SCENARIO_id_1_v2\"}])) == 0      )        _VersionManager._set_development_version(\"2.0\")      assert len(_SequenceManager._get_all()) == 5      assert (          len(_SequenceManager._get_all_by(filters=[{\"version\": \"2.0\", \"id\": \"SEQUENCE_sequence_SCENARIO_id_1_v1\"}])) == 0      )      assert (          len(_SequenceManager._get_all_by(filters=[{\"version\": \"2.0\", \"id\": \"SEQUENCE_sequence_SCENARIO_id_1_v2\"}])) == 1      )      def mult_by_two(nb: int):      return nb * 2      def mult_by_3(nb: int):      return nb * 3      def test_get_or_create_data(init_sql_repo):      # only create intermediate data node once      Config.configure_job_executions(mode=JobConfig._DEVELOPMENT_MODE)        init_managers()        dn_config_1 = Config.configure_data_node(\"foo\", \"in_memory\", Scope.SCENARIO, default_data=1)      dn_config_2 = Config.configure_data_node(\"bar\", \"in_memory\", Scope.SCENARIO, default_data=0)      dn_config_6 = Config.configure_data_node(\"baz\", \"in_memory\", Scope.SCENARIO, default_data=0)        task_config_mult_by_two = Config.configure_task(\"mult_by_two\", mult_by_two, [dn_config_1], dn_config_2)      task_config_mult_by_3 = Config.configure_task(\"mult_by_3\", mult_by_3, [dn_config_2], dn_config_6)      # dn_1 ---> mult_by_two ---> dn_2 ---> mult_by_3 ---> dn_6      scenario_config = Config.configure_scenario(\"scenario\", [task_config_mult_by_two, task_config_mult_by_3])        _OrchestratorFactory._build_dispatcher()        assert len(_DataManager._get_all()) == 0      assert len(_TaskManager._get_all()) == 0        scenario = _ScenarioManager._create(scenario_config)      scenario.add_sequences({\"by_6\": list(scenario.tasks.values())})      sequence = scenario.sequences[\"by_6\"]        assert sequence.name == \"by_6\"        assert len(_DataManager._get_all()) == 3      assert len(_TaskManager._get_all()) == 2      assert len(sequence._get_sorted_tasks()) == 2      assert sequence.foo.read() == 1      assert sequence.bar.read() == 0      assert sequence.baz.read() == 0      assert sequence._get_sorted_tasks()[0][0].config_id == task_config_mult_by_two.id      assert sequence._get_sorted_tasks()[1][0].config_id == task_config_mult_by_3.id        _SequenceManager._submit(sequence.id)      assert sequence.foo.read() == 1      assert sequence.bar.read() == 2      assert sequence.baz.read() == 6        sequence.foo.write(\"new data value\")      assert sequence.foo.read() == \"new data value\"      assert sequence.bar.read() == 2      assert sequence.baz.read() == 6        sequence.bar.write(7)      assert sequence.foo.read() == \"new data value\"      assert sequence.bar.read() == 7      assert sequence.baz.read() == 6        with pytest.raises(AttributeError):          sequence.WRONG.write(7)      def test_hard_delete_one_single_sequence_with_scenario_data_nodes(init_sql_repo):      Config.configure_job_executions(mode=JobConfig._DEVELOPMENT_MODE)        init_managers()        dn_input_config = Config.configure_data_node(\"my_input\", \"in_memory\", scope=Scope.SCENARIO, default_data=\"testing\")      dn_output_config = Config.configure_data_node(\"my_output\", \"in_memory\", scope=Scope.SCENARIO)      task_config = Config.configure_task(\"task_config\", print, dn_input_config, dn_output_config)        _OrchestratorFactory._build_dispatcher()        tasks = _TaskManager._bulk_get_or_create([task_config])      scenario = Scenario(\"scenario\", set(tasks), {}, sequences={\"sequence\": {\"tasks\": tasks}})      _ScenarioManager._set(scenario)        sequence = scenario.sequences[\"sequence\"]      sequence.submit()        assert len(_ScenarioManager._get_all()) == 1      assert len(_SequenceManager._get_all()) == 1      assert len(_TaskManager._get_all()) == 1      assert len(_DataManager._get_all()) == 2      assert len(_JobManager._get_all()) == 1      _SequenceManager._hard_delete(sequence.id)      assert len(_ScenarioManager._get_all()) == 1      assert len(_SequenceManager._get_all()) == 0      assert len(_TaskManager._get_all()) == 1      assert len(_DataManager._get_all()) == 2      assert len(_JobManager._get_all()) == 1      def test_hard_delete_one_single_sequence_with_cycle_data_nodes(init_sql_repo):      Config.configure_job_executions(mode=JobConfig._DEVELOPMENT_MODE)        init_managers()        dn_input_config = Config.configure_data_node(\"my_input\", \"in_memory\", scope=Scope.CYCLE, default_data=\"testing\")      dn_output_config = Config.configure_data_node(\"my_output\", \"in_memory\", scope=Scope.CYCLE)      task_config = Config.configure_task(\"task_config\", print, dn_input_config, dn_output_config)        _OrchestratorFactory._build_dispatcher()        tasks = _TaskManager._bulk_get_or_create([task_config])      scenario = Scenario(\"scenario\", tasks, {}, sequences={\"sequence\": {\"tasks\": tasks}})      _ScenarioManager._set(scenario)        sequence = scenario.sequences[\"sequence\"]      sequence.submit()        assert len(_ScenarioManager._get_all()) == 1      assert len(_SequenceManager._get_all()) == 1      assert len(_TaskManager._get_all()) == 1      assert len(_DataManager._get_all()) == 2      assert len(_JobManager._get_all()) == 1      _SequenceManager._hard_delete(sequence.id)      assert len(_ScenarioManager._get_all()) == 1      assert len(_SequenceManager._get_all()) == 0      assert len(_TaskManager._get_all()) == 1      assert len(_DataManager._get_all()) == 2      assert len(_JobManager._get_all()) == 1      def test_hard_delete_shared_entities(init_sql_repo):      Config.configure_job_executions(mode=JobConfig._DEVELOPMENT_MODE)        init_managers()        input_dn = Config.configure_data_node(\"my_input\", \"in_memory\", scope=Scope.SCENARIO, default_data=\"testing\")      intermediate_dn = Config.configure_data_node(\"my_inter\", \"in_memory\", scope=Scope.GLOBAL, default_data=\"testing\")      output_dn = Config.configure_data_node(\"my_output\", \"in_memory\", scope=Scope.GLOBAL, default_data=\"testing\")      task_1 = Config.configure_task(\"task_1\", print, input_dn, intermediate_dn)      task_2 = Config.configure_task(\"task_2\", print, intermediate_dn, output_dn)        _OrchestratorFactory._build_dispatcher()        tasks_scenario_1 = _TaskManager._bulk_get_or_create([task_1, task_2], scenario_id=\"scenario_id_1\")      tasks_scenario_2 = _TaskManager._bulk_get_or_create([task_1, task_2], scenario_id=\"scenario_id_2\")        scenario_1 = Scenario(\"scenario_1\", tasks_scenario_1, {}, sequences={\"sequence\": {\"tasks\": tasks_scenario_1}})      scenario_2 = Scenario(\"scenario_2\", tasks_scenario_2, {}, sequences={\"sequence\": {\"tasks\": tasks_scenario_2}})      _ScenarioManager._set(scenario_1)      _ScenarioManager._set(scenario_2)      sequence_1 = scenario_1.sequences[\"sequence\"]      sequence_2 = scenario_2.sequences[\"sequence\"]        _SequenceManager._submit(sequence_1.id)      _SequenceManager._submit(sequence_2.id)        assert len(_ScenarioManager._get_all()) == 2      assert len(_SequenceManager._get_all()) == 2      assert len(_TaskManager._get_all()) == 3      assert len(_DataManager._get_all()) == 4      assert len(_JobManager._get_all()) == 4      _SequenceManager._hard_delete(sequence_1.id)      assert len(_ScenarioManager._get_all()) == 2      assert len(_SequenceManager._get_all()) == 1      assert len(_TaskManager._get_all()) == 3      assert len(_DataManager._get_all()) == 4      assert len(_JobManager._get_all()) == 4 "}
{"text": "import json  from pathlib import Path  from typing import Callable, Iterable, Optional  from unittest import mock  from unittest.mock import ANY    import pytest    from src.taipy.core._orchestrator._orchestrator import _Orchestrator  from src.taipy.core._orchestrator._orchestrator_factory import _OrchestratorFactory  from src.taipy.core._version._version_manager import _VersionManager  from src.taipy.core.common import _utils  from src.taipy.core.common._utils import _Subscriber  from src.taipy.core.config.job_config import JobConfig  from src.taipy.core.data._data_manager import _DataManager  from src.taipy.core.data.in_memory import InMemoryDataNode  from src.taipy.core.exceptions.exceptions import (      InvalidSequenceId,      ModelNotFound,      NonExistingSequence,      NonExistingTask,      SequenceBelongsToNonExistingScenario,  )  from src.taipy.core.job._job_manager import _JobManager  from src.taipy.core.scenario._scenario_manager import _ScenarioManager  from src.taipy.core.scenario.scenario import Scenario  from src.taipy.core.sequence._sequence_manager import _SequenceManager  from src.taipy.core.sequence._sequence_manager_factory import _SequenceManagerFactory  from src.taipy.core.sequence.sequence import Sequence  from src.taipy.core.sequence.sequence_id import SequenceId  from src.taipy.core.task._task_manager import _TaskManager  from src.taipy.core.task.task import Task  from src.taipy.core.task.task_id import TaskId  from taipy.config.common.scope import Scope  from taipy.config.config import Config  from tests.core.utils.NotifyMock import NotifyMock      def test_breakdown_sequence_id():      with pytest.raises(InvalidSequenceId):          _SequenceManager._breakdown_sequence_id(\"scenario_id\")      with pytest.raises(InvalidSequenceId):          _SequenceManager._breakdown_sequence_id(\"sequence_id\")      with pytest.raises(InvalidSequenceId):          _SequenceManager._breakdown_sequence_id(\"SEQUENCE_sequence_id\")      with pytest.raises(InvalidSequenceId):          _SequenceManager._breakdown_sequence_id(\"SCENARIO_scenario_id\")      with pytest.raises(InvalidSequenceId):          _SequenceManager._breakdown_sequence_id(\"sequence_SCENARIO_scenario_id\")      with pytest.raises(InvalidSequenceId):          _SequenceManager._breakdown_sequence_id(\"SEQUENCE_sequence_scenario_id\")      sequence_name, scenario_id = _SequenceManager._breakdown_sequence_id(\"SEQUENCE_sequence_SCENARIO_scenario\")      assert sequence_name == \"sequence\" and scenario_id == \"SCENARIO_scenario\"      sequence_name, scenario_id = _SequenceManager._breakdown_sequence_id(\"SEQUENCEsequenceSCENARIO_scenario\")      assert sequence_name == \"sequence\" and scenario_id == \"SCENARIO_scenario\"      def test_raise_sequence_does_not_belong_to_scenario():      with pytest.raises(SequenceBelongsToNonExistingScenario):          sequence = Sequence({\"name\": \"sequence_name\"}, [], \"SEQUENCE_sequence_name_SCENARIO_scenario_id\")          _SequenceManager._set(sequence)      def __init():      Config.configure_job_executions(mode=JobConfig._DEVELOPMENT_MODE)      _OrchestratorFactory._build_dispatcher()      input_dn = InMemoryDataNode(\"foo\", Scope.SCENARIO)      output_dn = InMemoryDataNode(\"foo\", Scope.SCENARIO)      task = Task(\"task\", {}, print, [input_dn], [output_dn], TaskId(\"task_id\"))      scenario = Scenario(\"scenario\", set([task]), {}, set())      _ScenarioManager._set(scenario)      return scenario, task      def test_set_and_get_sequence_no_existing_sequence():      scenario, task = __init()      sequence_name_1 = \"p1\"      sequence_id_1 = SequenceId(f\"SEQUENCE_{sequence_name_1}_{scenario.id}\")      sequence_name_2 = \"p2\"      sequence_id_2 = SequenceId(f\"SEQUENCE_{sequence_name_2}_{scenario.id}\")        assert _SequenceManager._get(sequence_id_1) is None      assert _SequenceManager._get(sequence_id_2) is None      assert _SequenceManager._get(\"sequence\") is None      def test_set_and_get():      scenario, task = __init()      sequence_name_1 = \"p1\"      sequence_id_1 = SequenceId(f\"SEQUENCE_{sequence_name_1}_{scenario.id}\")      sequence_name_2 = \"p2\"      sequence_id_2 = SequenceId(f\"SEQUENCE_{sequence_name_2}_{scenario.id}\")        scenario.add_sequences({sequence_name_1: []})      sequence_1 = scenario.sequences[sequence_name_1]      assert _SequenceManager._get(sequence_id_1).id == sequence_1.id      assert len(_SequenceManager._get(sequence_id_1).tasks) == 0      assert _SequenceManager._get(sequence_1).id == sequence_1.id      assert len(_SequenceManager._get(sequence_1).tasks) == 0      assert _SequenceManager._get(sequence_id_2) is None        # Save a second sequence. Now, we expect to have a total of two sequences stored      _TaskManager._set(task)      scenario.add_sequences({sequence_name_2: [task]})      sequence_2 = scenario.sequences[sequence_name_2]      assert _SequenceManager._get(sequence_id_1).id == sequence_1.id      assert len(_SequenceManager._get(sequence_id_1).tasks) == 0      assert _SequenceManager._get(sequence_1).id == sequence_1.id      assert len(_SequenceManager._get(sequence_1).tasks) == 0      assert _SequenceManager._get(sequence_id_2).id == sequence_2.id      assert len(_SequenceManager._get(sequence_id_2).tasks) == 1      assert _SequenceManager._get(sequence_2).id == sequence_2.id      assert len(_SequenceManager._get(sequence_2).tasks) == 1      assert _TaskManager._get(task.id).id == task.id        # We save the first sequence again. We expect nothing to change      scenario.add_sequence(sequence_name_1, [])      sequence_1 = scenario.sequences[sequence_name_1]      assert _SequenceManager._get(sequence_id_1).id == sequence_1.id      assert len(_SequenceManager._get(sequence_id_1).tasks) == 0      assert _SequenceManager._get(sequence_1).id == sequence_1.id      assert len(_SequenceManager._get(sequence_1).tasks) == 0      assert _SequenceManager._get(sequence_id_2).id == sequence_2.id      assert len(_SequenceManager._get(sequence_id_2).tasks) == 1      assert _SequenceManager._get(sequence_2).id == sequence_2.id      assert len(_SequenceManager._get(sequence_2).tasks) == 1      assert _TaskManager._get(task.id).id == task.id        # We save a third sequence with same name as the first one.      # We expect the first sequence to be updated      scenario.add_sequences({sequence_name_1: [task]})      sequence_3 = scenario.sequences[sequence_name_1]      assert _SequenceManager._get(sequence_id_1).id == sequence_1.id      assert _SequenceManager._get(sequence_id_1).id == sequence_3.id      assert len(_SequenceManager._get(sequence_id_1).tasks) == 1      assert _SequenceManager._get(sequence_1).id == sequence_1.id      assert len(_SequenceManager._get(sequence_1).tasks) == 1      assert _SequenceManager._get(sequence_id_2).id == sequence_2.id      assert len(_SequenceManager._get(sequence_id_2).tasks) == 1      assert _SequenceManager._get(sequence_2).id == sequence_2.id      assert len(_SequenceManager._get(sequence_2).tasks) == 1      assert _TaskManager._get(task.id).id == task.id      def test_get_all_on_multiple_versions_environment():      # Create 5 sequences from Scenario with 2 versions each      for version in range(1, 3):          for i in range(5):              _ScenarioManager._set(                  Scenario(                      f\"config_id_{i+version}\",                      [],                      {},                      [],                      f\"SCENARIO_id_{i}_v{version}\",                      version=f\"{version}.0\",                      sequences={\"sequence\": {}},                  )              )        _VersionManager._set_experiment_version(\"1.0\")      assert len(_SequenceManager._get_all()) == 5      assert (          len(_SequenceManager._get_all_by(filters=[{\"version\": \"1.0\", \"id\": \"SEQUENCE_sequence_SCENARIO_id_1_v1\"}])) == 1      )      assert (          len(_SequenceManager._get_all_by(filters=[{\"version\": \"2.0\", \"id\": \"SEQUENCE_sequence_SCENARIO_id_1_v1\"}])) == 0      )        _VersionManager._set_experiment_version(\"2.0\")      assert len(_SequenceManager._get_all()) == 5      assert (          len(_SequenceManager._get_all_by(filters=[{\"version\": \"2.0\", \"id\": \"SEQUENCE_sequence_SCENARIO_id_1_v1\"}])) == 0      )      assert (          len(_SequenceManager._get_all_by(filters=[{\"version\": \"2.0\", \"id\": \"SEQUENCE_sequence_SCENARIO_id_1_v2\"}])) == 1      )        _VersionManager._set_development_version(\"1.0\")      assert len(_SequenceManager._get_all()) == 5      assert (          len(_SequenceManager._get_all_by(filters=[{\"version\": \"1.0\", \"id\": \"SEQUENCE_sequence_SCENARIO_id_1_v1\"}])) == 1      )      assert (          len(_SequenceManager._get_all_by(filters=[{\"version\": \"1.0\", \"id\": \"SEQUENCE_sequence_SCENARIO_id_1_v2\"}])) == 0      )        _VersionManager._set_development_version(\"2.0\")      assert len(_SequenceManager._get_all()) == 5      assert (          len(_SequenceManager._get_all_by(filters=[{\"version\": \"2.0\", \"id\": \"SEQUENCE_sequence_SCENARIO_id_1_v1\"}])) == 0      )      assert (          len(_SequenceManager._get_all_by(filters=[{\"version\": \"2.0\", \"id\": \"SEQUENCE_sequence_SCENARIO_id_1_v2\"}])) == 1      )      def test_is_submittable():      dn = InMemoryDataNode(\"dn\", Scope.SCENARIO, properties={\"default_data\": 10})      task = Task(\"task\", {}, print, [dn])      scenario = Scenario(\"scenario\", set([task]), {}, set())      _ScenarioManager._set(scenario)        scenario.add_sequences({\"sequence\": list([task])})      sequence = scenario.sequences[\"sequence\"]        assert len(_SequenceManager._get_all()) == 1      assert _SequenceManager._is_submittable(sequence)      assert _SequenceManager._is_submittable(sequence.id)      assert not _SequenceManager._is_submittable(\"Sequence_temp\")      assert not _SequenceManager._is_submittable(\"SEQUENCE_temp_SCENARIO_scenario\")        scenario.dn.edit_in_progress = True      assert not _SequenceManager._is_submittable(sequence)      assert not _SequenceManager._is_submittable(sequence.id)        scenario.dn.edit_in_progress = False      assert _SequenceManager._is_submittable(sequence)      assert _SequenceManager._is_submittable(sequence.id)      def test_submit():      Config.configure_job_executions(mode=JobConfig._DEVELOPMENT_MODE)      _OrchestratorFactory._build_dispatcher()        data_node_1 = InMemoryDataNode(\"foo\", Scope.SCENARIO, \"s1\")      data_node_2 = InMemoryDataNode(\"bar\", Scope.SCENARIO, \"s2\")      data_node_3 = InMemoryDataNode(\"baz\", Scope.SCENARIO, \"s3\")      data_node_4 = InMemoryDataNode(\"qux\", Scope.SCENARIO, \"s4\")      data_node_5 = InMemoryDataNode(\"quux\", Scope.SCENARIO, \"s5\")      data_node_6 = InMemoryDataNode(\"quuz\", Scope.SCENARIO, \"s6\")      data_node_7 = InMemoryDataNode(\"corge\", Scope.SCENARIO, \"s7\")      task_1 = Task(          \"grault\",          {},          print,          [data_node_1, data_node_2],          [data_node_3, data_node_4],          TaskId(\"t1\"),      )      task_2 = Task(\"garply\", {}, print, [data_node_3], [data_node_5], TaskId(\"t2\"))      task_3 = Task(\"waldo\", {}, print, [data_node_5, data_node_4], [data_node_6], TaskId(\"t3\"))      task_4 = Task(\"fred\", {}, print, [data_node_4], [data_node_7], TaskId(\"t4\"))      scenario = Scenario(\"sce\", {task_1, task_2, task_3, task_4}, {})        sequence_name = \"sequence\"      sequence_id = Sequence._new_id(sequence_name, scenario.id)        class MockOrchestrator(_Orchestrator):          submit_calls = []            @classmethod          def _lock_dn_output_and_create_job(              cls,              task: Task,              submit_id: str,              submit_entity_id: str,              callbacks: Optional[Iterable[Callable]] = None,              force: bool = False,          ):              cls.submit_calls.append(task)              return super()._lock_dn_output_and_create_job(task, submit_id, submit_entity_id, callbacks, force)        with mock.patch(\"src.taipy.core.task._task_manager._TaskManager._orchestrator\", new=MockOrchestrator):          # sequence does not exists. We expect an exception to be raised          with pytest.raises(NonExistingSequence):              _SequenceManager._submit(sequence_id)            _ScenarioManager._set(scenario)          scenario.add_sequences({sequence_name: [task_4, task_2, task_1, task_3]})            # sequence, and tasks does exist. We expect the tasks to be submitted          # in a specific order          _TaskManager._set(task_1)          _TaskManager._set(task_2)          _TaskManager._set(task_3)          _TaskManager._set(task_4)          sequence = scenario.sequences[sequence_name]            _SequenceManager._submit(sequence.id)          calls_ids = [t.id for t in _TaskManager._orchestrator().submit_calls]          tasks_ids = [task_1.id, task_2.id, task_4.id, task_3.id]          assert calls_ids == tasks_ids            _SequenceManager._submit(sequence)          calls_ids = [t.id for t in _TaskManager._orchestrator().submit_calls]          tasks_ids = tasks_ids * 2          assert set(calls_ids) == set(tasks_ids)      def test_assign_sequence_as_parent_of_task():      dn_config_1 = Config.configure_data_node(\"dn_1\", \"in_memory\", scope=Scope.SCENARIO)      dn_config_2 = Config.configure_data_node(\"dn_2\", \"in_memory\", scope=Scope.SCENARIO)      dn_config_3 = Config.configure_data_node(\"dn_3\", \"in_memory\", scope=Scope.SCENARIO)      task_config_1 = Config.configure_task(\"task_1\", print, [dn_config_1], [dn_config_2])      task_config_2 = Config.configure_task(\"task_2\", print, [dn_config_2], [dn_config_3])      task_config_3 = Config.configure_task(\"task_3\", print, [dn_config_2], [dn_config_3])        tasks = _TaskManager._bulk_get_or_create([task_config_1, task_config_2, task_config_3], \"scenario_id\")      sequence_1 = _SequenceManager._create(\"sequence_1\", [tasks[0], tasks[1]], scenario_id=\"scenario_id\")      sequence_2 = _SequenceManager._create(\"sequence_2\", [tasks[0], tasks[2]], scenario_id=\"scenario_id\")        tasks_1 = list(sequence_1.tasks.values())      tasks_2 = list(sequence_2.tasks.values())        assert len(tasks_1) == 2      assert len(tasks_2) == 2        assert tasks_1[0].parent_ids == {sequence_1.id, sequence_2.id}      assert tasks_2[0].parent_ids == {sequence_1.id, sequence_2.id}      assert tasks_1[1].parent_ids == {sequence_1.id}      assert tasks_2[1].parent_ids == {sequence_2.id}      g = 0      def mock_function_no_input_no_output():      global g      g += 1      def mock_function_one_input_no_output(inp):      global g      g += inp      def mock_function_no_input_one_output():      global g      return g      def test_submit_sequence_from_tasks_with_one_or_no_input_output():      Config.configure_job_executions(mode=JobConfig._DEVELOPMENT_MODE)      _OrchestratorFactory._build_dispatcher()        # test no input and no output Task      task_no_input_no_output = Task(\"task_no_input_no_output\", {}, mock_function_no_input_no_output)      scenario_1 = Scenario(\"scenario_1\", {task_no_input_no_output}, {})        _TaskManager._set(task_no_input_no_output)      _ScenarioManager._set(scenario_1)        scenario_1.add_sequences({\"my_sequence_1\": [task_no_input_no_output]})      sequence_1 = scenario_1.sequences[\"my_sequence_1\"]        assert len(sequence_1._get_sorted_tasks()) == 1        _SequenceManager._submit(sequence_1)      assert g == 1        # test one input and no output Task      data_node_input = InMemoryDataNode(\"input_dn\", Scope.SCENARIO, properties={\"default_data\": 2})      task_one_input_no_output = Task(          \"task_one_input_no_output\", {}, mock_function_one_input_no_output, input=[data_node_input]      )      scenario_2 = Scenario(\"scenario_2\", {task_one_input_no_output}, {})        _DataManager._set(data_node_input)      data_node_input.unlock_edit()        _TaskManager._set(task_one_input_no_output)      _ScenarioManager._set(scenario_2)        scenario_2.add_sequences({\"my_sequence_2\": [task_one_input_no_output]})      sequence_2 = scenario_2.sequences[\"my_sequence_2\"]      assert len(sequence_2._get_sorted_tasks()) == 1        _SequenceManager._submit(sequence_2)      assert g == 3        # test no input and one output Task      data_node_output = InMemoryDataNode(\"output_dn\", Scope.SCENARIO, properties={\"default_data\": None})      task_no_input_one_output = Task(          \"task_no_input_one_output\", {}, mock_function_no_input_one_output, output=[data_node_output]      )      scenario_3 = Scenario(\"scenario_3\", {task_no_input_one_output}, {})        _DataManager._set(data_node_output)      assert data_node_output.read() is None      _TaskManager._set(task_no_input_one_output)      _ScenarioManager._set(scenario_3)        scenario_3.add_sequences({\"my_sequence_3\": [task_no_input_one_output]})      sequence_3 = scenario_3.sequences[\"my_sequence_3\"]        assert len(sequence_2._get_sorted_tasks()) == 1        _SequenceManager._submit(sequence_3)      assert data_node_output.read() == 3      def mult_by_two(nb: int):      return nb * 2      def mult_by_3(nb: int):      return nb * 3      def test_get_or_create_data():      # only create intermediate data node once      Config.configure_job_executions(mode=JobConfig._DEVELOPMENT_MODE)        dn_config_1 = Config.configure_data_node(\"foo\", \"in_memory\", Scope.SCENARIO, default_data=1)      dn_config_2 = Config.configure_data_node(\"bar\", \"in_memory\", Scope.SCENARIO, default_data=0)      dn_config_6 = Config.configure_data_node(\"baz\", \"in_memory\", Scope.SCENARIO, default_data=0)        task_config_mult_by_two = Config.configure_task(\"mult_by_two\", mult_by_two, [dn_config_1], dn_config_2)      task_config_mult_by_3 = Config.configure_task(\"mult_by_3\", mult_by_3, [dn_config_2], dn_config_6)      # dn_1 ---> mult_by_two ---> dn_2 ---> mult_by_3 ---> dn_6      scenario_config = Config.configure_scenario(\"scenario\", [task_config_mult_by_two, task_config_mult_by_3])        _OrchestratorFactory._build_dispatcher()        assert len(_DataManager._get_all()) == 0      assert len(_TaskManager._get_all()) == 0        scenario = _ScenarioManager._create(scenario_config)      scenario.add_sequences({\"by_6\": list(scenario.tasks.values())})      sequence = scenario.sequences[\"by_6\"]        assert sequence.name == \"by_6\"        assert len(_DataManager._get_all()) == 3      assert len(_TaskManager._get_all()) == 2      assert len(sequence._get_sorted_tasks()) == 2      assert sequence.foo.read() == 1      assert sequence.bar.read() == 0      assert sequence.baz.read() == 0      assert sequence._get_sorted_tasks()[0][0].config_id == task_config_mult_by_two.id      assert sequence._get_sorted_tasks()[1][0].config_id == task_config_mult_by_3.id        _SequenceManager._submit(sequence.id)      assert sequence.foo.read() == 1      assert sequence.bar.read() == 2      assert sequence.baz.read() == 6        sequence.foo.write(\"new data value\")      assert sequence.foo.read() == \"new data value\"      assert sequence.bar.read() == 2      assert sequence.baz.read() == 6        sequence.bar.write(7)      assert sequence.foo.read() == \"new data value\"      assert sequence.bar.read() == 7      assert sequence.baz.read() == 6        with pytest.raises(AttributeError):          sequence.WRONG.write(7)      def notify1(*args, **kwargs):      ...      def notify2(*args, **kwargs):      ...      def notify_multi_param(*args, **kwargs):      ...      def test_sequence_notification_subscribe(mocker):      Config.configure_job_executions(mode=JobConfig._DEVELOPMENT_MODE)        mocker.patch(\"src.taipy.core._entity._reload._Reloader._reload\", side_effect=lambda m, o: o)        task_configs = [          Config.configure_task(              \"mult_by_two\",              mult_by_two,              [Config.configure_data_node(\"foo\", \"in_memory\", Scope.SCENARIO, default_data=1)],              Config.configure_data_node(\"bar\", \"in_memory\", Scope.SCENARIO, default_data=0),          )      ]        _OrchestratorFactory._build_dispatcher()        tasks = _TaskManager._bulk_get_or_create(task_configs=task_configs)      scenario = Scenario(\"scenario\", set(tasks), {}, sequences={\"by_1\": {\"tasks\": tasks}})      _ScenarioManager._set(scenario)        sequence = scenario.sequences[\"by_1\"]        notify_1 = NotifyMock(sequence)      notify_1.__name__ = \"notify_1\"      notify_1.__module__ = \"notify_1\"      notify_2 = NotifyMock(sequence)      notify_2.__name__ = \"notify_2\"      notify_2.__module__ = \"notify_2\"      # Mocking this because NotifyMock is a class that does not loads correctly when getting the sequence      # from the storage.      mocker.patch.object(_utils, \"_load_fct\", side_effect=[notify_1, notify_1, notify_2, notify_2, notify_2, notify_2])        # test subscription      callback = mock.MagicMock()      _SequenceManager._submit(sequence.id, [callback])      callback.assert_called()        # test sequence subscribe notification      _SequenceManager._subscribe(callback=notify_1, sequence=sequence)      _SequenceManager._submit(sequence.id)        notify_1.assert_called_3_times()      notify_1.reset()        # test sequence unsubscribe notification      # test subscribe notification only on new job      _SequenceManager._unsubscribe(callback=notify_1, sequence=sequence)      _SequenceManager._subscribe(callback=notify_2, sequence=sequence)      _SequenceManager._submit(sequence)        notify_1.assert_not_called()      notify_2.assert_called_3_times()      def test_sequence_notification_subscribe_multi_param(mocker):      Config.configure_job_executions(mode=JobConfig._DEVELOPMENT_MODE)        mocker.patch(\"src.taipy.core._entity._reload._Reloader._reload\", side_effect=lambda m, o: o)        task_configs = [          Config.configure_task(              \"mult_by_two\",              mult_by_two,              [Config.configure_data_node(\"foo\", \"in_memory\", Scope.SCENARIO, default_data=1)],              Config.configure_data_node(\"bar\", \"in_memory\", Scope.SCENARIO, default_data=0),          )      ]        _OrchestratorFactory._build_dispatcher()        tasks = _TaskManager._bulk_get_or_create(task_configs)      scenario = Scenario(\"scenario\", set(tasks), {}, sequences={\"by_6\": {\"tasks\": tasks}})      _ScenarioManager._set(scenario)        sequence = scenario.sequences[\"by_6\"]      notify = mocker.Mock()        # test sequence subscribe notification      _SequenceManager._subscribe(callback=notify, params=[\"foobar\", 123, 1.2], sequence=sequence)      mocker.patch.object(_SequenceManager, \"_get\", return_value=sequence)        _SequenceManager._submit(sequence.id)        # as the callback is called with Sequence/Scenario and Job objects      # we can assert that is called with params plus a sequence object that we know      # of and a job object that is represented by ANY in this case      notify.assert_called_with(\"foobar\", 123, 1.2, sequence, ANY)      def test_sequence_notification_unsubscribe(mocker):      Config.configure_job_executions(mode=JobConfig._DEVELOPMENT_MODE)        mocker.patch(\"src.taipy.core._entity._reload._Reloader._reload\", side_effect=lambda m, o: o)        task_configs = [          Config.configure_task(              \"mult_by_two\",              mult_by_two,              [Config.configure_data_node(\"foo\", \"in_memory\", Scope.SCENARIO, default_data=1)],              Config.configure_data_node(\"bar\", \"in_memory\", Scope.SCENARIO, default_data=0),          )      ]        _OrchestratorFactory._build_dispatcher()        tasks = _TaskManager._bulk_get_or_create(task_configs)      scenario = Scenario(\"scenario\", set(tasks), {}, sequences={\"by_6\": {\"tasks\": tasks}})      _ScenarioManager._set(scenario)        sequence = scenario.sequences[\"by_6\"]        notify_1 = notify1      notify_2 = notify2        _SequenceManager._subscribe(callback=notify_1, sequence=sequence)      _SequenceManager._unsubscribe(callback=notify_1, sequence=sequence)      _SequenceManager._subscribe(callback=notify_2, sequence=sequence)      _SequenceManager._submit(sequence.id)        with pytest.raises(ValueError):          _SequenceManager._unsubscribe(callback=notify_1, sequence=sequence)          _SequenceManager._unsubscribe(callback=notify_2, sequence=sequence)      def test_sequence_notification_unsubscribe_multi_param():      Config.configure_job_executions(mode=JobConfig._DEVELOPMENT_MODE)        task_configs = [          Config.configure_task(              \"mult_by_two\",              mult_by_two,              [Config.configure_data_node(\"foo\", \"in_memory\", Scope.SCENARIO, default_data=1)],              Config.configure_data_node(\"bar\", \"in_memory\", Scope.SCENARIO, default_data=0),          )      ]        _OrchestratorFactory._build_dispatcher()        tasks = _TaskManager._bulk_get_or_create(task_configs)      scenario = Scenario(\"scenario\", tasks, {}, sequences={\"by_6\": {\"tasks\": tasks}})      _ScenarioManager._set(scenario)        sequence = scenario.sequences[\"by_6\"]        _SequenceManager._subscribe(callback=notify_multi_param, params=[\"foobar\", 123, 0], sequence=sequence)      _SequenceManager._subscribe(callback=notify_multi_param, params=[\"foobar\", 123, 1], sequence=sequence)      _SequenceManager._subscribe(callback=notify_multi_param, params=[\"foobar\", 123, 2], sequence=sequence)        assert len(sequence.subscribers) == 3        sequence.unsubscribe(notify_multi_param)      assert len(sequence.subscribers) == 2      assert _Subscriber(notify_multi_param, [\"foobar\", 123, 0]) not in sequence.subscribers        sequence.unsubscribe(notify_multi_param, [\"foobar\", 123, 2])      assert len(sequence.subscribers) == 1      assert _Subscriber(notify_multi_param, [\"foobar\", 123, 2]) not in sequence.subscribers        with pytest.raises(ValueError):          sequence.unsubscribe(notify_multi_param, [\"foobar\", 123, 10000])      def test_sequence_notification_subscribe_all():      Config.configure_job_executions(mode=JobConfig._DEVELOPMENT_MODE)        task_configs = [          Config.configure_task(              \"mult_by_two\",              mult_by_two,              [Config.configure_data_node(\"foo\", \"in_memory\", Scope.SCENARIO, default_data=1)],              Config.configure_data_node(\"bar\", \"in_memory\", Scope.SCENARIO, default_data=0),          )      ]        _OrchestratorFactory._build_dispatcher()        tasks = _TaskManager._bulk_get_or_create(task_configs)      scenario = Scenario(\"scenario\", tasks, {}, sequences={\"by_6\": {\"tasks\": tasks}, \"other_sequence\": {\"tasks\": tasks}})      _ScenarioManager._set(scenario)        sequence = scenario.sequences[\"by_6\"]      other_sequence = scenario.sequences[\"other_sequence\"]        notify_1 = NotifyMock(sequence)        _SequenceManager._subscribe(notify_1)        assert len(_SequenceManager._get(sequence.id).subscribers) == 1      assert len(_SequenceManager._get(other_sequence.id).subscribers) == 1      def test_delete():      sequence_id = \"SEQUENCE_sequence_SCENARIO_scenario_id_1\"      with pytest.raises(ModelNotFound):          _SequenceManager._delete(sequence_id)        scenario_1 = Scenario(\"scenario_1\", [], {}, scenario_id=\"SCENARIO_scenario_id_1\")      scenario_2 = Scenario(\"scenario_2\", [], {}, scenario_id=\"SCENARIO_scenario_id_2\")      _ScenarioManager._set(scenario_1)      _ScenarioManager._set(scenario_2)      with pytest.raises(ModelNotFound):          _SequenceManager._delete(sequence_id)        scenario_1.add_sequences({\"sequence\": {}})      assert len(_SequenceManager._get_all()) == 1      _SequenceManager._delete(sequence_id)      assert len(_SequenceManager._get_all()) == 0        scenario_1.add_sequences({\"sequence\": {}, \"sequence_1\": {}})      assert len(_SequenceManager._get_all()) == 2      _SequenceManager._delete(sequence_id)      assert len(_SequenceManager._get_all()) == 1        scenario_1.add_sequences({\"sequence_1\": {}, \"sequence_2\": {}, \"sequence_3\": {}})      scenario_2.add_sequences({\"sequence_1_2\": {}, \"sequence_2_2\": {}})      assert len(_SequenceManager._get_all()) == 5      _SequenceManager._delete_all()      assert len(_SequenceManager._get_all()) == 0        scenario_1.add_sequences({\"sequence_1\": {}, \"sequence_2\": {}, \"sequence_3\": {}, \"sequence_4\": {}})      scenario_2.add_sequences({\"sequence_1_2\": {}, \"sequence_2_2\": {}})      assert len(_SequenceManager._get_all()) == 6      _SequenceManager._delete_many(          [              \"SEQUENCE_sequence_1_SCENARIO_scenario_id_1\",              \"SEQUENCE_sequence_2_SCENARIO_scenario_id_1\",              \"SEQUENCE_sequence_1_2_SCENARIO_scenario_id_2\",          ]      )      assert len(_SequenceManager._get_all()) == 3        with pytest.raises(ModelNotFound):          _SequenceManager._delete_many(              [\"SEQUENCE_sequence_1_SCENARIO_scenario_id_1\", \"SEQUENCE_sequence_2_SCENARIO_scenario_id_1\"]          )      def test_delete_version():      scenario_1_0 = Scenario(          \"scenario_config\",          [],          {},          scenario_id=\"SCENARIO_id_1_v1_0\",          version=\"1.0\",          sequences={\"sequence_1\": {}, \"sequence_2\": {}},      )      scenario_1_1 = Scenario(          \"scenario_config\",          [],          {},          scenario_id=\"SCENARIO_id_1_v1_1\",          version=\"1.1\",          sequences={\"sequence_1\": {}, \"sequence_2\": {}},      )      _ScenarioManager._set(scenario_1_0)      _ScenarioManager._set(scenario_1_1)        _VersionManager._set_experiment_version(\"1.1\")      assert len(_ScenarioManager._get_all()) == 1      assert len(_SequenceManager._get_all()) == 2        _VersionManager._set_experiment_version(\"1.0\")      assert len(_ScenarioManager._get_all()) == 1      assert len(_SequenceManager._get_all()) == 2        _SequenceManager._delete_by_version(\"1.0\")      assert len(_ScenarioManager._get_all()) == 1      assert len(_SequenceManager._get_all()) == 0      assert len(scenario_1_0.sequences) == 0      assert len(scenario_1_1.sequences) == 2        _VersionManager._set_experiment_version(\"1.1\")      assert len(_ScenarioManager._get_all()) == 1      assert len(_SequenceManager._get_all()) == 2      assert len(scenario_1_0.sequences) == 0      assert len(scenario_1_1.sequences) == 2      _SequenceManager._delete_by_version(\"1.1\")      assert len(_ScenarioManager._get_all()) == 1      assert len(_SequenceManager._get_all()) == 0      def test_exists():      scenario = Scenario(\"scenario\", [], {}, scenario_id=\"SCENARIO_scenario\", sequences={\"sequence\": {}})      _ScenarioManager._set(scenario)      assert len(_ScenarioManager._get_all()) == 1      assert len(_SequenceManager._get_all()) == 1      assert not _SequenceManager._exists(\"SEQUENCE_sequence_not_exist_SCENARIO_scenario\")      assert not _SequenceManager._exists(\"SEQUENCE_sequence_SCENARIO_scenario_id\")      assert _SequenceManager._exists(\"SEQUENCE_sequence_SCENARIO_scenario\")      assert _SequenceManager._exists(scenario.sequences[\"sequence\"])      def test_export(tmpdir_factory):      path = tmpdir_factory.mktemp(\"data\")      task = Task(\"task\", {}, print, id=TaskId(\"task_id\"))      scenario = Scenario(          \"scenario\",          set([task]),          {},          set(),          version=\"1.0\",          sequences={\"sequence_1\": {}, \"sequence_2\": {\"tasks\": [task], \"properties\": {\"xyz\": \"acb\"}}},      )      _TaskManager._set(task)      _ScenarioManager._set(scenario)        sequence_1 = scenario.sequences[\"sequence_1\"]      sequence_2 = scenario.sequences[\"sequence_2\"]        _SequenceManager._export(sequence_1.id, Path(path))      export_sequence_json_file_path = f\"{path}/sequences/{sequence_1.id}.json\"      with open(export_sequence_json_file_path, \"rb\") as f:          sequence_json_file = json.load(f)          expected_json = {              \"id\": sequence_1.id,              \"owner_id\": scenario.id,              \"parent_ids\": [scenario.id],              \"name\": \"sequence_1\",              \"tasks\": [],              \"properties\": {},              \"subscribers\": [],          }          assert expected_json == sequence_json_file        _SequenceManager._export(sequence_2.id, Path(path))      export_sequence_json_file_path = f\"{path}/sequences/{sequence_2.id}.json\"      with open(export_sequence_json_file_path, \"rb\") as f:          sequence_json_file = json.load(f)          expected_json = {              \"id\": sequence_2.id,              \"owner_id\": scenario.id,              \"parent_ids\": [scenario.id],              \"name\": \"sequence_2\",              \"tasks\": [task.id],              \"properties\": {\"xyz\": \"acb\"},              \"subscribers\": [],          }          assert expected_json == sequence_json_file      def test_hard_delete_one_single_sequence_with_scenario_data_nodes():      Config.configure_job_executions(mode=JobConfig._DEVELOPMENT_MODE)        dn_input_config = Config.configure_data_node(\"my_input\", \"in_memory\", scope=Scope.SCENARIO, default_data=\"testing\")      dn_output_config = Config.configure_data_node(\"my_output\", \"in_memory\", scope=Scope.SCENARIO)      task_config = Config.configure_task(\"task_config\", print, dn_input_config, dn_output_config)        _OrchestratorFactory._build_dispatcher()        tasks = _TaskManager._bulk_get_or_create([task_config])      scenario = Scenario(\"scenario\", tasks, {}, sequences={\"sequence\": {\"tasks\": tasks}})      _ScenarioManager._set(scenario)        sequence = scenario.sequences[\"sequence\"]      sequence.submit()        assert len(_ScenarioManager._get_all()) == 1      assert len(_SequenceManager._get_all()) == 1      assert len(_TaskManager._get_all()) == 1      assert len(_DataManager._get_all()) == 2      assert len(_JobManager._get_all()) == 1      _SequenceManager._hard_delete(sequence.id)      assert len(_ScenarioManager._get_all()) == 1      assert len(_SequenceManager._get_all()) == 0      assert len(_TaskManager._get_all()) == 1      assert len(_DataManager._get_all()) == 2      assert len(_JobManager._get_all()) == 1      def test_hard_delete_one_single_sequence_with_cycle_data_nodes():      Config.configure_job_executions(mode=JobConfig._DEVELOPMENT_MODE)        dn_input_config = Config.configure_data_node(\"my_input\", \"in_memory\", scope=Scope.CYCLE, default_data=\"testing\")      dn_output_config = Config.configure_data_node(\"my_output\", \"in_memory\", scope=Scope.CYCLE)      task_config = Config.configure_task(\"task_config\", print, dn_input_config, dn_output_config)        _OrchestratorFactory._build_dispatcher()        tasks = _TaskManager._bulk_get_or_create([task_config])      scenario = Scenario(\"scenario\", tasks, {}, sequences={\"sequence\": {\"tasks\": tasks}})      _ScenarioManager._set(scenario)        sequence = scenario.sequences[\"sequence\"]      sequence.submit()        assert len(_ScenarioManager._get_all()) == 1      assert len(_SequenceManager._get_all()) == 1      assert len(_TaskManager._get_all()) == 1      assert len(_DataManager._get_all()) == 2      assert len(_JobManager._get_all()) == 1      _SequenceManager._hard_delete(sequence.id)      assert len(_ScenarioManager._get_all()) == 1      assert len(_SequenceManager._get_all()) == 0      assert len(_TaskManager._get_all()) == 1      assert len(_DataManager._get_all()) == 2      assert len(_JobManager._get_all()) == 1      def test_hard_delete_shared_entities():      Config.configure_job_executions(mode=JobConfig._DEVELOPMENT_MODE)        input_dn = Config.configure_data_node(\"my_input\", \"in_memory\", scope=Scope.SCENARIO, default_data=\"testing\")      intermediate_dn = Config.configure_data_node(\"my_inter\", \"in_memory\", scope=Scope.GLOBAL, default_data=\"testing\")      output_dn = Config.configure_data_node(\"my_output\", \"in_memory\", scope=Scope.GLOBAL, default_data=\"testing\")      task_1 = Config.configure_task(\"task_1\", print, input_dn, intermediate_dn)      task_2 = Config.configure_task(\"task_2\", print, intermediate_dn, output_dn)        _OrchestratorFactory._build_dispatcher()        tasks_scenario_1 = _TaskManager._bulk_get_or_create([task_1, task_2], scenario_id=\"scenario_id_1\")      tasks_scenario_2 = _TaskManager._bulk_get_or_create([task_1, task_2], scenario_id=\"scenario_id_2\")        scenario_1 = Scenario(\"scenario_1\", tasks_scenario_1, {}, sequences={\"sequence\": {\"tasks\": tasks_scenario_1}})      scenario_2 = Scenario(\"scenario_2\", tasks_scenario_2, {}, sequences={\"sequence\": {\"tasks\": tasks_scenario_2}})      _ScenarioManager._set(scenario_1)      _ScenarioManager._set(scenario_2)      sequence_1 = scenario_1.sequences[\"sequence\"]      sequence_2 = scenario_2.sequences[\"sequence\"]        _SequenceManager._submit(sequence_1.id)      _SequenceManager._submit(sequence_2.id)        assert len(_ScenarioManager._get_all()) == 2      assert len(_SequenceManager._get_all()) == 2      assert len(_TaskManager._get_all()) == 3      assert len(_DataManager._get_all()) == 4      assert len(_JobManager._get_all()) == 4      _SequenceManager._hard_delete(sequence_1.id)      assert len(_ScenarioManager._get_all()) == 2      assert len(_SequenceManager._get_all()) == 1      assert len(_TaskManager._get_all()) == 3      assert len(_DataManager._get_all()) == 4      assert len(_JobManager._get_all()) == 4      def my_print(a, b):      print(a + b)      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\")      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\")      json_dn_cfg = Config.configure_parquet_data_node(\"wrong_json_file_path\", default_path=\"wrong_path.json\")      task_cfg = Config.configure_task(\"task\", my_print, [csv_dn_cfg, pickle_dn_cfg], parquet_dn_cfg)      task_2_cfg = Config.configure_task(\"task2\", my_print, [csv_dn_cfg, parquet_dn_cfg], json_dn_cfg)        tasks = _TaskManager._bulk_get_or_create([task_cfg, task_2_cfg])      scenario = Scenario(\"scenario\", tasks, {}, sequences={\"sequence\": {\"tasks\": tasks}})      _ScenarioManager._set(scenario)      sequence = scenario.sequences[\"sequence\"]        pip_manager = _SequenceManagerFactory._build_manager()      pip_manager._submit(sequence)        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 sequence.get_inputs()      ]      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 sequence.data_nodes.values()          if input_dn not in sequence.get_inputs()      ]      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_one_input_dn_wrong_file_path(caplog):      csv_dn_cfg = Config.configure_csv_data_node(\"wrong_csv_file_path\", default_path=\"wrong_path.csv\")      pickle_dn_cfg = Config.configure_pickle_data_node(\"wrong_pickle_file_path\", default_data=\"value\")      parquet_dn_cfg = Config.configure_parquet_data_node(\"wrong_parquet_file_path\", default_path=\"wrong_path.parquet\")      json_dn_cfg = Config.configure_parquet_data_node(\"wrong_json_file_path\", default_path=\"wrong_path.json\")      task_cfg = Config.configure_task(\"task\", my_print, [csv_dn_cfg, pickle_dn_cfg], parquet_dn_cfg)      task_2_cfg = Config.configure_task(\"task2\", my_print, [csv_dn_cfg, parquet_dn_cfg], json_dn_cfg)        tasks = _TaskManager._bulk_get_or_create([task_cfg, task_2_cfg])      scenario = Scenario(\"scenario\", tasks, {}, sequences={\"sequence\": {\"tasks\": tasks}})      _ScenarioManager._set(scenario)      sequence = scenario.sequences[\"sequence\"]        pip_manager = _SequenceManagerFactory._build_manager()      pip_manager._submit(sequence)        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 sequence.get_inputs()          if input_dn.config_id == \"wrong_csv_file_path\"      ]      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 sequence.data_nodes.values()          if input_dn.config_id != \"wrong_csv_file_path\"      ]      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]) "}
{"text": "import datetime  import json  import os  import pathlib  from dataclasses import dataclass  from enum import Enum  from time import sleep    import numpy as np  import pandas as pd  import pytest    from src.taipy.core.data._data_manager import _DataManager  from src.taipy.core.data.data_node_id import DataNodeId  from src.taipy.core.data.json import JSONDataNode  from src.taipy.core.data.operator import JoinOperator, Operator  from src.taipy.core.exceptions.exceptions import NoData  from taipy.config.common.scope import Scope  from taipy.config.config import Config  from taipy.config.exceptions.exceptions import InvalidConfigurationId      @pytest.fixture(scope=\"function\", autouse=True)  def cleanup():      yield      path = os.path.join(pathlib.Path(__file__).parent.resolve(), \"data_sample/temp.json\")      if os.path.isfile(path):          os.remove(path)      class MyCustomObject:      def __init__(self, id, integer, text):          self.id = id          self.integer = integer          self.text = text      class MyCustomObject2:      def __init__(self, id, boolean, text):          self.id = id          self.boolean = boolean          self.text = text      class MyEnum(Enum):      A = 1      B = 2      C = 3      @dataclass  class CustomDataclass:      integer: int      string: str      class MyCustomEncoder(json.JSONEncoder):      def default(self, o):          if isinstance(o, MyCustomObject):              return {\"__type__\": \"MyCustomObject\", \"id\": o.id, \"integer\": o.integer, \"text\": o.text}          return super().default(self, o)      class MyCustomDecoder(json.JSONDecoder):      def __init__(self, *args, **kwargs):          super().__init__(object_hook=self.object_hook, *args, **kwargs)        def object_hook(self, o):          if o.get(\"__type__\") == \"MyCustomObject\":              return MyCustomObject(o[\"id\"], o[\"integer\"], o[\"text\"])          else:              return o      class TestJSONDataNode:      def test_create(self):          path = \"data/node/path\"          dn = JSONDataNode(\"foo_bar\", Scope.SCENARIO, properties={\"default_path\": path, \"name\": \"super name\"})          assert isinstance(dn, JSONDataNode)          assert dn.storage_type() == \"json\"          assert dn.config_id == \"foo_bar\"          assert dn.name == \"super name\"          assert dn.scope == Scope.SCENARIO          assert dn.id is not None          assert dn.owner_id is None          assert dn.last_edit_date is None          assert dn.job_ids == []          assert not dn.is_ready_for_reading          assert dn.path == path            with pytest.raises(InvalidConfigurationId):              dn = JSONDataNode(                  \"foo bar\", Scope.SCENARIO, properties={\"default_path\": path, \"has_header\": False, \"name\": \"super name\"}              )        def test_get_user_properties(self, json_file):          dn_1 = JSONDataNode(\"dn_1\", Scope.SCENARIO, properties={\"path\": json_file})          assert dn_1._get_user_properties() == {}            dn_2 = JSONDataNode(              \"dn_2\",              Scope.SCENARIO,              properties={                  \"default_data\": \"foo\",                  \"default_path\": json_file,                  \"encoder\": MyCustomEncoder,                  \"decoder\": MyCustomDecoder,                  \"foo\": \"bar\",              },          )            # default_data, default_path, path, encoder, decoder are filtered out          assert dn_2._get_user_properties() == {\"foo\": \"bar\"}        def test_new_json_data_node_with_existing_file_is_ready_for_reading(self):          not_ready_dn_cfg = Config.configure_data_node(              \"not_ready_data_node_config_id\", \"json\", default_path=\"NOT_EXISTING.json\"          )          not_ready_dn = _DataManager._bulk_get_or_create([not_ready_dn_cfg])[not_ready_dn_cfg]          assert not not_ready_dn.is_ready_for_reading          assert not_ready_dn.path == \"NOT_EXISTING.json\"            path = os.path.join(pathlib.Path(__file__).parent.resolve(), \"data_sample/json/example_list.json\")          ready_dn_cfg = Config.configure_data_node(\"ready_data_node_config_id\", \"json\", default_path=path)          ready_dn = _DataManager._bulk_get_or_create([ready_dn_cfg])[ready_dn_cfg]          assert ready_dn.is_ready_for_reading        def test_read_non_existing_json(self):          not_existing_json = JSONDataNode(\"foo\", Scope.SCENARIO, properties={\"default_path\": \"WRONG.json\"})          with pytest.raises(NoData):              assert not_existing_json.read() is None              not_existing_json.read_or_raise()        def test_read(self):          path_1 = os.path.join(pathlib.Path(__file__).parent.resolve(), \"data_sample/json/example_list.json\")          dn_1 = JSONDataNode(\"bar\", Scope.SCENARIO, properties={\"default_path\": path_1})          data_1 = dn_1.read()          assert isinstance(data_1, list)          assert len(data_1) == 4            path_2 = os.path.join(pathlib.Path(__file__).parent.resolve(), \"data_sample/json/example_dict.json\")          dn_2 = JSONDataNode(\"bar\", Scope.SCENARIO, properties={\"default_path\": path_2})          data_2 = dn_2.read()          assert isinstance(data_2, dict)          assert data_2[\"id\"] == \"1\"            path_3 = os.path.join(pathlib.Path(__file__).parent.resolve(), \"data_sample/json/example_int.json\")          dn_3 = JSONDataNode(\"bar\", Scope.SCENARIO, properties={\"default_path\": path_3})          data_3 = dn_3.read()          assert isinstance(data_3, int)          assert data_3 == 1            path_4 = os.path.join(pathlib.Path(__file__).parent.resolve(), \"data_sample/json/example_null.json\")          dn_4 = JSONDataNode(\"bar\", Scope.SCENARIO, properties={\"default_path\": path_4})          data_4 = dn_4.read()          assert data_4 is None        def test_read_invalid_json(self):          path = os.path.join(pathlib.Path(__file__).parent.resolve(), \"data_sample/invalid.json.txt\")          dn = JSONDataNode(\"foo\", Scope.SCENARIO, properties={\"default_path\": path})          with pytest.raises(ValueError):              dn.read()        def test_append_to_list(self, json_file):          json_dn = JSONDataNode(\"foo\", Scope.SCENARIO, properties={\"default_path\": json_file})          original_data = json_dn.read()            # Append a dictionary          append_data_1 = {\"a\": 1, \"b\": 2, \"c\": 3}          json_dn.append(append_data_1)          assert json_dn.read() == original_data + [append_data_1]            # Append a list of dictionaries          append_data_data_2 = [{\"a\": 1, \"b\": 2, \"c\": 3}, {\"a\": 4, \"b\": 5, \"c\": 6}]          json_dn.append(append_data_data_2)          assert json_dn.read() == original_data + [append_data_1] + append_data_data_2        def test_append_to_a_dictionary(self, json_file):          json_dn = JSONDataNode(\"foo\", Scope.SCENARIO, properties={\"default_path\": json_file})          original_data = {\"a\": 1, \"b\": 2, \"c\": 3}          json_dn.write(original_data)            # Append another dictionary          append_data_1 = {\"d\": 1, \"e\": 2, \"f\": 3}          json_dn.append(append_data_1)          assert json_dn.read() == {**original_data, **append_data_1}            # Append an overlap dictionary          append_data_data_2 = {\"a\": 10, \"b\": 20, \"g\": 30}          json_dn.append(append_data_data_2)          assert json_dn.read() == {**original_data, **append_data_1, **append_data_data_2}        def test_write(self, json_file):          json_dn = JSONDataNode(\"foo\", Scope.SCENARIO, properties={\"default_path\": json_file})          data = {\"a\": 1, \"b\": 2, \"c\": 3}          json_dn.write(data)          assert np.array_equal(json_dn.read(), data)        def test_write_with_different_encoding(self, json_file):          data = {\"\u2265a\": 1, \"b\": 2}            utf8_dn = JSONDataNode(\"utf8_dn\", Scope.SCENARIO, properties={\"default_path\": json_file})          utf16_dn = JSONDataNode(              \"utf16_dn\", Scope.SCENARIO, properties={\"default_path\": json_file, \"encoding\": \"utf-16\"}          )            # If a file is written with utf-8 encoding, it can only be read with utf-8, not utf-16 encoding          utf8_dn.write(data)          assert np.array_equal(utf8_dn.read(), data)          with pytest.raises(UnicodeError):              utf16_dn.read()            # If a file is written with utf-16 encoding, it can only be read with utf-16, not utf-8 encoding          utf16_dn.write(data)          assert np.array_equal(utf16_dn.read(), data)          with pytest.raises(UnicodeError):              utf8_dn.read()        def test_write_non_serializable(self, json_file):          json_dn = JSONDataNode(\"foo\", Scope.SCENARIO, properties={\"default_path\": json_file})          data = {\"a\": 1, \"b\": json_dn}          with pytest.raises(TypeError):              json_dn.write(data)        def test_write_date(self, json_file):          json_dn = JSONDataNode(\"foo\", Scope.SCENARIO, properties={\"default_path\": json_file})          now = datetime.datetime.now()          data = {\"date\": now}          json_dn.write(data)          read_data = json_dn.read()          assert read_data[\"date\"] == now        def test_write_enum(self, json_file):          json_dn = JSONDataNode(\"foo\", Scope.SCENARIO, properties={\"default_path\": json_file})          data = [MyEnum.A, MyEnum.B, MyEnum.C]          json_dn.write(data)          read_data = json_dn.read()          assert read_data == [MyEnum.A, MyEnum.B, MyEnum.C]        def test_write_dataclass(self, json_file):          json_dn = JSONDataNode(\"foo\", Scope.SCENARIO, properties={\"default_path\": json_file})          json_dn.write(CustomDataclass(integer=1, string=\"foo\"))          read_data = json_dn.read()          assert read_data.integer == 1          assert read_data.string == \"foo\"        def test_write_custom_encoder(self, json_file):          json_dn = JSONDataNode(              \"foo\", Scope.SCENARIO, properties={\"default_path\": json_file, \"encoder\": MyCustomEncoder}          )          data = [MyCustomObject(\"1\", 1, \"abc\"), 100]          json_dn.write(data)          read_data = json_dn.read()          assert read_data[0][\"__type__\"] == \"MyCustomObject\"          assert read_data[0][\"id\"] == \"1\"          assert read_data[0][\"integer\"] == 1          assert read_data[0][\"text\"] == \"abc\"          assert read_data[1] == 100        def test_read_write_custom_encoder_decoder(self, json_file):          json_dn = JSONDataNode(              \"foo\",              Scope.SCENARIO,              properties={\"default_path\": json_file, \"encoder\": MyCustomEncoder, \"decoder\": MyCustomDecoder},          )          data = [MyCustomObject(\"1\", 1, \"abc\"), 100]          json_dn.write(data)          read_data = json_dn.read()          assert isinstance(read_data[0], MyCustomObject)          assert read_data[0].id == \"1\"          assert read_data[0].integer == 1          assert read_data[0].text == \"abc\"          assert read_data[1] == 100        def test_filter(self, json_file):          json_dn = JSONDataNode(\"foo\", Scope.SCENARIO, properties={\"default_path\": json_file})          json_dn.write(              [                  {\"foo\": 1, \"bar\": 1},                  {\"foo\": 1, \"bar\": 2},                  {\"foo\": 1},                  {\"foo\": 2, \"bar\": 2},                  {\"bar\": 2},                  {\"KWARGS_KEY\": \"KWARGS_VALUE\"},              ]          )            assert len(json_dn.filter((\"foo\", 1, Operator.EQUAL))) == 3          assert len(json_dn.filter((\"foo\", 1, Operator.NOT_EQUAL))) == 3          assert len(json_dn.filter((\"bar\", 2, Operator.EQUAL))) == 3          assert len(json_dn.filter([(\"bar\", 1, Operator.EQUAL), (\"bar\", 2, Operator.EQUAL)], JoinOperator.OR)) == 4            assert json_dn[0] == {\"foo\": 1, \"bar\": 1}          assert json_dn[2] == {\"foo\": 1}          assert json_dn[:2] == [{\"foo\": 1, \"bar\": 1}, {\"foo\": 1, \"bar\": 2}]        @pytest.mark.parametrize(          [\"properties\", \"exists\"],          [              ({}, False),              ({\"default_data\": {\"foo\": \"bar\"}}, True),          ],      )      def test_create_with_default_data(self, properties, exists):          dn = JSONDataNode(\"foo\", Scope.SCENARIO, DataNodeId(\"dn_id\"), properties=properties)          assert os.path.exists(dn.path) is exists        def test_set_path(self):          dn = JSONDataNode(\"foo\", Scope.SCENARIO, properties={\"default_path\": \"foo.json\"})          assert dn.path == \"foo.json\"          dn.path = \"bar.json\"          assert dn.path == \"bar.json\"        def test_read_write_after_modify_path(self):          path = os.path.join(pathlib.Path(__file__).parent.resolve(), \"data_sample/json/example_dict.json\")          new_path = os.path.join(pathlib.Path(__file__).parent.resolve(), \"data_sample/temp.json\")          dn = JSONDataNode(\"foo\", Scope.SCENARIO, properties={\"default_path\": path})          read_data = dn.read()          assert read_data is not None          dn.path = new_path          with pytest.raises(FileNotFoundError):              dn.read()          dn.write({\"other\": \"stuff\"})          assert dn.read() == {\"other\": \"stuff\"}        def test_get_system_modified_date_instead_of_last_edit_date(self, tmpdir_factory):          temp_file_path = str(tmpdir_factory.mktemp(\"data\").join(\"temp.json\"))          pd.DataFrame([]).to_json(temp_file_path)          dn = JSONDataNode(\"foo\", Scope.SCENARIO, properties={\"path\": temp_file_path})            dn.write([1, 2, 3])          previous_edit_date = dn.last_edit_date            sleep(0.1)            pd.DataFrame([4, 5, 6]).to_json(temp_file_path)          new_edit_date = datetime.datetime.fromtimestamp(os.path.getmtime(temp_file_path))            assert previous_edit_date < dn.last_edit_date          assert new_edit_date == dn.last_edit_date            sleep(0.1)            dn.write([1, 2, 3])          assert new_edit_date < dn.last_edit_date          os.unlink(temp_file_path) "}
{"text": "from importlib import util  from unittest.mock import patch    import modin.pandas as modin_pd  import numpy as np  import pandas as pd  import pytest  from modin.pandas.test.utils import df_equals  from pandas.testing import assert_frame_equal    from src.taipy.core.data.data_node_id import DataNodeId  from src.taipy.core.data.operator import JoinOperator, Operator  from src.taipy.core.data.sql import SQLDataNode  from src.taipy.core.exceptions.exceptions import MissingAppendQueryBuilder, MissingRequiredProperty  from taipy.config.common.scope import Scope      class MyCustomObject:      def __init__(self, foo=None, bar=None, *args, **kwargs):          self.foo = foo          self.bar = bar          self.args = args          self.kwargs = kwargs      def my_write_query_builder_with_pandas(data: pd.DataFrame):      insert_data = data.to_dict(\"records\")      return [\"DELETE FROM example\", (\"INSERT INTO example VALUES (:foo, :bar)\", insert_data)]      def my_write_query_builder_with_modin(data: modin_pd.DataFrame):      insert_data = data.to_dict(\"records\")      return [\"DELETE FROM example\", (\"INSERT INTO example VALUES (:foo, :bar)\", insert_data)]      def my_append_query_builder_with_pandas(data: pd.DataFrame):      insert_data = data.to_dict(\"records\")      return [(\"INSERT INTO example VALUES (:foo, :bar)\", insert_data)]      def my_append_query_builder_with_modin(data: modin_pd.DataFrame):      insert_data = data.to_dict(\"records\")      return [(\"INSERT INTO example VALUES (:foo, :bar)\", insert_data)]      def single_write_query_builder(data):      return \"DELETE FROM example\"      class TestSQLDataNode:      __pandas_properties = [          {              \"db_name\": \"taipy.sqlite3\",              \"db_engine\": \"sqlite\",              \"read_query\": \"SELECT * FROM example\",              \"write_query_builder\": my_write_query_builder_with_pandas,              \"db_extra_args\": {                  \"TrustServerCertificate\": \"yes\",                  \"other\": \"value\",              },          },      ]        __modin_properties = [          {              \"db_name\": \"taipy.sqlite3\",              \"db_engine\": \"sqlite\",              \"read_query\": \"SELECT * FROM example\",              \"write_query_builder\": my_write_query_builder_with_modin,              \"exposed_type\": \"modin\",              \"db_extra_args\": {                  \"TrustServerCertificate\": \"yes\",                  \"other\": \"value\",              },          },      ]        if util.find_spec(\"pyodbc\"):          __pandas_properties.append(              {                  \"db_username\": \"sa\",                  \"db_password\": \"Passw0rd\",                  \"db_name\": \"taipy\",                  \"db_engine\": \"mssql\",                  \"read_query\": \"SELECT * FROM example\",                  \"write_query_builder\": my_write_query_builder_with_pandas,                  \"db_extra_args\": {                      \"TrustServerCertificate\": \"yes\",                  },              },          )          __modin_properties.append(              {                  \"db_username\": \"sa\",                  \"db_password\": \"Passw0rd\",                  \"db_name\": \"taipy\",                  \"db_engine\": \"mssql\",                  \"read_query\": \"SELECT * FROM example\",                  \"write_query_builder\": my_write_query_builder_with_modin,                  \"exposed_type\": \"modin\",                  \"db_extra_args\": {                      \"TrustServerCertificate\": \"yes\",                  },              },          )        if util.find_spec(\"pymysql\"):          __pandas_properties.append(              {                  \"db_username\": \"sa\",                  \"db_password\": \"Passw0rd\",                  \"db_name\": \"taipy\",                  \"db_engine\": \"mysql\",                  \"read_query\": \"SELECT * FROM example\",                  \"write_query_builder\": my_write_query_builder_with_pandas,                  \"db_extra_args\": {                      \"TrustServerCertificate\": \"yes\",                  },              },          )          __modin_properties.append(              {                  \"db_username\": \"sa\",                  \"db_password\": \"Passw0rd\",                  \"db_name\": \"taipy\",                  \"db_engine\": \"mysql\",                  \"read_query\": \"SELECT * FROM example\",                  \"write_query_builder\": my_write_query_builder_with_modin,                  \"exposed_type\": \"modin\",                  \"db_extra_args\": {                      \"TrustServerCertificate\": \"yes\",                  },              },          )        if util.find_spec(\"psycopg2\"):          __pandas_properties.append(              {                  \"db_username\": \"sa\",                  \"db_password\": \"Passw0rd\",                  \"db_name\": \"taipy\",                  \"db_engine\": \"postgresql\",                  \"read_query\": \"SELECT * FROM example\",                  \"write_query_builder\": my_write_query_builder_with_pandas,                  \"db_extra_args\": {                      \"TrustServerCertificate\": \"yes\",                  },              },          )          __modin_properties.append(              {                  \"db_username\": \"sa\",                  \"db_password\": \"Passw0rd\",                  \"db_name\": \"taipy\",                  \"db_engine\": \"postgresql\",                  \"read_query\": \"SELECT * FROM example\",                  \"write_query_builder\": my_write_query_builder_with_modin,                  \"exposed_type\": \"modin\",                  \"db_extra_args\": {                      \"TrustServerCertificate\": \"yes\",                  },              },          )        @pytest.mark.parametrize(\"pandas_properties\", __pandas_properties)      @pytest.mark.parametrize(\"modin_properties\", __modin_properties)      def test_create(self, pandas_properties, modin_properties):          dn = SQLDataNode(              \"foo_bar\",              Scope.SCENARIO,              properties=pandas_properties,          )          assert isinstance(dn, SQLDataNode)          assert dn.storage_type() == \"sql\"          assert dn.config_id == \"foo_bar\"          assert dn.scope == Scope.SCENARIO          assert dn.id is not None          assert dn.owner_id is None          assert dn.job_ids == []          assert dn.is_ready_for_reading          assert dn.exposed_type == \"pandas\"          assert dn.read_query == \"SELECT * FROM example\"          assert dn.write_query_builder == my_write_query_builder_with_pandas            dn = SQLDataNode(              \"foo_bar\",              Scope.SCENARIO,              properties=modin_properties,          )          assert isinstance(dn, SQLDataNode)          assert dn.storage_type() == \"sql\"          assert dn.config_id == \"foo_bar\"          assert dn.scope == Scope.SCENARIO          assert dn.id is not None          assert dn.owner_id is None          assert dn.job_ids == []          assert dn.is_ready_for_reading          assert dn.exposed_type == \"modin\"          assert dn.read_query == \"SELECT * FROM example\"          assert dn.write_query_builder == my_write_query_builder_with_modin        @pytest.mark.parametrize(\"properties\", __pandas_properties + __modin_properties)      def test_get_user_properties(self, properties):          custom_properties = properties.copy()          custom_properties[\"foo\"] = \"bar\"          dn = SQLDataNode(              \"foo_bar\",              Scope.SCENARIO,              properties=custom_properties,          )          assert dn._get_user_properties() == {\"foo\": \"bar\"}        @pytest.mark.parametrize(          \"properties\",          [              {},              {\"db_username\": \"foo\"},              {\"db_username\": \"foo\", \"db_password\": \"foo\"},              {\"db_username\": \"foo\", \"db_password\": \"foo\", \"db_name\": \"foo\"},              {\"engine\": \"sqlite\"},              {\"engine\": \"mssql\", \"db_name\": \"foo\"},              {\"engine\": \"mysql\", \"db_username\": \"foo\"},              {\"engine\": \"postgresql\", \"db_username\": \"foo\", \"db_password\": \"foo\"},          ],      )      def test_create_with_missing_parameters(self, properties):          with pytest.raises(MissingRequiredProperty):              SQLDataNode(\"foo\", Scope.SCENARIO, DataNodeId(\"dn_id\"))          with pytest.raises(MissingRequiredProperty):              SQLDataNode(\"foo\", Scope.SCENARIO, DataNodeId(\"dn_id\"), properties=properties)        @pytest.mark.parametrize(\"pandas_properties\", __pandas_properties)      @pytest.mark.parametrize(\"modin_properties\", __modin_properties)      def test_write_query_builder(self, pandas_properties, modin_properties):          custom_properties = pandas_properties.copy()          custom_properties.pop(\"db_extra_args\")          dn = SQLDataNode(\"foo_bar\", Scope.SCENARIO, properties=custom_properties)          with patch(\"sqlalchemy.engine.Engine.connect\") as engine_mock:              # mock connection execute              dn.write(pd.DataFrame({\"foo\": [1, 2, 3], \"bar\": [4, 5, 6]}))              assert len(engine_mock.mock_calls[4].args) == 1              assert engine_mock.mock_calls[4].args[0].text == \"DELETE FROM example\"              assert len(engine_mock.mock_calls[5].args) == 2              assert engine_mock.mock_calls[5].args[0].text == \"INSERT INTO example VALUES (:foo, :bar)\"              assert engine_mock.mock_calls[5].args[1] == [                  {\"foo\": 1, \"bar\": 4},                  {\"foo\": 2, \"bar\": 5},                  {\"foo\": 3, \"bar\": 6},              ]            custom_properties[\"write_query_builder\"] = single_write_query_builder          dn = SQLDataNode(\"foo_bar\", Scope.SCENARIO, properties=custom_properties)            with patch(\"sqlalchemy.engine.Engine.connect\") as engine_mock:              # mock connection execute              dn.write(pd.DataFrame({\"foo\": [1, 2, 3], \"bar\": [4, 5, 6]}))              assert len(engine_mock.mock_calls[4].args) == 1              assert engine_mock.mock_calls[4].args[0].text == \"DELETE FROM example\"            custom_properties = modin_properties.copy()          custom_properties.pop(\"db_extra_args\")          dn = SQLDataNode(\"foo_bar\", Scope.SCENARIO, properties=custom_properties)          with patch(\"sqlalchemy.engine.Engine.connect\") as engine_mock:              # mock connection execute              dn.write(modin_pd.DataFrame({\"foo\": [1, 2, 3], \"bar\": [4, 5, 6]}))              assert len(engine_mock.mock_calls[4].args) == 1              assert engine_mock.mock_calls[4].args[0].text == \"DELETE FROM example\"              assert len(engine_mock.mock_calls[5].args) == 2              assert engine_mock.mock_calls[5].args[0].text == \"INSERT INTO example VALUES (:foo, :bar)\"              assert engine_mock.mock_calls[5].args[1] == [                  {\"foo\": 1, \"bar\": 4},                  {\"foo\": 2, \"bar\": 5},                  {\"foo\": 3, \"bar\": 6},              ]            custom_properties[\"write_query_builder\"] = single_write_query_builder          dn = SQLDataNode(\"foo_bar\", Scope.SCENARIO, properties=custom_properties)            with patch(\"sqlalchemy.engine.Engine.connect\") as engine_mock:              # mock connection execute              dn.write(modin_pd.DataFrame({\"foo\": [1, 2, 3], \"bar\": [4, 5, 6]}))              assert len(engine_mock.mock_calls[4].args) == 1              assert engine_mock.mock_calls[4].args[0].text == \"DELETE FROM example\"        @pytest.mark.parametrize(          \"tmp_sqlite_path\",          [              \"tmp_sqlite_db_file_path\",              \"tmp_sqlite_sqlite3_file_path\",          ],      )      def test_sqlite_read_file_with_different_extension(self, tmp_sqlite_path, request):          tmp_sqlite_path = request.getfixturevalue(tmp_sqlite_path)          folder_path, db_name, file_extension = tmp_sqlite_path          properties = {              \"db_engine\": \"sqlite\",              \"read_query\": \"SELECT * from example\",              \"write_query_builder\": single_write_query_builder,              \"db_name\": db_name,              \"sqlite_folder_path\": folder_path,              \"sqlite_file_extension\": file_extension,          }            dn = SQLDataNode(\"sqlite_dn\", Scope.SCENARIO, properties=properties)          data = dn.read()          assert data.equals(pd.DataFrame([{\"foo\": 1, \"bar\": 2}, {\"foo\": 3, \"bar\": 4}]))        def test_sqlite_append_pandas(self, tmp_sqlite_sqlite3_file_path):          folder_path, db_name, file_extension = tmp_sqlite_sqlite3_file_path          properties = {              \"db_engine\": \"sqlite\",              \"read_query\": \"SELECT * FROM example\",              \"write_query_builder\": my_write_query_builder_with_pandas,              \"append_query_builder\": my_append_query_builder_with_pandas,              \"db_name\": db_name,              \"sqlite_folder_path\": folder_path,              \"sqlite_file_extension\": file_extension,          }            dn = SQLDataNode(\"sqlite_dn\", Scope.SCENARIO, properties=properties)          original_data = pd.DataFrame([{\"foo\": 1, \"bar\": 2}, {\"foo\": 3, \"bar\": 4}])          data = dn.read()          assert_frame_equal(data, original_data)            append_data_1 = pd.DataFrame([{\"foo\": 5, \"bar\": 6}, {\"foo\": 7, \"bar\": 8}])          dn.append(append_data_1)          assert_frame_equal(dn.read(), pd.concat([original_data, append_data_1]).reset_index(drop=True))        def test_sqlite_append_modin(self, tmp_sqlite_sqlite3_file_path):          folder_path, db_name, file_extension = tmp_sqlite_sqlite3_file_path          properties = {              \"db_engine\": \"sqlite\",              \"read_query\": \"SELECT * FROM example\",              \"write_query_builder\": my_write_query_builder_with_pandas,              \"append_query_builder\": my_append_query_builder_with_pandas,              \"db_name\": db_name,              \"sqlite_folder_path\": folder_path,              \"sqlite_file_extension\": file_extension,              \"exposed_type\": \"modin\",          }            dn = SQLDataNode(\"sqlite_dn\", Scope.SCENARIO, properties=properties)          original_data = modin_pd.DataFrame([{\"foo\": 1, \"bar\": 2}, {\"foo\": 3, \"bar\": 4}])          data = dn.read()          df_equals(data, original_data)            append_data_1 = modin_pd.DataFrame([{\"foo\": 5, \"bar\": 6}, {\"foo\": 7, \"bar\": 8}])          dn.append(append_data_1)          df_equals(dn.read(), modin_pd.concat([original_data, append_data_1]).reset_index(drop=True))        def test_sqlite_append_without_append_query_builder(self, tmp_sqlite_sqlite3_file_path):          folder_path, db_name, file_extension = tmp_sqlite_sqlite3_file_path          properties = {              \"db_engine\": \"sqlite\",              \"read_query\": \"SELECT * FROM example\",              \"write_query_builder\": my_write_query_builder_with_pandas,              \"db_name\": db_name,              \"sqlite_folder_path\": folder_path,              \"sqlite_file_extension\": file_extension,          }            dn = SQLDataNode(\"sqlite_dn\", Scope.SCENARIO, properties=properties)          with pytest.raises(MissingAppendQueryBuilder):              dn.append(pd.DataFrame([{\"foo\": 1, \"bar\": 2}, {\"foo\": 3, \"bar\": 4}]))        def test_filter_pandas_exposed_type(self, tmp_sqlite_sqlite3_file_path):          folder_path, db_name, file_extension = tmp_sqlite_sqlite3_file_path          properties = {              \"db_engine\": \"sqlite\",              \"read_query\": \"SELECT * FROM example\",              \"write_query_builder\": my_write_query_builder_with_pandas,              \"db_name\": db_name,              \"sqlite_folder_path\": folder_path,              \"sqlite_file_extension\": file_extension,              \"exposed_type\": \"pandas\",          }          dn = SQLDataNode(\"foo\", Scope.SCENARIO, properties=properties)          dn.write(              pd.DataFrame(                  [                      {\"foo\": 1, \"bar\": 1},                      {\"foo\": 1, \"bar\": 2},                      {\"foo\": 1, \"bar\": 3},                      {\"foo\": 2, \"bar\": 1},                      {\"foo\": 2, \"bar\": 2},                      {\"foo\": 2, \"bar\": 3},                  ]              )          )            # Test datanode indexing and slicing          assert dn[\"foo\"].equals(pd.Series([1, 1, 1, 2, 2, 2]))          assert dn[\"bar\"].equals(pd.Series([1, 2, 3, 1, 2, 3]))          assert dn[:2].equals(pd.DataFrame([{\"foo\": 1, \"bar\": 1}, {\"foo\": 1, \"bar\": 2}]))            # Test filter data          filtered_by_filter_method = dn.filter((\"foo\", 1, Operator.EQUAL))          filtered_by_indexing = dn[dn[\"foo\"] == 1]          expected_data = pd.DataFrame([{\"foo\": 1, \"bar\": 1}, {\"foo\": 1, \"bar\": 2}, {\"foo\": 1, \"bar\": 3}])          assert_frame_equal(filtered_by_filter_method.reset_index(drop=True), expected_data)          assert_frame_equal(filtered_by_indexing.reset_index(drop=True), expected_data)            filtered_by_filter_method = dn.filter((\"foo\", 1, Operator.NOT_EQUAL))          filtered_by_indexing = dn[dn[\"foo\"] != 1]          expected_data = pd.DataFrame([{\"foo\": 2, \"bar\": 1}, {\"foo\": 2, \"bar\": 2}, {\"foo\": 2, \"bar\": 3}])          assert_frame_equal(filtered_by_filter_method.reset_index(drop=True), expected_data)          assert_frame_equal(filtered_by_indexing.reset_index(drop=True), expected_data)            filtered_by_filter_method = dn.filter([(\"bar\", 1, Operator.EQUAL), (\"bar\", 2, Operator.EQUAL)], JoinOperator.OR)          filtered_by_indexing = dn[(dn[\"bar\"] == 1) | (dn[\"bar\"] == 2)]          expected_data = pd.DataFrame(              [                  {\"foo\": 1, \"bar\": 1},                  {\"foo\": 1, \"bar\": 2},                  {\"foo\": 2, \"bar\": 1},                  {\"foo\": 2, \"bar\": 2},              ]          )          assert_frame_equal(filtered_by_filter_method.reset_index(drop=True), expected_data)          assert_frame_equal(filtered_by_indexing.reset_index(drop=True), expected_data)        def test_filter_modin_exposed_type(self, tmp_sqlite_sqlite3_file_path):          folder_path, db_name, file_extension = tmp_sqlite_sqlite3_file_path          properties = {              \"db_engine\": \"sqlite\",              \"read_query\": \"SELECT * FROM example\",              \"write_query_builder\": my_write_query_builder_with_modin,              \"db_name\": db_name,              \"sqlite_folder_path\": folder_path,              \"sqlite_file_extension\": file_extension,              \"exposed_type\": \"modin\",          }          dn = SQLDataNode(\"foo\", Scope.SCENARIO, properties=properties)          dn.write(              pd.DataFrame(                  [                      {\"foo\": 1, \"bar\": 1},                      {\"foo\": 1, \"bar\": 2},                      {\"foo\": 1, \"bar\": 3},                      {\"foo\": 2, \"bar\": 1},                      {\"foo\": 2, \"bar\": 2},                      {\"foo\": 2, \"bar\": 3},                  ]              )          )            # Test datanode indexing and slicing          assert dn[\"foo\"].equals(pd.Series([1, 1, 1, 2, 2, 2]))          assert dn[\"bar\"].equals(pd.Series([1, 2, 3, 1, 2, 3]))          assert dn[:2].equals(modin_pd.DataFrame([{\"foo\": 1, \"bar\": 1}, {\"foo\": 1, \"bar\": 2}]))            # Test filter data          filtered_by_filter_method = dn.filter((\"foo\", 1, Operator.EQUAL))          filtered_by_indexing = dn[dn[\"foo\"] == 1]          expected_data = modin_pd.DataFrame([{\"foo\": 1, \"bar\": 1}, {\"foo\": 1, \"bar\": 2}, {\"foo\": 1, \"bar\": 3}])          df_equals(filtered_by_filter_method.reset_index(drop=True), expected_data)          df_equals(filtered_by_indexing.reset_index(drop=True), expected_data)            filtered_by_filter_method = dn.filter((\"foo\", 1, Operator.NOT_EQUAL))          filtered_by_indexing = dn[dn[\"foo\"] != 1]          expected_data = modin_pd.DataFrame([{\"foo\": 2, \"bar\": 1}, {\"foo\": 2, \"bar\": 2}, {\"foo\": 2, \"bar\": 3}])          df_equals(filtered_by_filter_method.reset_index(drop=True), expected_data)          df_equals(filtered_by_indexing.reset_index(drop=True), expected_data)            filtered_by_filter_method = dn.filter([(\"bar\", 1, Operator.EQUAL), (\"bar\", 2, Operator.EQUAL)], JoinOperator.OR)          filtered_by_indexing = dn[(dn[\"bar\"] == 1) | (dn[\"bar\"] == 2)]          expected_data = modin_pd.DataFrame(              [                  {\"foo\": 1, \"bar\": 1},                  {\"foo\": 1, \"bar\": 2},                  {\"foo\": 2, \"bar\": 1},                  {\"foo\": 2, \"bar\": 2},              ]          )          df_equals(filtered_by_filter_method.reset_index(drop=True), expected_data)          df_equals(filtered_by_indexing.reset_index(drop=True), expected_data)        def test_filter_numpy_exposed_type(self, tmp_sqlite_sqlite3_file_path):          folder_path, db_name, file_extension = tmp_sqlite_sqlite3_file_path          properties = {              \"db_engine\": \"sqlite\",              \"read_query\": \"SELECT * FROM example\",              \"write_query_builder\": my_write_query_builder_with_pandas,              \"db_name\": db_name,              \"sqlite_folder_path\": folder_path,              \"sqlite_file_extension\": file_extension,              \"exposed_type\": \"numpy\",          }          dn = SQLDataNode(\"foo\", Scope.SCENARIO, properties=properties)          dn.write(              pd.DataFrame(                  [                      {\"foo\": 1, \"bar\": 1},                      {\"foo\": 1, \"bar\": 2},                      {\"foo\": 1, \"bar\": 3},                      {\"foo\": 2, \"bar\": 1},                      {\"foo\": 2, \"bar\": 2},                      {\"foo\": 2, \"bar\": 3},                  ]              )          )            # Test datanode indexing and slicing          assert np.array_equal(dn[0], np.array([1, 1]))          assert np.array_equal(dn[1], np.array([1, 2]))          assert np.array_equal(dn[:3], np.array([[1, 1], [1, 2], [1, 3]]))          assert np.array_equal(dn[:, 0], np.array([1, 1, 1, 2, 2, 2]))          assert np.array_equal(dn[1:4, :1], np.array([[1], [1], [2]]))            # Test filter data          assert np.array_equal(dn.filter((\"foo\", 1, Operator.EQUAL)), np.array([[1, 1], [1, 2], [1, 3]]))          assert np.array_equal(dn[dn[:, 0] == 1], np.array([[1, 1], [1, 2], [1, 3]]))            assert np.array_equal(dn.filter((\"foo\", 1, Operator.NOT_EQUAL)), np.array([[2, 1], [2, 2], [2, 3]]))          assert np.array_equal(dn[dn[:, 0] != 1], np.array([[2, 1], [2, 2], [2, 3]]))            assert np.array_equal(dn.filter((\"bar\", 2, Operator.EQUAL)), np.array([[1, 2], [2, 2]]))          assert np.array_equal(dn[dn[:, 1] == 2], np.array([[1, 2], [2, 2]]))            assert np.array_equal(              dn.filter([(\"bar\", 1, Operator.EQUAL), (\"bar\", 2, Operator.EQUAL)], JoinOperator.OR),              np.array([[1, 1], [1, 2], [2, 1], [2, 2]]),          )          assert np.array_equal(dn[(dn[:, 1] == 1) | (dn[:, 1] == 2)], np.array([[1, 1], [1, 2], [2, 1], [2, 2]]))        def test_filter_does_not_read_all_entities(self, tmp_sqlite_sqlite3_file_path):          folder_path, db_name, file_extension = tmp_sqlite_sqlite3_file_path          properties = {              \"db_engine\": \"sqlite\",              \"read_query\": \"SELECT * FROM example\",              \"write_query_builder\": my_write_query_builder_with_pandas,              \"db_name\": db_name,              \"sqlite_folder_path\": folder_path,              \"sqlite_file_extension\": file_extension,              \"exposed_type\": \"numpy\",          }          dn = SQLDataNode(\"foo\", Scope.SCENARIO, properties=properties)            # SQLDataNode.filter() should not call the MongoCollectionDataNode._read() method          with patch.object(SQLDataNode, \"_read\") as read_mock:              dn.filter((\"foo\", 1, Operator.EQUAL))              dn.filter((\"bar\", 2, Operator.NOT_EQUAL))              dn.filter([(\"bar\", 1, Operator.EQUAL), (\"bar\", 2, Operator.EQUAL)], JoinOperator.OR)                assert read_mock[\"_read\"].call_count == 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.  import os  import pathlib    import pytest    from src.taipy.core._version._version_manager import _VersionManager  from src.taipy.core.config.data_node_config import DataNodeConfig  from src.taipy.core.data._data_manager import _DataManager  from src.taipy.core.data.csv import CSVDataNode  from src.taipy.core.data.data_node_id import DataNodeId  from src.taipy.core.data.in_memory import InMemoryDataNode  from src.taipy.core.data.pickle import PickleDataNode  from src.taipy.core.exceptions.exceptions import InvalidDataNodeType, ModelNotFound  from taipy.config.common.scope import Scope  from taipy.config.config import Config  from tests.core.utils.named_temporary_file import NamedTemporaryFile      def file_exists(file_path: str) -> bool:      return os.path.exists(file_path)      class TestDataManager:      def test_create_data_node_and_modify_properties_does_not_modify_config(self):          dn_config = Config.configure_data_node(id=\"name\", foo=\"bar\")          dn = _DataManager._create_and_set(dn_config, None, None)          assert dn_config.properties.get(\"foo\") == \"bar\"          assert dn_config.properties.get(\"baz\") is None            dn.properties[\"baz\"] = \"qux\"          _DataManager._set(dn)          assert dn_config.properties.get(\"foo\") == \"bar\"          assert dn_config.properties.get(\"baz\") is None          assert dn.properties.get(\"foo\") == \"bar\"          assert dn.properties.get(\"baz\") == \"qux\"        def test_create_data_node_with_name_provided(self):          dn_config = Config.configure_data_node(id=\"dn\", foo=\"bar\", name=\"acb\")          dn = _DataManager._create_and_set(dn_config, None, None)          assert dn.name == \"acb\"        def test_create_and_get_csv_data_node(self):          # Test we can instantiate a CsvDataNode from DataNodeConfig with :          # - a csv type          # - a default scenario scope          # - No owner_id          csv_dn_config = Config.configure_data_node(id=\"foo\", storage_type=\"csv\", path=\"bar\", has_header=True)          csv_dn = _DataManager._create_and_set(csv_dn_config, None, None)            assert isinstance(csv_dn, CSVDataNode)          assert isinstance(_DataManager._get(csv_dn.id), CSVDataNode)            assert _DataManager._exists(csv_dn.id)          assert _DataManager._get(csv_dn.id) is not None          assert _DataManager._get(csv_dn.id).id == csv_dn.id          assert _DataManager._get(csv_dn.id).config_id == \"foo\"          assert _DataManager._get(csv_dn.id).config_id == csv_dn.config_id          assert _DataManager._get(csv_dn.id).scope == Scope.SCENARIO          assert _DataManager._get(csv_dn.id).scope == csv_dn.scope          assert _DataManager._get(csv_dn.id).owner_id is None          assert _DataManager._get(csv_dn.id).owner_id == csv_dn.owner_id          assert _DataManager._get(csv_dn.id).parent_ids == set()          assert _DataManager._get(csv_dn.id).parent_ids == csv_dn.parent_ids          assert _DataManager._get(csv_dn.id).last_edit_date is None          assert _DataManager._get(csv_dn.id).last_edit_date == csv_dn.last_edit_date          assert _DataManager._get(csv_dn.id).job_ids == []          assert _DataManager._get(csv_dn.id).job_ids == csv_dn.job_ids          assert not _DataManager._get(csv_dn.id).is_ready_for_reading          assert _DataManager._get(csv_dn.id).is_ready_for_reading == csv_dn.is_ready_for_reading          assert len(_DataManager._get(csv_dn.id).properties) == 4          assert _DataManager._get(csv_dn.id).properties.get(\"path\") == \"bar\"          assert _DataManager._get(csv_dn.id).properties.get(\"encoding\") == \"utf-8\"          assert _DataManager._get(csv_dn.id).properties.get(\"has_header\") is True          assert _DataManager._get(csv_dn.id).properties.get(\"exposed_type\") == \"pandas\"          assert _DataManager._get(csv_dn.id).properties == csv_dn.properties          assert _DataManager._get(csv_dn.id).edit_in_progress is False          assert _DataManager._get(csv_dn.id)._editor_id is None          assert _DataManager._get(csv_dn.id)._editor_expiration_date is None            assert _DataManager._get(csv_dn) is not None          assert _DataManager._get(csv_dn).id == csv_dn.id          assert _DataManager._get(csv_dn).config_id == \"foo\"          assert _DataManager._get(csv_dn).config_id == csv_dn.config_id          assert _DataManager._get(csv_dn).scope == Scope.SCENARIO          assert _DataManager._get(csv_dn).scope == csv_dn.scope          assert _DataManager._get(csv_dn).owner_id is None          assert _DataManager._get(csv_dn).owner_id == csv_dn.owner_id          assert _DataManager._get(csv_dn).parent_ids == set()          assert _DataManager._get(csv_dn).parent_ids == csv_dn.parent_ids          assert _DataManager._get(csv_dn).last_edit_date is None          assert _DataManager._get(csv_dn).last_edit_date == csv_dn.last_edit_date          assert _DataManager._get(csv_dn).job_ids == []          assert _DataManager._get(csv_dn).job_ids == csv_dn.job_ids          assert not _DataManager._get(csv_dn).is_ready_for_reading          assert _DataManager._get(csv_dn).is_ready_for_reading == csv_dn.is_ready_for_reading          assert len(_DataManager._get(csv_dn).properties) == 4          assert _DataManager._get(csv_dn).properties.get(\"path\") == \"bar\"          assert _DataManager._get(csv_dn).properties.get(\"encoding\") == \"utf-8\"          assert _DataManager._get(csv_dn).properties.get(\"has_header\") is True          assert _DataManager._get(csv_dn.id).properties.get(\"exposed_type\") == \"pandas\"          assert _DataManager._get(csv_dn).properties == csv_dn.properties          assert _DataManager._get(csv_dn.id).edit_in_progress is False          assert _DataManager._get(csv_dn.id)._editor_id is None          assert _DataManager._get(csv_dn.id)._editor_expiration_date is None        def test_edit_and_get_data_node(self):          config = Config.configure_pickle_data_node(id=\"foo\")          dn = _DataManager._create_and_set(config, None, None)            assert _DataManager._get(dn.id).last_edit_date is None          assert len(_DataManager._get(dn.id).properties) == 1          assert _DataManager._get(dn.id).properties.get(\"is_generated\")          assert not _DataManager._get(dn.id).edit_in_progress          assert _DataManager._get(dn.id)._editor_id is None          assert _DataManager._get(dn.id)._editor_expiration_date is None            dn.lock_edit(\"foo\")            assert _DataManager._get(dn.id).last_edit_date is None          assert len(_DataManager._get(dn.id).properties) == 1          assert _DataManager._get(dn.id).properties.get(\"is_generated\")          assert _DataManager._get(dn.id).edit_in_progress          assert _DataManager._get(dn.id).editor_id == \"foo\"          assert _DataManager._get(dn.id).editor_expiration_date is not None            dn.unlock_edit(\"foo\")            assert _DataManager._get(dn.id).last_edit_date is None          assert len(_DataManager._get(dn.id).properties) == 1          assert _DataManager._get(dn.id).properties.get(\"is_generated\")          assert not _DataManager._get(dn.id).edit_in_progress          assert _DataManager._get(dn.id).editor_id is None          assert _DataManager._get(dn.id).editor_expiration_date is None        def test_create_and_get_in_memory_data_node(self):          # Test we can instantiate an InMemoryDataNode from DataNodeConfig with :          # - an in_memory type          # - a scenario scope          # - an owner id          # - some default data          in_memory_dn_config = Config.configure_data_node(              id=\"baz\", storage_type=\"in_memory\", scope=Scope.SCENARIO, default_data=\"qux\", other_data=\"foo\"          )          in_mem_dn = _DataManager._create_and_set(in_memory_dn_config, \"Scenario_id\", {\"task_id\"})            assert isinstance(in_mem_dn, InMemoryDataNode)          assert isinstance(_DataManager._get(in_mem_dn.id), InMemoryDataNode)            assert _DataManager._exists(in_mem_dn.id)          assert _DataManager._get(in_mem_dn.id) is not None          assert _DataManager._get(in_mem_dn.id).id == in_mem_dn.id          assert _DataManager._get(in_mem_dn.id).config_id == \"baz\"          assert _DataManager._get(in_mem_dn.id).config_id == in_mem_dn.config_id          assert _DataManager._get(in_mem_dn.id).scope == Scope.SCENARIO          assert _DataManager._get(in_mem_dn.id).scope == in_mem_dn.scope          assert _DataManager._get(in_mem_dn.id).owner_id == \"Scenario_id\"          assert _DataManager._get(in_mem_dn.id).owner_id == in_mem_dn.owner_id          assert _DataManager._get(in_mem_dn.id).parent_ids == {\"task_id\"}          assert _DataManager._get(in_mem_dn.id).parent_ids == in_mem_dn.parent_ids          assert _DataManager._get(in_mem_dn.id).last_edit_date is not None          assert _DataManager._get(in_mem_dn.id).last_edit_date == in_mem_dn.last_edit_date          assert _DataManager._get(in_mem_dn.id).job_ids == []          assert _DataManager._get(in_mem_dn.id).job_ids == in_mem_dn.job_ids          assert _DataManager._get(in_mem_dn.id).is_ready_for_reading          assert _DataManager._get(in_mem_dn.id).is_ready_for_reading == in_mem_dn.is_ready_for_reading          assert len(_DataManager._get(in_mem_dn.id).properties) == 1          assert _DataManager._get(in_mem_dn.id).properties.get(\"other_data\") == \"foo\"          assert _DataManager._get(in_mem_dn.id).properties == in_mem_dn.properties            assert _DataManager._get(in_mem_dn) is not None          assert _DataManager._get(in_mem_dn).id == in_mem_dn.id          assert _DataManager._get(in_mem_dn).config_id == \"baz\"          assert _DataManager._get(in_mem_dn).config_id == in_mem_dn.config_id          assert _DataManager._get(in_mem_dn).scope == Scope.SCENARIO          assert _DataManager._get(in_mem_dn).scope == in_mem_dn.scope          assert _DataManager._get(in_mem_dn).owner_id == \"Scenario_id\"          assert _DataManager._get(in_mem_dn).owner_id == in_mem_dn.owner_id          assert _DataManager._get(in_mem_dn).parent_ids == {\"task_id\"}          assert _DataManager._get(in_mem_dn).parent_ids == in_mem_dn.parent_ids          assert _DataManager._get(in_mem_dn).last_edit_date is not None          assert _DataManager._get(in_mem_dn).last_edit_date == in_mem_dn.last_edit_date          assert _DataManager._get(in_mem_dn).job_ids == []          assert _DataManager._get(in_mem_dn).job_ids == in_mem_dn.job_ids          assert _DataManager._get(in_mem_dn).is_ready_for_reading          assert _DataManager._get(in_mem_dn).is_ready_for_reading == in_mem_dn.is_ready_for_reading          assert len(_DataManager._get(in_mem_dn).properties) == 1          assert _DataManager._get(in_mem_dn).properties.get(\"other_data\") == \"foo\"          assert _DataManager._get(in_mem_dn).properties == in_mem_dn.properties        def test_create_and_get_pickle_data_node(self):          # Test we can instantiate a PickleDataNode from DataNodeConfig with :          # - an in_memory type          # - a business cycle scope          # - No owner id          # - no default data          dn_config = Config.configure_data_node(id=\"plop\", storage_type=\"pickle\", scope=Scope.CYCLE)          pickle_dn = _DataManager._create_and_set(dn_config, None, {\"task_id_1\", \"task_id_2\"})            assert isinstance(pickle_dn, PickleDataNode)          assert isinstance(_DataManager._get(pickle_dn.id), PickleDataNode)            assert _DataManager._exists(pickle_dn.id)          assert _DataManager._get(pickle_dn.id) is not None          assert _DataManager._get(pickle_dn.id).id == pickle_dn.id          assert _DataManager._get(pickle_dn.id).config_id == \"plop\"          assert _DataManager._get(pickle_dn.id).config_id == pickle_dn.config_id          assert _DataManager._get(pickle_dn.id).scope == Scope.CYCLE          assert _DataManager._get(pickle_dn.id).scope == pickle_dn.scope          assert _DataManager._get(pickle_dn.id).owner_id is None          assert _DataManager._get(pickle_dn.id).owner_id == pickle_dn.owner_id          assert _DataManager._get(pickle_dn.id).parent_ids == {\"task_id_1\", \"task_id_2\"}          assert _DataManager._get(pickle_dn.id).parent_ids == pickle_dn.parent_ids          assert _DataManager._get(pickle_dn.id).last_edit_date is None          assert _DataManager._get(pickle_dn.id).last_edit_date == pickle_dn.last_edit_date          assert _DataManager._get(pickle_dn.id).job_ids == []          assert _DataManager._get(pickle_dn.id).job_ids == pickle_dn.job_ids          assert not _DataManager._get(pickle_dn.id).is_ready_for_reading          assert _DataManager._get(pickle_dn.id).is_ready_for_reading == pickle_dn.is_ready_for_reading          assert len(_DataManager._get(pickle_dn.id).properties) == 1          assert _DataManager._get(pickle_dn.id).properties == pickle_dn.properties            assert _DataManager._get(pickle_dn) is not None          assert _DataManager._get(pickle_dn).id == pickle_dn.id          assert _DataManager._get(pickle_dn).config_id == \"plop\"          assert _DataManager._get(pickle_dn).config_id == pickle_dn.config_id          assert _DataManager._get(pickle_dn).scope == Scope.CYCLE          assert _DataManager._get(pickle_dn).scope == pickle_dn.scope          assert _DataManager._get(pickle_dn).owner_id is None          assert _DataManager._get(pickle_dn).owner_id == pickle_dn.owner_id          assert _DataManager._get(pickle_dn).parent_ids == {\"task_id_1\", \"task_id_2\"}          assert _DataManager._get(pickle_dn).parent_ids == pickle_dn.parent_ids          assert _DataManager._get(pickle_dn).last_edit_date is None          assert _DataManager._get(pickle_dn).last_edit_date == pickle_dn.last_edit_date          assert _DataManager._get(pickle_dn).job_ids == []          assert _DataManager._get(pickle_dn).job_ids == pickle_dn.job_ids          assert not _DataManager._get(pickle_dn).is_ready_for_reading          assert _DataManager._get(pickle_dn).is_ready_for_reading == pickle_dn.is_ready_for_reading          assert len(_DataManager._get(pickle_dn).properties) == 1          assert _DataManager._get(pickle_dn).properties == pickle_dn.properties        def test_create_raises_exception_with_wrong_type(self):          wrong_type_dn_config = DataNodeConfig(id=\"foo\", storage_type=\"bar\", scope=DataNodeConfig._DEFAULT_SCOPE)          with pytest.raises(InvalidDataNodeType):              _DataManager._create_and_set(wrong_type_dn_config, None, None)        def test_create_from_same_config_generates_new_data_node_and_new_id(self):          dn_config = Config.configure_data_node(id=\"foo\", storage_type=\"in_memory\")          dn = _DataManager._create_and_set(dn_config, None, None)          dn_2 = _DataManager._create_and_set(dn_config, None, None)          assert dn_2.id != dn.id        def test_create_uses_overridden_attributes_in_config_file(self):          Config.override(os.path.join(pathlib.Path(__file__).parent.resolve(), \"data_sample/config.toml\"))            csv_dn_cfg = Config.configure_data_node(id=\"foo\", storage_type=\"csv\", path=\"bar\", has_header=True)          csv_dn = _DataManager._create_and_set(csv_dn_cfg, None, None)          assert csv_dn.config_id == \"foo\"          assert isinstance(csv_dn, CSVDataNode)          assert csv_dn._path == \"path_from_config_file\"          assert csv_dn.has_header            csv_dn_cfg = Config.configure_data_node(id=\"baz\", storage_type=\"csv\", path=\"bar\", has_header=True)          csv_dn = _DataManager._create_and_set(csv_dn_cfg, None, None)          assert csv_dn.config_id == \"baz\"          assert isinstance(csv_dn, CSVDataNode)          assert csv_dn._path == \"bar\"          assert csv_dn.has_header        def test_get_if_not_exists(self):          with pytest.raises(ModelNotFound):              _DataManager._repository._load(\"test_data_node_2\")        def test_get_all(self):          assert len(_DataManager._get_all()) == 0          dn_config_1 = Config.configure_data_node(id=\"foo\", storage_type=\"in_memory\")          _DataManager._create_and_set(dn_config_1, None, None)          assert len(_DataManager._get_all()) == 1          dn_config_2 = Config.configure_data_node(id=\"baz\", storage_type=\"in_memory\")          _DataManager._create_and_set(dn_config_2, None, None)          _DataManager._create_and_set(dn_config_2, None, None)          assert len(_DataManager._get_all()) == 3          assert len([dn for dn in _DataManager._get_all() if dn.config_id == \"foo\"]) == 1          assert len([dn for dn in _DataManager._get_all() if dn.config_id == \"baz\"]) == 2        def test_get_all_on_multiple_versions_environment(self):          # Create 5 data nodes with 2 versions each          # Only version 1.0 has the data node with config_id = \"config_id_1\"          # Only version 2.0 has the data node with config_id = \"config_id_6\"          for version in range(1, 3):              for i in range(5):                  _DataManager._set(                      InMemoryDataNode(                          f\"config_id_{i + version}\",                          Scope.SCENARIO,                          id=DataNodeId(f\"id{i}_v{version}\"),                          version=f\"{version}.0\",                      )                  )            _VersionManager._set_experiment_version(\"1.0\")          assert len(_DataManager._get_all()) == 5          assert len(_DataManager._get_all_by(filters=[{\"version\": \"1.0\", \"config_id\": \"config_id_1\"}])) == 1          assert len(_DataManager._get_all_by(filters=[{\"version\": \"1.0\", \"config_id\": \"config_id_6\"}])) == 0            _VersionManager._set_development_version(\"1.0\")          assert len(_DataManager._get_all()) == 5          assert len(_DataManager._get_all_by(filters=[{\"version\": \"1.0\", \"config_id\": \"config_id_1\"}])) == 1          assert len(_DataManager._get_all_by(filters=[{\"version\": \"1.0\", \"config_id\": \"config_id_6\"}])) == 0            _VersionManager._set_experiment_version(\"2.0\")          assert len(_DataManager._get_all()) == 5          assert len(_DataManager._get_all_by(filters=[{\"version\": \"2.0\", \"config_id\": \"config_id_1\"}])) == 0          assert len(_DataManager._get_all_by(filters=[{\"version\": \"2.0\", \"config_id\": \"config_id_6\"}])) == 1            _VersionManager._set_development_version(\"2.0\")          assert len(_DataManager._get_all()) == 5          assert len(_DataManager._get_all_by(filters=[{\"version\": \"2.0\", \"config_id\": \"config_id_1\"}])) == 0          assert len(_DataManager._get_all_by(filters=[{\"version\": \"2.0\", \"config_id\": \"config_id_6\"}])) == 1        def test_set(self):          dn = InMemoryDataNode(              \"config_id\",              Scope.SCENARIO,              id=DataNodeId(\"id\"),              owner_id=None,              parent_ids={\"task_id_1\"},              last_edit_date=None,              edits=[],              edit_in_progress=False,              properties={\"foo\": \"bar\"},          )          assert len(_DataManager._get_all()) == 0          assert not _DataManager._exists(dn.id)          _DataManager._set(dn)          assert len(_DataManager._get_all()) == 1          assert _DataManager._exists(dn.id)            # changing data node attribute          dn.config_id = \"foo\"          assert dn.config_id == \"foo\"          _DataManager._set(dn)          assert len(_DataManager._get_all()) == 1          assert dn.config_id == \"foo\"          assert _DataManager._get(dn.id).config_id == \"foo\"        def test_delete(self):          dn_1 = InMemoryDataNode(\"config_id\", Scope.SCENARIO, id=\"id_1\")          dn_2 = InMemoryDataNode(\"config_id\", Scope.SCENARIO, id=\"id_2\")          dn_3 = InMemoryDataNode(\"config_id\", Scope.SCENARIO, id=\"id_3\")          assert len(_DataManager._get_all()) == 0          _DataManager._set(dn_1)          _DataManager._set(dn_2)          _DataManager._set(dn_3)          assert len(_DataManager._get_all()) == 3          assert all(_DataManager._exists(dn.id) for dn in [dn_1, dn_2, dn_3])          _DataManager._delete(dn_1.id)          assert len(_DataManager._get_all()) == 2          assert _DataManager._get(dn_2.id).id == dn_2.id          assert _DataManager._get(dn_3.id).id == dn_3.id          assert _DataManager._get(dn_1.id) is None          assert all(_DataManager._exists(dn.id) for dn in [dn_2, dn_3])          assert not _DataManager._exists(dn_1.id)          _DataManager._delete_all()          assert len(_DataManager._get_all()) == 0          assert not any(_DataManager._exists(dn.id) for dn in [dn_2, dn_3])        def test_get_or_create(self):          def _get_or_create_dn(config, *args):              return _DataManager._bulk_get_or_create([config], *args)[config]            _DataManager._delete_all()            global_dn_config = Config.configure_data_node(              id=\"test_data_node\", storage_type=\"in_memory\", scope=Scope.GLOBAL, data=\"In memory Data Node\"          )          cycle_dn_config = Config.configure_data_node(              id=\"test_data_node1\", storage_type=\"in_memory\", scope=Scope.CYCLE, data=\"In memory Data Node\"          )          scenario_dn_config = Config.configure_data_node(              id=\"test_data_node2\", storage_type=\"in_memory\", scope=Scope.SCENARIO, data=\"In memory scenario\"          )            assert len(_DataManager._get_all()) == 0          global_dn = _get_or_create_dn(global_dn_config, None, None)          assert len(_DataManager._get_all()) == 1          global_dn_bis = _get_or_create_dn(global_dn_config, None)          assert len(_DataManager._get_all()) == 1          assert global_dn.id == global_dn_bis.id            scenario_dn = _get_or_create_dn(scenario_dn_config, None, \"scenario_id\")          assert len(_DataManager._get_all()) == 2          scenario_dn_bis = _get_or_create_dn(scenario_dn_config, None, \"scenario_id\")          assert len(_DataManager._get_all()) == 2          assert scenario_dn.id == scenario_dn_bis.id          scenario_dn_ter = _get_or_create_dn(scenario_dn_config, None, \"scenario_id\")          assert len(_DataManager._get_all()) == 2          assert scenario_dn.id == scenario_dn_bis.id          assert scenario_dn_bis.id == scenario_dn_ter.id          scenario_dn_quater = _get_or_create_dn(scenario_dn_config, None, \"scenario_id_2\")          assert len(_DataManager._get_all()) == 3          assert scenario_dn.id == scenario_dn_bis.id          assert scenario_dn_bis.id == scenario_dn_ter.id          assert scenario_dn_ter.id != scenario_dn_quater.id            assert len(_DataManager._get_all()) == 3          cycle_dn = _get_or_create_dn(cycle_dn_config, \"cycle_id\", None)          assert len(_DataManager._get_all()) == 4          cycle_dn_1 = _get_or_create_dn(cycle_dn_config, \"cycle_id\", None)          assert len(_DataManager._get_all()) == 4          assert cycle_dn.id == cycle_dn_1.id          cycle_dn_2 = _get_or_create_dn(cycle_dn_config, \"cycle_id\", \"scenario_id\")          assert len(_DataManager._get_all()) == 4          assert cycle_dn.id == cycle_dn_2.id          cycle_dn_3 = _get_or_create_dn(cycle_dn_config, \"cycle_id\", None)          assert len(_DataManager._get_all()) == 4          assert cycle_dn.id == cycle_dn_3.id          cycle_dn_4 = _get_or_create_dn(cycle_dn_config, \"cycle_id\", \"scenario_id\")          assert len(_DataManager._get_all()) == 4          assert cycle_dn.id == cycle_dn_4.id          cycle_dn_5 = _get_or_create_dn(cycle_dn_config, \"cycle_id\", \"scenario_id_2\")          assert len(_DataManager._get_all()) == 4          assert cycle_dn.id == cycle_dn_5.id            assert cycle_dn_1.id == cycle_dn_2.id          assert cycle_dn_2.id == cycle_dn_3.id          assert cycle_dn_3.id == cycle_dn_4.id          assert cycle_dn_4.id == cycle_dn_5.id        def test_ensure_persistence_of_data_node(self):          dm = _DataManager()          dm._delete_all()            dn_config_1 = Config.configure_data_node(              id=\"data_node_1\", storage_type=\"in_memory\", data=\"In memory sequence 2\"          )          dn_config_2 = Config.configure_data_node(              id=\"data_node_2\", storage_type=\"in_memory\", data=\"In memory sequence 2\"          )            dm._bulk_get_or_create([dn_config_1, dn_config_2])            assert len(dm._get_all()) == 2            # Delete the DataManager to ensure it's get from the storage system          del dm          dm = _DataManager()          dm._bulk_get_or_create([dn_config_1])          assert len(dm._get_all()) == 2            dm._delete_all()        def test_clean_generated_pickle_files(self, pickle_file_path):          user_pickle_dn_config = Config.configure_data_node(              id=\"d1\", storage_type=\"pickle\", path=pickle_file_path, default_data=\"d\"          )          generated_pickle_dn_1_config = Config.configure_data_node(id=\"d2\", storage_type=\"pickle\", default_data=\"d\")          generated_pickle_dn_2_config = Config.configure_data_node(id=\"d3\", storage_type=\"pickle\", default_data=\"d\")            dns = _DataManager._bulk_get_or_create(              [user_pickle_dn_config, generated_pickle_dn_1_config, generated_pickle_dn_2_config]          )            user_pickle_dn = dns[user_pickle_dn_config]          generated_pickle_dn_1 = dns[generated_pickle_dn_1_config]          generated_pickle_dn_2 = dns[generated_pickle_dn_2_config]            _DataManager._clean_pickle_file(user_pickle_dn.id)          assert file_exists(user_pickle_dn.path)            _DataManager._clean_pickle_files([generated_pickle_dn_1, generated_pickle_dn_2])          assert not file_exists(generated_pickle_dn_1.path)          assert not file_exists(generated_pickle_dn_2.path)        def test_delete_does_clean_generated_pickle_files(self, pickle_file_path):          user_pickle_dn_config = Config.configure_data_node(              id=\"d1\", storage_type=\"pickle\", path=pickle_file_path, default_data=\"d\"          )          generated_pickle_dn_config_1 = Config.configure_data_node(id=\"d2\", storage_type=\"pickle\", default_data=\"d\")          generated_pickle_dn_config_2 = Config.configure_data_node(id=\"d3\", storage_type=\"pickle\", default_data=\"d\")          generated_pickle_dn_config_3 = Config.configure_data_node(id=\"d4\", storage_type=\"pickle\", default_data=\"d\")            dns = _DataManager._bulk_get_or_create(              [                  user_pickle_dn_config,                  generated_pickle_dn_config_1,                  generated_pickle_dn_config_2,                  generated_pickle_dn_config_3,              ]          )            user_pickle_dn = dns[user_pickle_dn_config]          generated_pickle_dn_1 = dns[generated_pickle_dn_config_1]          generated_pickle_dn_2 = dns[generated_pickle_dn_config_2]          generated_pickle_dn_3 = dns[generated_pickle_dn_config_3]            _DataManager._delete(user_pickle_dn.id)          assert file_exists(user_pickle_dn.path)            _DataManager._delete_many([generated_pickle_dn_1.id, generated_pickle_dn_2.id])          assert not file_exists(generated_pickle_dn_1.path)          assert not file_exists(generated_pickle_dn_2.path)            _DataManager._delete_all()          assert not file_exists(generated_pickle_dn_3.path)        def test_create_dn_from_loaded_config_no_scope(self):          file_config = NamedTemporaryFile(              \"\"\"              [TAIPY]                [DATA_NODE.a]              default_data = \"4:int\"                [DATA_NODE.b]                [TASK.t]              function = \"math.sqrt:function\"              inputs = [ \"a:SECTION\",]              outputs = [ \"b:SECTION\",]              skippable = \"False:bool\"                [SCENARIO.s]              tasks = [ \"t:SECTION\",]              sequences.s_sequence = [ \"t:SECTION\",]                [SCENARIO.s.comparators]              \"\"\"          )          from src.taipy import core as tp            Config.override(file_config.filename)          tp.create_scenario(Config.scenarios[\"s\"])          tp.create_scenario(Config.scenarios[\"s\"])            assert len(tp.get_data_nodes()) == 4        def test_create_dn_from_loaded_config_no_storage_type(self):          file_config = NamedTemporaryFile(              \"\"\"              [TAIPY]                [DATA_NODE.input]              scope = \"SCENARIO:SCOPE\"              default_data = \"21:int\"                [DATA_NODE.output]              storage_type = \"in_memory\"              scope = \"SCENARIO:SCOPE\"                [TASK.double]              inputs = [ \"input:SECTION\",]              function = \"math.sqrt:function\"              outputs = [ \"output:SECTION\",]              skippable = \"False:bool\"                [SCENARIO.my_scenario]              tasks = [ \"double:SECTION\",]              sequences.my_sequence = [ \"double:SECTION\",]                [SCENARIO.my_scenario.comparators]              \"\"\"          )          from src.taipy import core as tp            Config.override(file_config.filename)          scenario = tp.create_scenario(Config.scenarios[\"my_scenario\"])            assert isinstance(scenario.input, PickleDataNode)          assert isinstance(scenario.output, InMemoryDataNode)        def test_create_dn_from_loaded_config_modified_default_config(self):          file_config = NamedTemporaryFile(              \"\"\"              [TAIPY]                [DATA_NODE.input]              scope = \"SCENARIO:SCOPE\"              default_path=\"fake/path.csv\"                [DATA_NODE.output]              storage_type = \"in_memory\"              scope = \"SCENARIO:SCOPE\"                [TASK.double]              inputs = [ \"input:SECTION\",]              function = \"math.sqrt:function\"              outputs = [ \"output:SECTION\",]              skippable = \"False:bool\"                [SCENARIO.my_scenario]              tasks = [ \"double:SECTION\",]              sequences.my_sequence = [ \"double:SECTION\",]                [SCENARIO.my_scenario.comparators]              \"\"\"          )          from src.taipy import core as tp            Config.set_default_data_node_configuration(storage_type=\"csv\")          Config.override(file_config.filename)          scenario = tp.create_scenario(Config.scenarios[\"my_scenario\"])            assert isinstance(scenario.input, CSVDataNode)          assert isinstance(scenario.output, InMemoryDataNode)        def test_get_tasks_by_config_id(self):          dn_config_1 = Config.configure_data_node(\"dn_1\", scope=Scope.SCENARIO)          dn_config_2 = Config.configure_data_node(\"dn_2\", scope=Scope.SCENARIO)          dn_config_3 = Config.configure_data_node(\"dn_3\", scope=Scope.SCENARIO)            dn_1_1 = _DataManager._create_and_set(dn_config_1, None, None)          dn_1_2 = _DataManager._create_and_set(dn_config_1, None, None)          dn_1_3 = _DataManager._create_and_set(dn_config_1, None, None)          assert len(_DataManager._get_all()) == 3            dn_2_1 = _DataManager._create_and_set(dn_config_2, None, None)          dn_2_2 = _DataManager._create_and_set(dn_config_2, None, None)          assert len(_DataManager._get_all()) == 5            dn_3_1 = _DataManager._create_and_set(dn_config_3, None, None)          assert len(_DataManager._get_all()) == 6            dn_1_datanodes = _DataManager._get_by_config_id(dn_config_1.id)          assert len(dn_1_datanodes) == 3          assert sorted([dn_1_1.id, dn_1_2.id, dn_1_3.id]) == sorted([sequence.id for sequence in dn_1_datanodes])            dn_2_datanodes = _DataManager._get_by_config_id(dn_config_2.id)          assert len(dn_2_datanodes) == 2          assert sorted([dn_2_1.id, dn_2_2.id]) == sorted([sequence.id for sequence in dn_2_datanodes])            dn_3_datanodes = _DataManager._get_by_config_id(dn_config_3.id)          assert len(dn_3_datanodes) == 1          assert sorted([dn_3_1.id]) == sorted([sequence.id for sequence in dn_3_datanodes])        def test_get_data_nodes_by_config_id_in_multiple_versions_environment(self):          dn_config_1 = Config.configure_data_node(\"dn_1\", scope=Scope.SCENARIO)          dn_config_2 = Config.configure_data_node(\"dn_2\", scope=Scope.SCENARIO)            _VersionManager._set_experiment_version(\"1.0\")          _DataManager._create_and_set(dn_config_1, None, None)          _DataManager._create_and_set(dn_config_1, None, None)          _DataManager._create_and_set(dn_config_1, None, None)          _DataManager._create_and_set(dn_config_2, None, None)          _DataManager._create_and_set(dn_config_2, None, None)            assert len(_DataManager._get_by_config_id(dn_config_1.id)) == 3          assert len(_DataManager._get_by_config_id(dn_config_2.id)) == 2            _VersionManager._set_experiment_version(\"2.0\")          _DataManager._create_and_set(dn_config_1, None, None)          _DataManager._create_and_set(dn_config_1, None, None)          _DataManager._create_and_set(dn_config_1, None, None)          _DataManager._create_and_set(dn_config_2, None, None)          _DataManager._create_and_set(dn_config_2, None, None)            assert len(_DataManager._get_by_config_id(dn_config_1.id)) == 3          assert len(_DataManager._get_by_config_id(dn_config_2.id)) == 2 "}
{"text": "from typing import Dict, List    import numpy as np  import pandas as pd  import pytest    from src.taipy.core.data.operator import JoinOperator, Operator    from .utils import (      CustomClass,      FakeCustomDataNode,      FakeDataframeDataNode,      FakeDataNode,      FakeListDataNode,      FakeMultiSheetExcelCustomDataNode,      FakeMultiSheetExcelDataFrameDataNode,      FakeNumpyarrayDataNode,  )      def test_filter_pandas_exposed_type(default_data_frame):      dn = FakeDataNode(\"fake_dn\")      dn.write(\"Any data\")        with pytest.raises(NotImplementedError):          dn.filter(((\"any\", 0, Operator.EQUAL)), JoinOperator.OR)      with pytest.raises(NotImplementedError):          dn.filter(((\"any\", 0, Operator.NOT_EQUAL)), JoinOperator.OR)      with pytest.raises(NotImplementedError):          dn.filter(((\"any\", 0, Operator.LESS_THAN)), JoinOperator.AND)      with pytest.raises(NotImplementedError):          dn.filter(((\"any\", 0, Operator.LESS_OR_EQUAL)), JoinOperator.AND)      with pytest.raises(NotImplementedError):          dn.filter(((\"any\", 0, Operator.GREATER_THAN)))      with pytest.raises(NotImplementedError):          dn.filter((\"any\", 0, Operator.GREATER_OR_EQUAL))        df_dn = FakeDataframeDataNode(\"fake_dataframe_dn\", default_data_frame)        COLUMN_NAME_1 = \"a\"      COLUMN_NAME_2 = \"b\"      assert len(df_dn.filter((COLUMN_NAME_1, 1, Operator.EQUAL))) == len(          default_data_frame[default_data_frame[COLUMN_NAME_1] == 1]      )      assert len(df_dn.filter((COLUMN_NAME_1, 1, Operator.NOT_EQUAL))) == len(          default_data_frame[default_data_frame[COLUMN_NAME_1] != 1]      )      assert len(df_dn.filter([(COLUMN_NAME_1, 1, Operator.EQUAL)])) == len(          default_data_frame[default_data_frame[COLUMN_NAME_1] == 1]      )      assert len(df_dn.filter([(COLUMN_NAME_1, 1, Operator.NOT_EQUAL)])) == len(          default_data_frame[default_data_frame[COLUMN_NAME_1] != 1]      )      assert len(df_dn.filter([(COLUMN_NAME_1, 1, Operator.LESS_THAN)])) == len(          default_data_frame[default_data_frame[COLUMN_NAME_1] < 1]      )      assert len(df_dn.filter([(COLUMN_NAME_1, 1, Operator.LESS_OR_EQUAL)])) == len(          default_data_frame[default_data_frame[COLUMN_NAME_1] <= 1]      )      assert len(df_dn.filter([(COLUMN_NAME_1, 1, Operator.GREATER_THAN)])) == len(          default_data_frame[default_data_frame[COLUMN_NAME_1] > 1]      )      assert len(df_dn.filter([(COLUMN_NAME_1, 1, Operator.GREATER_OR_EQUAL)])) == len(          default_data_frame[default_data_frame[COLUMN_NAME_1] >= 1]      )      assert len(df_dn.filter([(COLUMN_NAME_1, -1000, Operator.LESS_OR_EQUAL)])) == 0      assert len(df_dn.filter([(COLUMN_NAME_1, 1000, Operator.GREATER_OR_EQUAL)])) == 0      assert len(df_dn.filter([(COLUMN_NAME_1, 4, Operator.EQUAL), (COLUMN_NAME_1, 5, Operator.EQUAL)])) == len(          default_data_frame[(default_data_frame[COLUMN_NAME_1] == 4) & (default_data_frame[COLUMN_NAME_1] == 5)]      )      assert len(          df_dn.filter([(COLUMN_NAME_1, 4, Operator.EQUAL), (COLUMN_NAME_2, 5, Operator.EQUAL)], JoinOperator.OR)      ) == len(default_data_frame[(default_data_frame[COLUMN_NAME_1] == 4) | (default_data_frame[COLUMN_NAME_2] == 5)])      assert len(          df_dn.filter(              [(COLUMN_NAME_1, 1, Operator.GREATER_THAN), (COLUMN_NAME_2, 3, Operator.GREATER_THAN)], JoinOperator.AND          )      ) == len(default_data_frame[(default_data_frame[COLUMN_NAME_1] > 1) & (default_data_frame[COLUMN_NAME_2] > 3)])      assert len(          df_dn.filter(              [(COLUMN_NAME_1, 2, Operator.GREATER_THAN), (COLUMN_NAME_1, 3, Operator.GREATER_THAN)], JoinOperator.OR          )      ) == len(default_data_frame[(default_data_frame[COLUMN_NAME_1] > 2) | (default_data_frame[COLUMN_NAME_1] > 3)])      assert len(          df_dn.filter(              [(COLUMN_NAME_1, 10, Operator.GREATER_THAN), (COLUMN_NAME_1, -10, Operator.LESS_THAN)], JoinOperator.AND          )      ) == len(default_data_frame[(default_data_frame[COLUMN_NAME_1] > 10) | (default_data_frame[COLUMN_NAME_1] < -10)])      assert len(          df_dn.filter(              [(COLUMN_NAME_1, 10, Operator.GREATER_THAN), (COLUMN_NAME_1, -10, Operator.LESS_THAN)], JoinOperator.OR          )      ) == len(default_data_frame[(default_data_frame[COLUMN_NAME_1] > 10) | (default_data_frame[COLUMN_NAME_1] < -10)])      def test_filter_list():      list_dn = FakeListDataNode(\"fake_list_dn\")        KEY_NAME = \"value\"        assert len(list_dn.filter((KEY_NAME, 4, Operator.EQUAL))) == 1      assert len(list_dn.filter((KEY_NAME, 4, Operator.NOT_EQUAL))) == 9      assert len(list_dn.filter([(KEY_NAME, 4, Operator.EQUAL)])) == 1      assert len(list_dn.filter([(KEY_NAME, 4, Operator.NOT_EQUAL)])) == 9      assert len(list_dn.filter([(KEY_NAME, 4, Operator.LESS_THAN)])) == 4      assert len(list_dn.filter([(KEY_NAME, 4, Operator.LESS_OR_EQUAL)])) == 5      assert len(list_dn.filter([(KEY_NAME, 4, Operator.GREATER_THAN)])) == 5      assert len(list_dn.filter([(KEY_NAME, 4, Operator.GREATER_OR_EQUAL)])) == 6      assert len(list_dn.filter([(KEY_NAME, -1000, Operator.LESS_OR_EQUAL)])) == 0      assert len(list_dn.filter([(KEY_NAME, 1000, Operator.GREATER_OR_EQUAL)])) == 0        assert len(list_dn.filter([(KEY_NAME, 4, Operator.EQUAL), (KEY_NAME, 5, Operator.EQUAL)])) == 0      assert len(list_dn.filter([(KEY_NAME, 4, Operator.EQUAL), (KEY_NAME, 5, Operator.EQUAL)], JoinOperator.OR)) == 2      assert len(list_dn.filter([(KEY_NAME, 4, Operator.EQUAL), (KEY_NAME, 11, Operator.EQUAL)], JoinOperator.AND)) == 0      assert len(list_dn.filter([(KEY_NAME, 4, Operator.EQUAL), (KEY_NAME, 11, Operator.EQUAL)], JoinOperator.OR)) == 1        assert (          len(list_dn.filter([(KEY_NAME, -10, Operator.LESS_OR_EQUAL), (KEY_NAME, 11, Operator.GREATER_OR_EQUAL)])) == 0      )      assert (          len(              list_dn.filter(                  [                      (KEY_NAME, 4, Operator.GREATER_OR_EQUAL),                      (KEY_NAME, 6, Operator.GREATER_OR_EQUAL),                  ],                  JoinOperator.AND,              )          )          == 4      )      assert (          len(              list_dn.filter(                  [                      (KEY_NAME, 4, Operator.GREATER_OR_EQUAL),                      (KEY_NAME, 6, Operator.GREATER_OR_EQUAL),                      (KEY_NAME, 11, Operator.EQUAL),                  ],                  JoinOperator.AND,              )          )          == 0      )      assert (          len(              list_dn.filter(                  [                      (KEY_NAME, 4, Operator.GREATER_OR_EQUAL),                      (KEY_NAME, 6, Operator.GREATER_OR_EQUAL),                      (KEY_NAME, 11, Operator.EQUAL),                  ],                  JoinOperator.OR,              )          )          == 6      )      def test_filter_numpy_exposed_type(default_data_frame):      default_array = default_data_frame.to_numpy()        df_dn = FakeNumpyarrayDataNode(\"fake_dataframe_dn\", default_array)        assert len(df_dn.filter((0, 1, Operator.EQUAL))) == len(default_array[default_array[:, 0] == 1])      assert len(df_dn.filter((0, 1, Operator.NOT_EQUAL))) == len(default_array[default_array[:, 0] != 1])      assert len(df_dn.filter([(0, 1, Operator.EQUAL)])) == len(default_array[default_array[:, 0] == 1])      assert len(df_dn.filter([(0, 1, Operator.NOT_EQUAL)])) == len(default_array[default_array[:, 0] != 1])      assert len(df_dn.filter([(0, 1, Operator.LESS_THAN)])) == len(default_array[default_array[:, 0] < 1])      assert len(df_dn.filter([(0, 1, Operator.LESS_OR_EQUAL)])) == len(default_array[default_array[:, 0] <= 1])      assert len(df_dn.filter([(0, 1, Operator.GREATER_THAN)])) == len(default_array[default_array[:, 0] > 1])      assert len(df_dn.filter([(0, 1, Operator.GREATER_OR_EQUAL)])) == len(default_array[default_array[:, 0] >= 1])      assert len(df_dn.filter([(0, -1000, Operator.LESS_OR_EQUAL)])) == 0      assert len(df_dn.filter([(0, 1000, Operator.GREATER_OR_EQUAL)])) == 0      assert len(df_dn.filter([(0, 4, Operator.EQUAL), (0, 5, Operator.EQUAL)])) == len(          default_array[(default_array[:, 0] == 4) & (default_array[:, 0] == 5)]      )      assert len(df_dn.filter([(0, 4, Operator.EQUAL), (1, 5, Operator.EQUAL)], JoinOperator.OR)) == len(          default_array[(default_array[:, 0] == 4) | (default_array[:, 1] == 5)]      )      assert len(df_dn.filter([(0, 1, Operator.GREATER_THAN), (1, 3, Operator.GREATER_THAN)], JoinOperator.AND)) == len(          default_array[(default_array[:, 0] > 1) & (default_array[:, 1] > 3)]      )      assert len(df_dn.filter([(0, 2, Operator.GREATER_THAN), (0, 3, Operator.GREATER_THAN)], JoinOperator.OR)) == len(          default_array[(default_array[:, 0] > 2) | (default_array[:, 0] > 3)]      )      assert len(df_dn.filter([(0, 10, Operator.GREATER_THAN), (0, -10, Operator.LESS_THAN)], JoinOperator.AND)) == len(          default_array[(default_array[:, 0] > 10) | (default_array[:, 0] < -10)]      )      assert len(df_dn.filter([(0, 10, Operator.GREATER_THAN), (0, -10, Operator.LESS_THAN)], JoinOperator.OR)) == len(          default_array[(default_array[:, 0] > 10) | (default_array[:, 0] < -10)]      )      def test_filter_by_get_item(default_data_frame):      # get item for DataFrame data_type      default_data_frame[1] = [100, 100]      df_dn = FakeDataframeDataNode(\"fake_dataframe_dn\", default_data_frame)        filtered_df_dn = df_dn[\"a\"]      assert isinstance(filtered_df_dn, pd.Series)      assert len(filtered_df_dn) == len(default_data_frame[\"a\"])      assert filtered_df_dn.to_dict() == default_data_frame[\"a\"].to_dict()        filtered_df_dn = df_dn[1]      assert isinstance(filtered_df_dn, pd.Series)      assert len(filtered_df_dn) == len(default_data_frame[1])      assert filtered_df_dn.to_dict() == default_data_frame[1].to_dict()        filtered_df_dn = df_dn[0:2]      assert isinstance(filtered_df_dn, pd.DataFrame)      assert filtered_df_dn.shape == default_data_frame[0:2].shape      assert len(filtered_df_dn) == 2        bool_df = default_data_frame.copy(deep=True) > 4      filtered_df_dn = df_dn[bool_df]      assert isinstance(filtered_df_dn, pd.DataFrame)        bool_1d_index = [True, False]      filtered_df_dn = df_dn[bool_1d_index]      assert isinstance(filtered_df_dn, pd.DataFrame)      assert filtered_df_dn.to_dict() == default_data_frame[bool_1d_index].to_dict()      assert len(filtered_df_dn) == 1        filtered_df_dn = df_dn[[\"a\", \"b\"]]      assert isinstance(filtered_df_dn, pd.DataFrame)      assert filtered_df_dn.shape == default_data_frame[[\"a\", \"b\"]].shape      assert filtered_df_dn.to_dict() == default_data_frame[[\"a\", \"b\"]].to_dict()        # get item for custom data_type      custom_dn = FakeCustomDataNode(\"fake_custom_dn\")        filtered_custom_dn = custom_dn[\"a\"]      assert isinstance(filtered_custom_dn, List)      assert len(filtered_custom_dn) == 10      assert filtered_custom_dn == [i for i in range(10)]        filtered_custom_dn = custom_dn[0:5]      assert isinstance(filtered_custom_dn, List)      assert all([isinstance(x, CustomClass) for x in filtered_custom_dn])      assert len(filtered_custom_dn) == 5        bool_1d_index = [True if i < 5 else False for i in range(10)]      filtered_custom_dn = custom_dn[bool_1d_index]      assert isinstance(filtered_custom_dn, List)      assert len(filtered_custom_dn) == 5      assert filtered_custom_dn == custom_dn._read()[:5]        filtered_custom_dn = custom_dn[[\"a\", \"b\"]]      assert isinstance(filtered_custom_dn, List)      assert all([isinstance(x, Dict) for x in filtered_custom_dn])      assert len(filtered_custom_dn) == 10      assert filtered_custom_dn == [{\"a\": i, \"b\": i * 2} for i in range(10)]        # get item for Multi-sheet Excel data_type      multi_sheet_excel_df_dn = FakeMultiSheetExcelDataFrameDataNode(\"fake_multi_sheet_excel_df_dn\", default_data_frame)      filtered_multi_sheet_excel_df_dn = multi_sheet_excel_df_dn[\"Sheet1\"]      assert isinstance(filtered_multi_sheet_excel_df_dn, pd.DataFrame)      assert len(filtered_multi_sheet_excel_df_dn) == len(default_data_frame)      assert np.array_equal(filtered_multi_sheet_excel_df_dn.to_numpy(), default_data_frame.to_numpy())        multi_sheet_excel_custom_dn = FakeMultiSheetExcelCustomDataNode(\"fake_multi_sheet_excel_df_dn\")      filtered_multi_sheet_excel_custom_dn = multi_sheet_excel_custom_dn[\"Sheet1\"]      assert isinstance(filtered_multi_sheet_excel_custom_dn, List)      assert len(filtered_multi_sheet_excel_custom_dn) == 10      expected_value = [CustomClass(i, i * 2) for i in range(10)]      assert all(          [              expected.a == filtered.a and expected.b == filtered.b              for expected, filtered in zip(expected_value, filtered_multi_sheet_excel_custom_dn)          ]      ) "}
{"text": "import os  import pathlib  from datetime import datetime  from importlib import util  from time import sleep    import modin.pandas as modin_pd  import numpy as np  import pandas as pd  import pytest  from modin.pandas.test.utils import df_equals  from pandas.testing import assert_frame_equal    from src.taipy.core.data._data_manager import _DataManager  from src.taipy.core.data.data_node_id import DataNodeId  from src.taipy.core.data.operator import JoinOperator, Operator  from src.taipy.core.data.parquet import ParquetDataNode  from src.taipy.core.exceptions.exceptions import (      InvalidExposedType,      NoData,      UnknownCompressionAlgorithm,      UnknownParquetEngine,  )  from taipy.config.common.scope import Scope  from taipy.config.config import Config  from taipy.config.exceptions.exceptions import InvalidConfigurationId      @pytest.fixture(scope=\"function\", autouse=True)  def cleanup():      yield      path = os.path.join(pathlib.Path(__file__).parent.resolve(), \"data_sample/temp.parquet\")      if os.path.isfile(path):          os.remove(path)      class MyCustomObject:      def __init__(self, id, integer, text):          self.id = id          self.integer = integer          self.text = text      class MyOtherCustomObject:      def __init__(self, id, sentence):          self.id = id          self.sentence = sentence      def create_custom_class(**kwargs):      return MyOtherCustomObject(id=kwargs[\"id\"], sentence=kwargs[\"text\"])      class TestParquetDataNode:      __engine = [\"pyarrow\"]      if util.find_spec(\"fastparquet\"):          __engine.append(\"fastparquet\")        def test_create(self):          path = \"data/node/path\"          compression = \"snappy\"          dn = ParquetDataNode(              \"foo_bar\", Scope.SCENARIO, properties={\"path\": path, \"compression\": compression, \"name\": \"super name\"}          )          assert isinstance(dn, ParquetDataNode)          assert dn.storage_type() == \"parquet\"          assert dn.config_id == \"foo_bar\"          assert dn.name == \"super name\"          assert dn.scope == Scope.SCENARIO          assert dn.id is not None          assert dn.owner_id is None          assert dn.last_edit_date is None          assert dn.job_ids == []          assert not dn.is_ready_for_reading          assert dn.path == path          assert dn.exposed_type == \"pandas\"          assert dn.compression == \"snappy\"          assert dn.engine == \"pyarrow\"            with pytest.raises(InvalidConfigurationId):              dn = ParquetDataNode(\"foo bar\", Scope.SCENARIO, properties={\"path\": path, \"name\": \"super name\"})        def test_get_user_properties(self, parquet_file_path):          dn_1 = ParquetDataNode(\"dn_1\", Scope.SCENARIO, properties={\"path\": parquet_file_path})          assert dn_1._get_user_properties() == {}            dn_2 = ParquetDataNode(              \"dn_2\",              Scope.SCENARIO,              properties={                  \"exposed_type\": \"numpy\",                  \"default_data\": \"foo\",                  \"default_path\": parquet_file_path,                  \"engine\": \"pyarrow\",                  \"compression\": \"snappy\",                  \"read_kwargs\": {\"columns\": [\"a\", \"b\"]},                  \"write_kwargs\": {\"index\": False},                  \"foo\": \"bar\",              },          )            # exposed_type, default_data, default_path, path, engine, compression, read_kwargs, write_kwargs          # are filtered out          assert dn_2._get_user_properties() == {\"foo\": \"bar\"}        def test_new_parquet_data_node_with_existing_file_is_ready_for_reading(self, parquet_file_path):          not_ready_dn_cfg = Config.configure_data_node(              \"not_ready_data_node_config_id\", \"parquet\", path=\"NOT_EXISTING.parquet\"          )          not_ready_dn = _DataManager._bulk_get_or_create([not_ready_dn_cfg])[not_ready_dn_cfg]          assert not not_ready_dn.is_ready_for_reading            ready_dn_cfg = Config.configure_data_node(\"ready_data_node_config_id\", \"parquet\", path=parquet_file_path)          ready_dn = _DataManager._bulk_get_or_create([ready_dn_cfg])[ready_dn_cfg]          assert ready_dn.is_ready_for_reading        @pytest.mark.parametrize(          [\"properties\", \"exists\"],          [              ({}, False),              ({\"default_data\": {\"a\": [\"foo\", \"bar\"]}}, True),          ],      )      def test_create_with_default_data(self, properties, exists):          dn = ParquetDataNode(\"foo\", Scope.SCENARIO, DataNodeId(\"dn_id\"), properties=properties)          assert os.path.exists(dn.path) is exists        @pytest.mark.parametrize(\"engine\", __engine)      def test_read_file(self, engine, parquet_file_path):          not_existing_parquet = ParquetDataNode(              \"foo\", Scope.SCENARIO, properties={\"path\": \"nonexistent.parquet\", \"engine\": engine}          )          with pytest.raises(NoData):              assert not_existing_parquet.read() is None              not_existing_parquet.read_or_raise()            df = pd.read_parquet(parquet_file_path)          # Create ParquetDataNode without exposed_type (Default is pandas.DataFrame)          parquet_data_node_as_pandas = ParquetDataNode(              \"bar\", Scope.SCENARIO, properties={\"path\": parquet_file_path, \"engine\": engine}          )          data_pandas = parquet_data_node_as_pandas.read()          assert isinstance(data_pandas, pd.DataFrame)          assert len(data_pandas) == 2          assert data_pandas.equals(df)          assert np.array_equal(data_pandas.to_numpy(), df.to_numpy())            # Create ParquetDataNode with modin exposed_type          parquet_data_node_as_modin = ParquetDataNode(              \"bar\", Scope.SCENARIO, properties={\"path\": parquet_file_path, \"exposed_type\": \"modin\", \"engine\": engine}          )          data_modin = parquet_data_node_as_modin.read()          assert isinstance(data_modin, modin_pd.DataFrame)          assert len(data_modin) == 2          assert data_modin.equals(df)          assert np.array_equal(data_modin.to_numpy(), df.to_numpy())            # Create ParquetDataNode with numpy exposed_type          parquet_data_node_as_numpy = ParquetDataNode(              \"bar\", Scope.SCENARIO, properties={\"path\": parquet_file_path, \"exposed_type\": \"numpy\", \"engine\": engine}          )          data_numpy = parquet_data_node_as_numpy.read()          assert isinstance(data_numpy, np.ndarray)          assert len(data_numpy) == 2          assert np.array_equal(data_numpy, df.to_numpy())        @pytest.mark.parametrize(\"engine\", __engine)      def test_read_folder(self, engine):          parquet_folder_path = os.path.join(pathlib.Path(__file__).parent.resolve(), \"data_sample/parquet_example\")            df = pd.read_parquet(parquet_folder_path)          parquet_data_node_as_pandas = ParquetDataNode(              \"bar\", Scope.SCENARIO, properties={\"path\": parquet_folder_path, \"engine\": engine}          )          data_pandas = parquet_data_node_as_pandas.read()          assert isinstance(data_pandas, pd.DataFrame)          assert len(data_pandas) == 5          assert data_pandas.equals(df)          assert np.array_equal(data_pandas.to_numpy(), df.to_numpy())        def test_set_path(self):          dn = ParquetDataNode(\"foo\", Scope.SCENARIO, properties={\"path\": \"foo.parquet\"})          assert dn.path == \"foo.parquet\"          dn.path = \"bar.parquet\"          assert dn.path == \"bar.parquet\"        @pytest.mark.parametrize(\"engine\", __engine)      def test_read_write_after_modify_path(self, engine):          path = os.path.join(pathlib.Path(__file__).parent.resolve(), \"data_sample/example.parquet\")          new_path = os.path.join(pathlib.Path(__file__).parent.resolve(), \"data_sample/temp.parquet\")          dn = ParquetDataNode(\"foo\", Scope.SCENARIO, properties={\"path\": path, \"engine\": engine})          read_data = dn.read()          assert read_data is not None          dn.path = new_path          with pytest.raises(FileNotFoundError):              dn.read()          dn.write(read_data)          assert dn.read().equals(read_data)        def test_read_custom_exposed_type(self):          example_parquet_path = os.path.join(pathlib.Path(__file__).parent.resolve(), \"data_sample/example.parquet\")            dn = ParquetDataNode(              \"foo\", Scope.SCENARIO, properties={\"path\": example_parquet_path, \"exposed_type\": MyCustomObject}          )          assert all([isinstance(obj, MyCustomObject) for obj in dn.read()])            dn = ParquetDataNode(              \"foo\", Scope.SCENARIO, properties={\"path\": example_parquet_path, \"exposed_type\": create_custom_class}          )          assert all([isinstance(obj, MyOtherCustomObject) for obj in dn.read()])        def test_raise_error_unknown_parquet_engine(self):          path = os.path.join(pathlib.Path(__file__).parent.resolve(), \"data_sample/example.parquet\")          with pytest.raises(UnknownParquetEngine):              ParquetDataNode(\"foo\", Scope.SCENARIO, properties={\"path\": path, \"engine\": \"foo\"})        def test_raise_error_unknown_compression_algorithm(self):          path = os.path.join(pathlib.Path(__file__).parent.resolve(), \"data_sample/example.parquet\")          with pytest.raises(UnknownCompressionAlgorithm):              ParquetDataNode(\"foo\", Scope.SCENARIO, properties={\"path\": path, \"compression\": \"foo\"})        def test_raise_error_invalid_exposed_type(self):          path = os.path.join(pathlib.Path(__file__).parent.resolve(), \"data_sample/example.parquet\")          with pytest.raises(InvalidExposedType):              ParquetDataNode(\"foo\", Scope.SCENARIO, properties={\"path\": path, \"exposed_type\": \"foo\"})        def test_read_empty_data(self, tmpdir_factory):          temp_file_path = str(tmpdir_factory.mktemp(\"data\").join(\"temp.parquet\"))          empty_df = pd.DataFrame([])          empty_df.to_parquet(temp_file_path)            # Pandas          dn = ParquetDataNode(\"foo\", Scope.SCENARIO, properties={\"path\": temp_file_path, \"exposed_type\": \"pandas\"})          assert dn.read().equals(empty_df)            # Numpy          dn = ParquetDataNode(\"foo\", Scope.SCENARIO, properties={\"path\": temp_file_path, \"exposed_type\": \"numpy\"})          assert np.array_equal(dn.read(), empty_df.to_numpy())            # Custom          dn = ParquetDataNode(\"foo\", Scope.SCENARIO, properties={\"path\": temp_file_path, \"exposed_type\": MyCustomObject})          assert dn.read() == []        def test_get_system_file_modified_date_instead_of_last_edit_date(self, tmpdir_factory):          temp_file_path = str(tmpdir_factory.mktemp(\"data\").join(\"temp.parquet\"))          pd.DataFrame([]).to_parquet(temp_file_path)          dn = ParquetDataNode(\"foo\", Scope.SCENARIO, properties={\"path\": temp_file_path, \"exposed_type\": \"pandas\"})            dn.write(pd.DataFrame(data={\"col1\": [1, 2], \"col2\": [3, 4]}))          previous_edit_date = dn.last_edit_date            sleep(0.1)            pd.DataFrame(pd.DataFrame(data={\"col1\": [5, 6], \"col2\": [7, 8]})).to_parquet(temp_file_path)          new_edit_date = datetime.fromtimestamp(os.path.getmtime(temp_file_path))            assert previous_edit_date < dn.last_edit_date          assert new_edit_date == dn.last_edit_date            sleep(0.1)            dn.write(pd.DataFrame(data={\"col1\": [9, 10], \"col2\": [10, 12]}))          assert new_edit_date < dn.last_edit_date          os.unlink(temp_file_path)        def test_get_system_folder_modified_date_instead_of_last_edit_date(self, tmpdir_factory):          temp_folder_path = tmpdir_factory.mktemp(\"data\").strpath          temp_file_path = os.path.join(temp_folder_path, \"temp.parquet\")          pd.DataFrame([]).to_parquet(temp_file_path)            dn = ParquetDataNode(\"foo\", Scope.SCENARIO, properties={\"path\": temp_folder_path})          initial_edit_date = dn.last_edit_date            # Sleep so that the file can be created successfully on Ubuntu          sleep(0.1)            pd.DataFrame(pd.DataFrame(data={\"col1\": [1, 2], \"col2\": [3, 4]})).to_parquet(temp_file_path)          first_edit_date = datetime.fromtimestamp(os.path.getmtime(temp_file_path))          assert dn.last_edit_date > initial_edit_date          assert dn.last_edit_date == first_edit_date            sleep(0.1)            pd.DataFrame(pd.DataFrame(data={\"col1\": [5, 6], \"col2\": [7, 8]})).to_parquet(temp_file_path)          second_edit_date = datetime.fromtimestamp(os.path.getmtime(temp_file_path))          assert dn.last_edit_date > first_edit_date          assert dn.last_edit_date == second_edit_date            os.unlink(temp_file_path)        @pytest.mark.skipif(not util.find_spec(\"fastparquet\"), reason=\"Append parquet requires fastparquet to be installed\")      @pytest.mark.parametrize(          \"content\",          [              ([{\"a\": 11, \"b\": 22, \"c\": 33}, {\"a\": 44, \"b\": 55, \"c\": 66}]),              (pd.DataFrame([{\"a\": 11, \"b\": 22, \"c\": 33}, {\"a\": 44, \"b\": 55, \"c\": 66}])),          ],      )      def test_append_pandas(self, parquet_file_path, default_data_frame, content):          dn = ParquetDataNode(\"foo\", Scope.SCENARIO, properties={\"path\": parquet_file_path})          assert_frame_equal(dn.read(), default_data_frame)            dn.append(content)          assert_frame_equal(              dn.read(),              pd.concat([default_data_frame, pd.DataFrame(content, columns=[\"a\", \"b\", \"c\"])]).reset_index(drop=True),          )        @pytest.mark.skipif(not util.find_spec(\"fastparquet\"), reason=\"Append parquet requires fastparquet to be installed\")      @pytest.mark.parametrize(          \"content\",          [              ([{\"a\": 11, \"b\": 22, \"c\": 33}, {\"a\": 44, \"b\": 55, \"c\": 66}]),              (pd.DataFrame([{\"a\": 11, \"b\": 22, \"c\": 33}, {\"a\": 44, \"b\": 55, \"c\": 66}])),          ],      )      def test_append_modin(self, parquet_file_path, default_data_frame, content):          dn = ParquetDataNode(\"foo\", Scope.SCENARIO, properties={\"path\": parquet_file_path, \"exposed_type\": \"modin\"})          df_equals(dn.read(), modin_pd.DataFrame(default_data_frame))            dn.append(content)          df_equals(              dn.read(),              modin_pd.concat([default_data_frame, pd.DataFrame(content, columns=[\"a\", \"b\", \"c\"])]).reset_index(                  drop=True              ),          )        @pytest.mark.parametrize(          \"data\",          [              [{\"a\": 11, \"b\": 22, \"c\": 33}, {\"a\": 44, \"b\": 55, \"c\": 66}],              pd.DataFrame([{\"a\": 11, \"b\": 22, \"c\": 33}, {\"a\": 44, \"b\": 55, \"c\": 66}]),              modin_pd.DataFrame([{\"a\": 11, \"b\": 22, \"c\": 33}, {\"a\": 44, \"b\": 55, \"c\": 66}]),          ],      )      def test_write_to_disk(self, tmpdir_factory, data):          temp_file_path = str(tmpdir_factory.mktemp(\"data\").join(\"temp.parquet\"))          dn = ParquetDataNode(\"foo\", Scope.SCENARIO, properties={\"path\": temp_file_path})          dn.write(data)            assert pathlib.Path(temp_file_path).exists()          assert isinstance(dn.read(), pd.DataFrame)        def test_filter_pandas_exposed_type(self, parquet_file_path):          dn = ParquetDataNode(\"foo\", Scope.SCENARIO, properties={\"path\": parquet_file_path, \"exposed_type\": \"pandas\"})          dn.write(              [                  {\"foo\": 1, \"bar\": 1},                  {\"foo\": 1, \"bar\": 2},                  {\"foo\": 1},                  {\"foo\": 2, \"bar\": 2},                  {\"bar\": 2},              ]          )            # Test datanode indexing and slicing          assert dn[\"foo\"].equals(pd.Series([1, 1, 1, 2, None]))          assert dn[\"bar\"].equals(pd.Series([1, 2, None, 2, 2]))          assert dn[:2].equals(pd.DataFrame([{\"foo\": 1.0, \"bar\": 1.0}, {\"foo\": 1.0, \"bar\": 2.0}]))            # Test filter data          filtered_by_filter_method = dn.filter((\"foo\", 1, Operator.EQUAL))          filtered_by_indexing = dn[dn[\"foo\"] == 1]          expected_data = pd.DataFrame([{\"foo\": 1.0, \"bar\": 1.0}, {\"foo\": 1.0, \"bar\": 2.0}, {\"foo\": 1.0}])          assert_frame_equal(filtered_by_filter_method.reset_index(drop=True), expected_data)          assert_frame_equal(filtered_by_indexing.reset_index(drop=True), expected_data)            filtered_by_filter_method = dn.filter((\"foo\", 1, Operator.NOT_EQUAL))          filtered_by_indexing = dn[dn[\"foo\"] != 1]          expected_data = pd.DataFrame([{\"foo\": 2.0, \"bar\": 2.0}, {\"bar\": 2.0}])          assert_frame_equal(filtered_by_filter_method.reset_index(drop=True), expected_data)          assert_frame_equal(filtered_by_indexing.reset_index(drop=True), expected_data)            filtered_by_filter_method = dn.filter((\"bar\", 2, Operator.EQUAL))          filtered_by_indexing = dn[dn[\"bar\"] == 2]          expected_data = pd.DataFrame([{\"foo\": 1.0, \"bar\": 2.0}, {\"foo\": 2.0, \"bar\": 2.0}, {\"bar\": 2.0}])          assert_frame_equal(filtered_by_filter_method.reset_index(drop=True), expected_data)          assert_frame_equal(filtered_by_indexing.reset_index(drop=True), expected_data)            filtered_by_filter_method = dn.filter([(\"bar\", 1, Operator.EQUAL), (\"bar\", 2, Operator.EQUAL)], JoinOperator.OR)          filtered_by_indexing = dn[(dn[\"bar\"] == 1) | (dn[\"bar\"] == 2)]          expected_data = pd.DataFrame(              [                  {\"foo\": 1.0, \"bar\": 1.0},                  {\"foo\": 1.0, \"bar\": 2.0},                  {\"foo\": 2.0, \"bar\": 2.0},                  {\"bar\": 2.0},              ]          )          assert_frame_equal(filtered_by_filter_method.reset_index(drop=True), expected_data)          assert_frame_equal(filtered_by_indexing.reset_index(drop=True), expected_data)        def test_filter_modin_exposed_type(self, parquet_file_path):          dn = ParquetDataNode(\"foo\", Scope.SCENARIO, properties={\"path\": parquet_file_path, \"exposed_type\": \"modin\"})          dn.write(              [                  {\"foo\": 1, \"bar\": 1},                  {\"foo\": 1, \"bar\": 2},                  {\"foo\": 1},                  {\"foo\": 2, \"bar\": 2},                  {\"bar\": 2},              ]          )            # Test datanode indexing and slicing          assert dn[\"foo\"].equals(modin_pd.Series([1, 1, 1, 2, None]))          assert dn[\"bar\"].equals(modin_pd.Series([1, 2, None, 2, 2]))          assert dn[:2].equals(modin_pd.DataFrame([{\"foo\": 1.0, \"bar\": 1.0}, {\"foo\": 1.0, \"bar\": 2.0}]))            # Test filter data          filtered_by_filter_method = dn.filter((\"foo\", 1, Operator.EQUAL))          filtered_by_indexing = dn[dn[\"foo\"] == 1]          expected_data = modin_pd.DataFrame([{\"foo\": 1.0, \"bar\": 1.0}, {\"foo\": 1.0, \"bar\": 2.0}, {\"foo\": 1.0}])          df_equals(filtered_by_filter_method.reset_index(drop=True), expected_data)          df_equals(filtered_by_indexing.reset_index(drop=True), expected_data)            filtered_by_filter_method = dn.filter((\"foo\", 1, Operator.NOT_EQUAL))          filtered_by_indexing = dn[dn[\"foo\"] != 1]          expected_data = modin_pd.DataFrame([{\"foo\": 2.0, \"bar\": 2.0}, {\"bar\": 2.0}])          df_equals(filtered_by_filter_method.reset_index(drop=True), expected_data)          df_equals(filtered_by_indexing.reset_index(drop=True), expected_data)            filtered_by_filter_method = dn.filter((\"bar\", 2, Operator.EQUAL))          filtered_by_indexing = dn[dn[\"bar\"] == 2]          expected_data = modin_pd.DataFrame([{\"foo\": 1.0, \"bar\": 2.0}, {\"foo\": 2.0, \"bar\": 2.0}, {\"bar\": 2.0}])          df_equals(filtered_by_filter_method.reset_index(drop=True), expected_data)          df_equals(filtered_by_indexing.reset_index(drop=True), expected_data)            filtered_by_filter_method = dn.filter([(\"bar\", 1, Operator.EQUAL), (\"bar\", 2, Operator.EQUAL)], JoinOperator.OR)          filtered_by_indexing = dn[(dn[\"bar\"] == 1) | (dn[\"bar\"] == 2)]          expected_data = modin_pd.DataFrame(              [                  {\"foo\": 1.0, \"bar\": 1.0},                  {\"foo\": 1.0, \"bar\": 2.0},                  {\"foo\": 2.0, \"bar\": 2.0},                  {\"bar\": 2.0},              ]          )          df_equals(filtered_by_filter_method.reset_index(drop=True), expected_data)          df_equals(filtered_by_indexing.reset_index(drop=True), expected_data)        def test_filter_numpy_exposed_type(self, parquet_file_path):          dn = ParquetDataNode(\"foo\", Scope.SCENARIO, properties={\"path\": parquet_file_path, \"exposed_type\": \"numpy\"})          dn.write(              [                  [1, 1],                  [1, 2],                  [1, 3],                  [2, 1],                  [2, 2],                  [2, 3],              ]          )            # Test datanode indexing and slicing          assert np.array_equal(dn[0], np.array([1, 1]))          assert np.array_equal(dn[1], np.array([1, 2]))          assert np.array_equal(dn[:3], np.array([[1, 1], [1, 2], [1, 3]]))          assert np.array_equal(dn[:, 0], np.array([1, 1, 1, 2, 2, 2]))          assert np.array_equal(dn[1:4, :1], np.array([[1], [1], [2]]))            # Test filter data          assert np.array_equal(dn.filter((0, 1, Operator.EQUAL)), np.array([[1, 1], [1, 2], [1, 3]]))          assert np.array_equal(dn[dn[:, 0] == 1], np.array([[1, 1], [1, 2], [1, 3]]))            assert np.array_equal(dn.filter((0, 1, Operator.NOT_EQUAL)), np.array([[2, 1], [2, 2], [2, 3]]))          assert np.array_equal(dn[dn[:, 0] != 1], np.array([[2, 1], [2, 2], [2, 3]]))            assert np.array_equal(dn.filter((1, 2, Operator.EQUAL)), np.array([[1, 2], [2, 2]]))          assert np.array_equal(dn[dn[:, 1] == 2], np.array([[1, 2], [2, 2]]))            assert np.array_equal(              dn.filter([(1, 1, Operator.EQUAL), (1, 2, Operator.EQUAL)], JoinOperator.OR),              np.array([[1, 1], [1, 2], [2, 1], [2, 2]]),          )          assert np.array_equal(dn[(dn[:, 1] == 1) | (dn[:, 1] == 2)], np.array([[1, 1], [1, 2], [2, 1], [2, 2]]))        @pytest.mark.parametrize(\"engine\", __engine)      def test_pandas_parquet_config_kwargs(self, engine, tmpdir_factory):          read_kwargs = {\"filters\": [(\"integer\", \"<\", 10)], \"columns\": [\"integer\"]}          temp_file_path = str(tmpdir_factory.mktemp(\"data\").join(\"temp.parquet\"))          dn = ParquetDataNode(              \"foo\", Scope.SCENARIO, properties={\"path\": temp_file_path, \"engine\": engine, \"read_kwargs\": read_kwargs}          )            df = pd.read_csv(os.path.join(pathlib.Path(__file__).parent.resolve(), \"data_sample/example.csv\"))          dn.write(df)            assert set(pd.read_parquet(temp_file_path).columns) == {\"id\", \"integer\", \"text\"}          assert set(dn.read().columns) == set(read_kwargs[\"columns\"])            # !!! filter doesn't work with `fastparquet` without partition_cols          if engine == \"pyarrow\":              assert len(dn.read()) != len(df)              assert len(dn.read()) == 2        @pytest.mark.parametrize(\"engine\", __engine)      def test_kwarg_precedence(self, engine, tmpdir_factory, default_data_frame):          # Precedence:          # 1. Class read/write methods          # 2. Defined in read_kwargs and write_kwargs, in properties          # 3. Defined top-level in properties            temp_file_path = str(tmpdir_factory.mktemp(\"data\").join(\"temp.parquet\"))          temp_file_2_path = str(tmpdir_factory.mktemp(\"data\").join(\"temp_2.parquet\"))          df = default_data_frame.copy(deep=True)            # Write          # 3          comp3 = \"snappy\"          dn = ParquetDataNode(              \"foo\", Scope.SCENARIO, properties={\"path\": temp_file_path, \"engine\": engine, \"compression\": comp3}          )          dn.write(df)          df.to_parquet(path=temp_file_2_path, compression=comp3, engine=engine)          with open(temp_file_2_path, \"rb\") as tf:              with pathlib.Path(temp_file_path).open(\"rb\") as f:                  assert f.read() == tf.read()            # 3 and 2          comp2 = \"gzip\"          dn = ParquetDataNode(              \"foo\",              Scope.SCENARIO,              properties={                  \"path\": temp_file_path,                  \"engine\": engine,                  \"compression\": comp3,                  \"write_kwargs\": {\"compression\": comp2},              },          )          dn.write(df)          df.to_parquet(path=temp_file_2_path, compression=comp2, engine=engine)          with open(temp_file_2_path, \"rb\") as tf:              with pathlib.Path(temp_file_path).open(\"rb\") as f:                  assert f.read() == tf.read()            # 3, 2 and 1          comp1 = \"brotli\"          dn = ParquetDataNode(              \"foo\",              Scope.SCENARIO,              properties={                  \"path\": temp_file_path,                  \"engine\": engine,                  \"compression\": comp3,                  \"write_kwargs\": {\"compression\": comp2},              },          )          dn.write_with_kwargs(df, compression=comp1)          df.to_parquet(path=temp_file_2_path, compression=comp1, engine=engine)          with open(temp_file_2_path, \"rb\") as tf:              with pathlib.Path(temp_file_path).open(\"rb\") as f:                  assert f.read() == tf.read()            # Read          df.to_parquet(temp_file_path, engine=engine)          # 2          cols2 = [\"a\", \"b\"]          dn = ParquetDataNode(              \"foo\",              Scope.SCENARIO,              properties={\"path\": temp_file_path, \"engine\": engine, \"read_kwargs\": {\"columns\": cols2}},          )          assert set(dn.read().columns) == set(cols2)            # 1          cols1 = [\"a\"]          dn = ParquetDataNode(              \"foo\",              Scope.SCENARIO,              properties={\"path\": temp_file_path, \"engine\": engine, \"read_kwargs\": {\"columns\": cols2}},          )          assert set(dn.read_with_kwargs(columns=cols1).columns) == set(cols1)        def test_partition_cols(self, tmpdir_factory, default_data_frame: pd.DataFrame):          temp_dir_path = str(tmpdir_factory.mktemp(\"data\").join(\"temp_dir\"))            write_kwargs = {\"partition_cols\": [\"a\", \"b\"]}          dn = ParquetDataNode(              \"foo\", Scope.SCENARIO, properties={\"path\": temp_dir_path, \"write_kwargs\": write_kwargs}          )  # type: ignore          dn.write(default_data_frame)            assert pathlib.Path(temp_dir_path).is_dir()          # dtypes change during round-trip with partition_cols          pd.testing.assert_frame_equal(              dn.read().sort_index(axis=1),              default_data_frame.sort_index(axis=1),              check_dtype=False,              check_categorical=False,          )        def test_read_with_kwargs_never_written(self):          path = \"data/node/path\"          dn = ParquetDataNode(\"foo\", Scope.SCENARIO, properties={\"path\": path})          assert dn.read_with_kwargs() is None "}
{"text": "from importlib import util  from unittest.mock import patch    import modin.pandas as modin_pd  import numpy as np  import pandas as pd  import pytest  from modin.pandas.test.utils import df_equals  from pandas.testing import assert_frame_equal    from src.taipy.core.data.data_node_id import DataNodeId  from src.taipy.core.data.operator import JoinOperator, Operator  from src.taipy.core.data.sql_table import SQLTableDataNode  from src.taipy.core.exceptions.exceptions import InvalidExposedType, MissingRequiredProperty  from taipy.config.common.scope import Scope      class MyCustomObject:      def __init__(self, foo=None, bar=None, *args, **kwargs):          self.foo = foo          self.bar = bar          self.args = args          self.kwargs = kwargs      class TestSQLTableDataNode:      __pandas_properties = [          {              \"db_name\": \"taipy\",              \"db_engine\": \"sqlite\",              \"table_name\": \"example\",              \"db_extra_args\": {                  \"TrustServerCertificate\": \"yes\",                  \"other\": \"value\",              },          },      ]        __modin_properties = [          {              \"db_name\": \"taipy\",              \"db_engine\": \"sqlite\",              \"table_name\": \"example\",              \"exposed_type\": \"modin\",              \"db_extra_args\": {                  \"TrustServerCertificate\": \"yes\",                  \"other\": \"value\",              },          },      ]        if util.find_spec(\"pyodbc\"):          __pandas_properties.append(              {                  \"db_username\": \"sa\",                  \"db_password\": \"Passw0rd\",                  \"db_name\": \"taipy\",                  \"db_engine\": \"mssql\",                  \"table_name\": \"example\",                  \"db_extra_args\": {                      \"TrustServerCertificate\": \"yes\",                  },              },          )          __modin_properties.append(              {                  \"db_username\": \"sa\",                  \"db_password\": \"Passw0rd\",                  \"db_name\": \"taipy\",                  \"db_engine\": \"mssql\",                  \"table_name\": \"example\",                  \"exposed_type\": \"modin\",                  \"db_extra_args\": {                      \"TrustServerCertificate\": \"yes\",                  },              },          )        if util.find_spec(\"pymysql\"):          __pandas_properties.append(              {                  \"db_username\": \"sa\",                  \"db_password\": \"Passw0rd\",                  \"db_name\": \"taipy\",                  \"db_engine\": \"mysql\",                  \"table_name\": \"example\",                  \"db_extra_args\": {                      \"TrustServerCertificate\": \"yes\",                  },              },          )          __modin_properties.append(              {                  \"db_username\": \"sa\",                  \"db_password\": \"Passw0rd\",                  \"db_name\": \"taipy\",                  \"db_engine\": \"mysql\",                  \"table_name\": \"example\",                  \"exposed_type\": \"modin\",                  \"db_extra_args\": {                      \"TrustServerCertificate\": \"yes\",                  },              },          )        if util.find_spec(\"psycopg2\"):          __pandas_properties.append(              {                  \"db_username\": \"sa\",                  \"db_password\": \"Passw0rd\",                  \"db_name\": \"taipy\",                  \"db_engine\": \"postgresql\",                  \"table_name\": \"example\",                  \"db_extra_args\": {                      \"TrustServerCertificate\": \"yes\",                  },              },          )          __modin_properties.append(              {                  \"db_username\": \"sa\",                  \"db_password\": \"Passw0rd\",                  \"db_name\": \"taipy\",                  \"db_engine\": \"postgresql\",                  \"table_name\": \"example\",                  \"exposed_type\": \"modin\",                  \"db_extra_args\": {                      \"TrustServerCertificate\": \"yes\",                  },              },          )        @pytest.mark.parametrize(\"pandas_properties\", __pandas_properties)      @pytest.mark.parametrize(\"modin_properties\", __modin_properties)      def test_create(self, pandas_properties, modin_properties):          dn = SQLTableDataNode(              \"foo_bar\",              Scope.SCENARIO,              properties=pandas_properties,          )          assert isinstance(dn, SQLTableDataNode)          assert dn.storage_type() == \"sql_table\"          assert dn.config_id == \"foo_bar\"          assert dn.scope == Scope.SCENARIO          assert dn.id is not None          assert dn.owner_id is None          assert dn.job_ids == []          assert dn.is_ready_for_reading          assert dn.exposed_type == \"pandas\"          assert dn.table_name == \"example\"          assert dn._get_base_read_query() == \"SELECT * FROM example\"            dn = SQLTableDataNode(              \"foo_bar\",              Scope.SCENARIO,              properties=modin_properties,          )          assert isinstance(dn, SQLTableDataNode)          assert dn.storage_type() == \"sql_table\"          assert dn.config_id == \"foo_bar\"          assert dn.scope == Scope.SCENARIO          assert dn.id is not None          assert dn.owner_id is None          assert dn.job_ids == []          assert dn.is_ready_for_reading          assert dn.exposed_type == \"modin\"          assert dn.table_name == \"example\"          assert dn._get_base_read_query() == \"SELECT * FROM example\"        @pytest.mark.parametrize(\"properties\", __pandas_properties)      def test_get_user_properties(self, properties):          custom_properties = properties.copy()          custom_properties[\"foo\"] = \"bar\"          dn = SQLTableDataNode(              \"foo_bar\",              Scope.SCENARIO,              properties=custom_properties,          )          assert dn._get_user_properties() == {\"foo\": \"bar\"}        @pytest.mark.parametrize(          \"properties\",          [              {},              {\"db_username\": \"foo\"},              {\"db_username\": \"foo\", \"db_password\": \"foo\"},              {\"db_username\": \"foo\", \"db_password\": \"foo\", \"db_name\": \"foo\"},          ],      )      def test_create_with_missing_parameters(self, properties):          with pytest.raises(MissingRequiredProperty):              SQLTableDataNode(\"foo\", Scope.SCENARIO, DataNodeId(\"dn_id\"))          with pytest.raises(MissingRequiredProperty):              SQLTableDataNode(\"foo\", Scope.SCENARIO, DataNodeId(\"dn_id\"), properties=properties)        @patch(\"src.taipy.core.data.sql_table.SQLTableDataNode._read_as\", return_value=\"custom\")      @patch(\"src.taipy.core.data.sql_table.SQLTableDataNode._read_as_pandas_dataframe\", return_value=\"pandas\")      @patch(\"src.taipy.core.data.sql_table.SQLTableDataNode._read_as_modin_dataframe\", return_value=\"modin\")      @patch(\"src.taipy.core.data.sql_table.SQLTableDataNode._read_as_numpy\", return_value=\"numpy\")      @pytest.mark.parametrize(\"pandas_properties\", __pandas_properties)      @pytest.mark.parametrize(\"modin_properties\", __modin_properties)      def test_read(          self,          mock_read_as,          mock_read_as_pandas_dataframe,          mock_read_as_modin_dataframe,          mock_read_as_numpy,          pandas_properties,          modin_properties,      ):          custom_properties = pandas_properties.copy()          # Create SQLTableDataNode without exposed_type (Default is pandas.DataFrame)          sql_data_node_as_pandas = SQLTableDataNode(              \"foo\",              Scope.SCENARIO,              properties=pandas_properties,          )            assert sql_data_node_as_pandas.read() == \"pandas\"            custom_properties.pop(\"db_extra_args\")          custom_properties[\"exposed_type\"] = MyCustomObject          # Create the same SQLTableDataNode but with custom exposed_type          sql_data_node_as_custom_object = SQLTableDataNode(\"foo\", Scope.SCENARIO, properties=custom_properties)          assert sql_data_node_as_custom_object.read() == \"custom\"            # Create the same SQLDataSource but with numpy exposed_type          custom_properties[\"exposed_type\"] = \"numpy\"          sql_data_source_as_numpy_object = SQLTableDataNode(\"foo\", Scope.SCENARIO, properties=custom_properties)            assert sql_data_source_as_numpy_object.read() == \"numpy\"            # Create the same SQLDataSource but with modin exposed_type          sql_data_source_as_modin_object = SQLTableDataNode(\"foo\", Scope.SCENARIO, properties=modin_properties)          assert sql_data_source_as_modin_object.properties[\"exposed_type\"] == \"modin\"          assert sql_data_source_as_modin_object.read() == \"modin\"        @pytest.mark.parametrize(\"pandas_properties\", __pandas_properties)      def test_read_as(self, pandas_properties):          custom_properties = pandas_properties.copy()            custom_properties.pop(\"db_extra_args\")          custom_properties[\"exposed_type\"] = MyCustomObject          sql_data_node = SQLTableDataNode(\"foo\", Scope.SCENARIO, properties=custom_properties)            with patch(\"sqlalchemy.engine.Engine.connect\") as engine_mock:              cursor_mock = engine_mock.return_value.__enter__.return_value              cursor_mock.execute.return_value = [                  {\"foo\": \"baz\", \"bar\": \"qux\"},                  {\"foo\": \"quux\", \"bar\": \"quuz\"},                  {\"foo\": \"corge\"},                  {\"bar\": \"grault\"},                  {\"KWARGS_KEY\": \"KWARGS_VALUE\"},                  {},              ]              data = sql_data_node._read_as()            assert isinstance(data, list)          assert isinstance(data[0], MyCustomObject)          assert isinstance(data[1], MyCustomObject)          assert isinstance(data[2], MyCustomObject)          assert isinstance(data[3], MyCustomObject)          assert isinstance(data[4], MyCustomObject)          assert isinstance(data[5], MyCustomObject)            assert data[0].foo == \"baz\"          assert data[0].bar == \"qux\"          assert data[1].foo == \"quux\"          assert data[1].bar == \"quuz\"          assert data[2].foo == \"corge\"          assert data[2].bar is None          assert data[3].foo is None          assert data[3].bar == \"grault\"          assert data[4].foo is None          assert data[4].bar is None          assert data[4].kwargs[\"KWARGS_KEY\"] == \"KWARGS_VALUE\"          assert data[5].foo is None          assert data[5].bar is None          assert len(data[5].args) == 0          assert len(data[5].kwargs) == 0            with patch(\"sqlalchemy.engine.Engine.connect\") as engine_mock:              cursor_mock = engine_mock.return_value.__enter__.return_value              cursor_mock.execute.return_value = []              data_2 = sql_data_node._read_as()          assert isinstance(data_2, list)          assert len(data_2) == 0        @pytest.mark.parametrize(          \"data,written_data,called_func\",          [              ([{\"a\": 1, \"b\": 2}, {\"a\": 3, \"b\": 4}], [{\"a\": 1, \"b\": 2}, {\"a\": 3, \"b\": 4}], \"__insert_dicts\"),              ({\"a\": 1, \"b\": 2}, [{\"a\": 1, \"b\": 2}], \"__insert_dicts\"),              ([(1, 2), (3, 4)], [(1, 2), (3, 4)], \"__insert_tuples\"),              ([[1, 2], [3, 4]], [[1, 2], [3, 4]], \"__insert_tuples\"),              ((1, 2), [(1, 2)], \"__insert_tuples\"),              ([1, 2, 3, 4], [(1,), (2,), (3,), (4,)], \"__insert_tuples\"),              (\"foo\", [(\"foo\",)], \"__insert_tuples\"),              (None, [(None,)], \"__insert_tuples\"),              (np.array([1, 2, 3, 4]), [(1,), (2,), (3,), (4,)], \"__insert_tuples\"),              (np.array([np.array([1, 2]), np.array([3, 4])]), [[1, 2], [3, 4]], \"__insert_tuples\"),          ],      )      @pytest.mark.parametrize(\"pandas_properties\", __pandas_properties)      def test_write_1(self, data, written_data, called_func, pandas_properties):          custom_properties = pandas_properties.copy()          custom_properties.pop(\"db_extra_args\")          dn = SQLTableDataNode(\"foo\", Scope.SCENARIO, properties=custom_properties)            with patch(\"sqlalchemy.engine.Engine.connect\") as engine_mock, patch(              \"src.taipy.core.data.sql_table.SQLTableDataNode._create_table\"          ) as create_table_mock:              cursor_mock = engine_mock.return_value.__enter__.return_value              cursor_mock.execute.side_effect = None                with patch(f\"src.taipy.core.data.sql_table.SQLTableDataNode._SQLTableDataNode{called_func}\") as mck:                  dn.write(data)                  mck.assert_called_once_with(written_data, create_table_mock.return_value, cursor_mock, True)        @pytest.mark.parametrize(\"pandas_properties\", __pandas_properties)      def test_raise_error_invalid_exposed_type(self, pandas_properties):          custom_properties = pandas_properties.copy()          custom_properties.pop(\"db_extra_args\")          custom_properties[\"exposed_type\"] = \"foo\"          with pytest.raises(InvalidExposedType):              SQLTableDataNode(\"foo\", Scope.SCENARIO, properties=custom_properties)        @pytest.mark.parametrize(\"pandas_properties\", __pandas_properties)      @pytest.mark.parametrize(\"modin_properties\", __modin_properties)      def test_write_dataframe(self, pandas_properties, modin_properties):          # test write pandas dataframe          custom_properties = pandas_properties.copy()          custom_properties.pop(\"db_extra_args\")          dn = SQLTableDataNode(\"foo\", Scope.SCENARIO, properties=custom_properties)            df = pd.DataFrame({\"a\": [1, 2, 3, 4], \"b\": [5, 6, 7, 8]})          with patch(\"sqlalchemy.engine.Engine.connect\") as engine_mock, patch(              \"src.taipy.core.data.sql_table.SQLTableDataNode._create_table\"          ):              cursor_mock = engine_mock.return_value.__enter__.return_value              cursor_mock.execute.side_effect = None                with patch(\"src.taipy.core.data.sql_table.SQLTableDataNode._SQLTableDataNode__insert_dataframe\") as mck:                  dn.write(df)                  assert mck.call_args[0][0].equals(df)            # test write modin dataframe          custom_properties = modin_properties.copy()          custom_properties.pop(\"db_extra_args\")          dn = SQLTableDataNode(\"foo\", Scope.SCENARIO, properties=custom_properties)            df = modin_pd.DataFrame({\"a\": [1, 2, 3, 4], \"b\": [5, 6, 7, 8]})          with patch(\"sqlalchemy.engine.Engine.connect\") as engine_mock, patch(              \"src.taipy.core.data.sql_table.SQLTableDataNode._create_table\"          ):              cursor_mock = engine_mock.return_value.__enter__.return_value              cursor_mock.execute.side_effect = None                with patch(\"src.taipy.core.data.sql_table.SQLTableDataNode._SQLTableDataNode__insert_dataframe\") as mck:                  dn.write(df)                  assert mck.call_args[0][0].equals(df)        @pytest.mark.parametrize(          \"data\",          [              [],              np.array([]),          ],      )      @pytest.mark.parametrize(\"pandas_properties\", __pandas_properties)      def test_write_empty_list(self, data, pandas_properties):          custom_properties = pandas_properties.copy()          custom_properties.pop(\"db_extra_args\")          dn = SQLTableDataNode(\"foo\", Scope.SCENARIO, properties=custom_properties)            with patch(\"sqlalchemy.engine.Engine.connect\") as engine_mock, patch(              \"src.taipy.core.data.sql_table.SQLTableDataNode._create_table\"          ) as create_table_mock:              cursor_mock = engine_mock.return_value.__enter__.return_value              cursor_mock.execute.side_effect = None                with patch(\"src.taipy.core.data.sql_table.SQLTableDataNode._SQLTableDataNode__delete_all_rows\") as mck:                  dn.write(data)                  mck.assert_called_once_with(create_table_mock.return_value, cursor_mock, True)        @pytest.mark.parametrize(\"pandas_properties\", __pandas_properties)      @patch(\"pandas.read_sql_query\")      def test_engine_cache(self, _, pandas_properties):          dn = SQLTableDataNode(              \"foo\",              Scope.SCENARIO,              properties=pandas_properties,          )            assert dn._engine is None            with patch(\"sqlalchemy.engine.Engine.connect\") as engine_mock, patch(              \"src.taipy.core.data.sql_table.SQLTableDataNode._create_table\"          ):              cursor_mock = engine_mock.return_value.__enter__.return_value              cursor_mock.execute.side_effect = None                dn.read()              assert dn._engine is not None                dn.db_username = \"foo\"              assert dn._engine is None                dn.write(1)              assert dn._engine is not None                dn.some_random_attribute_that_does_not_related_to_engine = \"foo\"              assert dn._engine is not None        @pytest.mark.parametrize(          \"tmp_sqlite_path\",          [              \"tmp_sqlite_db_file_path\",              \"tmp_sqlite_sqlite3_file_path\",          ],      )      def test_sqlite_read_file_with_different_extension(self, tmp_sqlite_path, request):          tmp_sqlite_path = request.getfixturevalue(tmp_sqlite_path)          folder_path, db_name, file_extension = tmp_sqlite_path          properties = {              \"db_engine\": \"sqlite\",              \"table_name\": \"example\",              \"db_name\": db_name,              \"sqlite_folder_path\": folder_path,              \"sqlite_file_extension\": file_extension,          }            dn = SQLTableDataNode(\"sqlite_dn\", Scope.SCENARIO, properties=properties)          data = dn.read()            assert data.equals(pd.DataFrame([{\"foo\": 1, \"bar\": 2}, {\"foo\": 3, \"bar\": 4}]))        def test_sqlite_append_pandas(self, tmp_sqlite_sqlite3_file_path):          folder_path, db_name, file_extension = tmp_sqlite_sqlite3_file_path          properties = {              \"db_engine\": \"sqlite\",              \"table_name\": \"example\",              \"db_name\": db_name,              \"sqlite_folder_path\": folder_path,              \"sqlite_file_extension\": file_extension,          }            dn = SQLTableDataNode(\"sqlite_dn\", Scope.SCENARIO, properties=properties)          original_data = pd.DataFrame([{\"foo\": 1, \"bar\": 2}, {\"foo\": 3, \"bar\": 4}])          data = dn.read()          assert_frame_equal(data, original_data)            append_data_1 = pd.DataFrame([{\"foo\": 5, \"bar\": 6}, {\"foo\": 7, \"bar\": 8}])          dn.append(append_data_1)          assert_frame_equal(dn.read(), pd.concat([original_data, append_data_1]).reset_index(drop=True))        def test_sqlite_append_modin(self, tmp_sqlite_sqlite3_file_path):          folder_path, db_name, file_extension = tmp_sqlite_sqlite3_file_path          properties = {              \"db_engine\": \"sqlite\",              \"table_name\": \"example\",              \"db_name\": db_name,              \"sqlite_folder_path\": folder_path,              \"sqlite_file_extension\": file_extension,              \"exposed_type\": \"modin\",          }            dn = SQLTableDataNode(\"sqlite_dn\", Scope.SCENARIO, properties=properties)          original_data = modin_pd.DataFrame([{\"foo\": 1, \"bar\": 2}, {\"foo\": 3, \"bar\": 4}])          data = dn.read()          df_equals(data, original_data)            append_data_1 = modin_pd.DataFrame([{\"foo\": 5, \"bar\": 6}, {\"foo\": 7, \"bar\": 8}])          dn.append(append_data_1)          df_equals(dn.read(), modin_pd.concat([original_data, append_data_1]).reset_index(drop=True))        def test_filter_pandas_exposed_type(self, tmp_sqlite_sqlite3_file_path):          folder_path, db_name, file_extension = tmp_sqlite_sqlite3_file_path          properties = {              \"db_engine\": \"sqlite\",              \"table_name\": \"example\",              \"db_name\": db_name,              \"sqlite_folder_path\": folder_path,              \"sqlite_file_extension\": file_extension,              \"exposed_type\": \"pandas\",          }          dn = SQLTableDataNode(\"foo\", Scope.SCENARIO, properties=properties)          dn.write(              pd.DataFrame(                  [                      {\"foo\": 1, \"bar\": 1},                      {\"foo\": 1, \"bar\": 2},                      {\"foo\": 1, \"bar\": 3},                      {\"foo\": 2, \"bar\": 1},                      {\"foo\": 2, \"bar\": 2},                      {\"foo\": 2, \"bar\": 3},                  ]              )          )            # Test datanode indexing and slicing          assert dn[\"foo\"].equals(pd.Series([1, 1, 1, 2, 2, 2]))          assert dn[\"bar\"].equals(pd.Series([1, 2, 3, 1, 2, 3]))          assert dn[:2].equals(pd.DataFrame([{\"foo\": 1, \"bar\": 1}, {\"foo\": 1, \"bar\": 2}]))            # Test filter data          filtered_by_filter_method = dn.filter((\"foo\", 1, Operator.EQUAL))          filtered_by_indexing = dn[dn[\"foo\"] == 1]          expected_data = pd.DataFrame([{\"foo\": 1, \"bar\": 1}, {\"foo\": 1, \"bar\": 2}, {\"foo\": 1, \"bar\": 3}])          assert_frame_equal(filtered_by_filter_method.reset_index(drop=True), expected_data)          assert_frame_equal(filtered_by_indexing.reset_index(drop=True), expected_data)            filtered_by_filter_method = dn.filter((\"foo\", 1, Operator.NOT_EQUAL))          filtered_by_indexing = dn[dn[\"foo\"] != 1]          expected_data = pd.DataFrame([{\"foo\": 2, \"bar\": 1}, {\"foo\": 2, \"bar\": 2}, {\"foo\": 2, \"bar\": 3}])          assert_frame_equal(filtered_by_filter_method.reset_index(drop=True), expected_data)          assert_frame_equal(filtered_by_indexing.reset_index(drop=True), expected_data)            filtered_by_filter_method = dn.filter([(\"bar\", 1, Operator.EQUAL), (\"bar\", 2, Operator.EQUAL)], JoinOperator.OR)          filtered_by_indexing = dn[(dn[\"bar\"] == 1) | (dn[\"bar\"] == 2)]          expected_data = pd.DataFrame(              [                  {\"foo\": 1, \"bar\": 1},                  {\"foo\": 1, \"bar\": 2},                  {\"foo\": 2, \"bar\": 1},                  {\"foo\": 2, \"bar\": 2},              ]          )          assert_frame_equal(filtered_by_filter_method.reset_index(drop=True), expected_data)          assert_frame_equal(filtered_by_indexing.reset_index(drop=True), expected_data)        def test_filter_modin_exposed_type(self, tmp_sqlite_sqlite3_file_path):          folder_path, db_name, file_extension = tmp_sqlite_sqlite3_file_path          properties = {              \"db_engine\": \"sqlite\",              \"table_name\": \"example\",              \"db_name\": db_name,              \"sqlite_folder_path\": folder_path,              \"sqlite_file_extension\": file_extension,              \"exposed_type\": \"modin\",          }          dn = SQLTableDataNode(\"foo\", Scope.SCENARIO, properties=properties)          dn.write(              pd.DataFrame(                  [                      {\"foo\": 1, \"bar\": 1},                      {\"foo\": 1, \"bar\": 2},                      {\"foo\": 1, \"bar\": 3},                      {\"foo\": 2, \"bar\": 1},                      {\"foo\": 2, \"bar\": 2},                      {\"foo\": 2, \"bar\": 3},                  ]              )          )            # Test datanode indexing and slicing          assert dn[\"foo\"].equals(pd.Series([1, 1, 1, 2, 2, 2]))          assert dn[\"bar\"].equals(pd.Series([1, 2, 3, 1, 2, 3]))          assert dn[:2].equals(modin_pd.DataFrame([{\"foo\": 1, \"bar\": 1}, {\"foo\": 1, \"bar\": 2}]))            # Test filter data          filtered_by_filter_method = dn.filter((\"foo\", 1, Operator.EQUAL))          filtered_by_indexing = dn[dn[\"foo\"] == 1]          expected_data = modin_pd.DataFrame([{\"foo\": 1, \"bar\": 1}, {\"foo\": 1, \"bar\": 2}, {\"foo\": 1, \"bar\": 3}])          df_equals(filtered_by_filter_method.reset_index(drop=True), expected_data)          df_equals(filtered_by_indexing.reset_index(drop=True), expected_data)            filtered_by_filter_method = dn.filter((\"foo\", 1, Operator.NOT_EQUAL))          filtered_by_indexing = dn[dn[\"foo\"] != 1]          expected_data = modin_pd.DataFrame([{\"foo\": 2, \"bar\": 1}, {\"foo\": 2, \"bar\": 2}, {\"foo\": 2, \"bar\": 3}])          df_equals(filtered_by_filter_method.reset_index(drop=True), expected_data)          df_equals(filtered_by_indexing.reset_index(drop=True), expected_data)            filtered_by_filter_method = dn.filter([(\"bar\", 1, Operator.EQUAL), (\"bar\", 2, Operator.EQUAL)], JoinOperator.OR)          filtered_by_indexing = dn[(dn[\"bar\"] == 1) | (dn[\"bar\"] == 2)]          expected_data = modin_pd.DataFrame(              [                  {\"foo\": 1, \"bar\": 1},                  {\"foo\": 1, \"bar\": 2},                  {\"foo\": 2, \"bar\": 1},                  {\"foo\": 2, \"bar\": 2},              ]          )          df_equals(filtered_by_filter_method.reset_index(drop=True), expected_data)          df_equals(filtered_by_indexing.reset_index(drop=True), expected_data)        def test_filter_numpy_exposed_type(self, tmp_sqlite_sqlite3_file_path):          folder_path, db_name, file_extension = tmp_sqlite_sqlite3_file_path          properties = {              \"db_engine\": \"sqlite\",              \"table_name\": \"example\",              \"db_name\": db_name,              \"sqlite_folder_path\": folder_path,              \"sqlite_file_extension\": file_extension,              \"exposed_type\": \"numpy\",          }          dn = SQLTableDataNode(\"foo\", Scope.SCENARIO, properties=properties)          dn.write(              pd.DataFrame(                  [                      {\"foo\": 1, \"bar\": 1},                      {\"foo\": 1, \"bar\": 2},                      {\"foo\": 1, \"bar\": 3},                      {\"foo\": 2, \"bar\": 1},                      {\"foo\": 2, \"bar\": 2},                      {\"foo\": 2, \"bar\": 3},                  ]              )          )            # Test datanode indexing and slicing          assert np.array_equal(dn[0], np.array([1, 1]))          assert np.array_equal(dn[1], np.array([1, 2]))          assert np.array_equal(dn[:3], np.array([[1, 1], [1, 2], [1, 3]]))          assert np.array_equal(dn[:, 0], np.array([1, 1, 1, 2, 2, 2]))          assert np.array_equal(dn[1:4, :1], np.array([[1], [1], [2]]))            # Test filter data          assert np.array_equal(dn.filter((\"foo\", 1, Operator.EQUAL)), np.array([[1, 1], [1, 2], [1, 3]]))          assert np.array_equal(dn[dn[:, 0] == 1], np.array([[1, 1], [1, 2], [1, 3]]))            assert np.array_equal(dn.filter((\"foo\", 1, Operator.NOT_EQUAL)), np.array([[2, 1], [2, 2], [2, 3]]))          assert np.array_equal(dn[dn[:, 0] != 1], np.array([[2, 1], [2, 2], [2, 3]]))            assert np.array_equal(dn.filter((\"bar\", 2, Operator.EQUAL)), np.array([[1, 2], [2, 2]]))          assert np.array_equal(dn[dn[:, 1] == 2], np.array([[1, 2], [2, 2]]))            assert np.array_equal(              dn.filter([(\"bar\", 1, Operator.EQUAL), (\"bar\", 2, Operator.EQUAL)], JoinOperator.OR),              np.array([[1, 1], [1, 2], [2, 1], [2, 2]]),          )          assert np.array_equal(dn[(dn[:, 1] == 1) | (dn[:, 1] == 2)], np.array([[1, 1], [1, 2], [2, 1], [2, 2]]))        def test_filter_does_not_read_all_entities(self, tmp_sqlite_sqlite3_file_path):          folder_path, db_name, file_extension = tmp_sqlite_sqlite3_file_path          properties = {              \"db_engine\": \"sqlite\",              \"table_name\": \"example\",              \"db_name\": db_name,              \"sqlite_folder_path\": folder_path,              \"sqlite_file_extension\": file_extension,              \"exposed_type\": \"numpy\",          }          dn = SQLTableDataNode(\"foo\", Scope.SCENARIO, properties=properties)            # SQLTableDataNode.filter() should not call the MongoCollectionDataNode._read() method          with patch.object(SQLTableDataNode, \"_read\") as read_mock:              dn.filter((\"foo\", 1, Operator.EQUAL))              dn.filter((\"bar\", 2, Operator.NOT_EQUAL))              dn.filter([(\"bar\", 1, Operator.EQUAL), (\"bar\", 2, Operator.EQUAL)], JoinOperator.OR)                assert read_mock[\"_read\"].call_count == 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  from datetime import datetime, timedelta  from time import sleep  from unittest import mock    import pytest    import src.taipy.core as tp  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.data.data_node import DataNode  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 DataNodeIsBeingEdited, NoData  from src.taipy.core.job.job_id import JobId  from taipy.config import Config  from taipy.config.common.scope import Scope  from taipy.config.exceptions.exceptions import InvalidConfigurationId    from .utils import FakeDataNode      def funct_a_b(input: str):      print(\"task_a_b\")      return \"B\"      def funct_b_c(input: str):      print(\"task_b_c\")      return \"C\"      def funct_b_d(input: str):      print(\"task_b_d\")      return \"D\"      class TestDataNode:      def test_create_with_default_values(self):          dn = DataNode(\"foo_bar\")          assert dn.config_id == \"foo_bar\"          assert dn.scope == Scope.SCENARIO          assert dn.id is not None          assert dn.name is None          assert dn.owner_id is None          assert dn.parent_ids == set()          assert dn.last_edit_date is None          assert dn.job_ids == []          assert not dn.is_ready_for_reading          assert len(dn.properties) == 0        def test_create(self):          a_date = datetime.now()          dn = DataNode(              \"foo_bar\",              Scope.SCENARIO,              DataNodeId(\"an_id\"),              \"a_scenario_id\",              {\"a_parent_id\"},              a_date,              [dict(job_id=\"a_job_id\")],              edit_in_progress=False,              prop=\"erty\",              name=\"a name\",          )          assert dn.config_id == \"foo_bar\"          assert dn.scope == Scope.SCENARIO          assert dn.id == \"an_id\"          assert dn.name == \"a name\"          assert dn.owner_id == \"a_scenario_id\"          assert dn.parent_ids == {\"a_parent_id\"}          assert dn.last_edit_date == a_date          assert dn.job_ids == [\"a_job_id\"]          assert dn.is_ready_for_reading          assert len(dn.properties) == 2          assert dn.properties == {\"prop\": \"erty\", \"name\": \"a name\"}            with pytest.raises(InvalidConfigurationId):              DataNode(\"foo bar\")        def test_read_write(self):          dn = FakeDataNode(\"foo_bar\")          with pytest.raises(NoData):              assert dn.read() is None              dn.read_or_raise()          assert dn.write_has_been_called == 0          assert dn.read_has_been_called == 0          assert not dn.is_ready_for_reading          assert dn.last_edit_date is None          assert dn.job_ids == []          assert dn.edits == []            dn.write(\"Any data\")          assert dn.write_has_been_called == 1          assert dn.read_has_been_called == 0          assert dn.last_edit_date is not None          first_edition = dn.last_edit_date          assert dn.is_ready_for_reading          assert dn.job_ids == []          assert len(dn.edits) == 1          assert dn.get_last_edit()[\"timestamp\"] == dn.last_edit_date            sleep(0.1)            dn.write(\"Any other data\", job_id := JobId(\"a_job_id\"))          assert dn.write_has_been_called == 2          assert dn.read_has_been_called == 0          second_edition = dn.last_edit_date          assert first_edition < second_edition          assert dn.is_ready_for_reading          assert dn.job_ids == [job_id]          assert len(dn.edits) == 2          assert dn.get_last_edit()[\"timestamp\"] == dn.last_edit_date            dn.read()          assert dn.write_has_been_called == 2          assert dn.read_has_been_called == 1          second_edition = dn.last_edit_date          assert first_edition < second_edition          assert dn.is_ready_for_reading          assert dn.job_ids == [job_id]        def test_lock_initialization(self):          dn = InMemoryDataNode(\"dn\", Scope.SCENARIO)          assert not dn.edit_in_progress          assert dn._editor_id is None          assert dn._editor_expiration_date is None        def test_locked_dn_unlockable_only_by_same_editor(self):          dn = InMemoryDataNode(\"dn\", Scope.SCENARIO)          dn.lock_edit(\"user_1\")          assert dn.edit_in_progress          assert dn._editor_id == \"user_1\"          assert dn._editor_expiration_date is not None          with pytest.raises(DataNodeIsBeingEdited):              dn.lock_edit(\"user_2\")          with pytest.raises(DataNodeIsBeingEdited):              dn.unlock_edit(\"user_2\")          dn.unlock_edit(\"user_1\")          assert not dn.edit_in_progress          assert dn._editor_id is None          assert dn._editor_expiration_date is None        def test_none_editor_can_lock_a_locked_dn(self):          dn = InMemoryDataNode(\"dn\", Scope.SCENARIO)          dn.lock_edit(\"user\")          assert dn.edit_in_progress          assert dn._editor_id == \"user\"          assert dn._editor_expiration_date is not None          dn.lock_edit()          assert dn.edit_in_progress          assert dn._editor_id is None          assert dn._editor_expiration_date is None        def test_none_editor_can_unlock_a_locked_dn(self):          dn = InMemoryDataNode(\"dn\", Scope.SCENARIO)          dn.lock_edit(\"user\")          assert dn.edit_in_progress          assert dn._editor_id == \"user\"          assert dn._editor_expiration_date is not None          dn.unlock_edit()          assert not dn.edit_in_progress          assert dn._editor_id is None          assert dn._editor_expiration_date is None            dn.lock_edit()          assert dn.edit_in_progress          assert dn._editor_id is None          assert dn._editor_expiration_date is None          dn.unlock_edit()          assert not dn.edit_in_progress          assert dn._editor_id is None          assert dn._editor_expiration_date is None        def test_ready_for_reading(self):          dn = InMemoryDataNode(\"foo_bar\", Scope.CYCLE)          assert dn.last_edit_date is None          assert not dn.is_ready_for_reading          assert dn.job_ids == []            dn.lock_edit()          assert dn.last_edit_date is None          assert not dn.is_ready_for_reading          assert dn.job_ids == []            dn.unlock_edit()          assert dn.last_edit_date is None          assert not dn.is_ready_for_reading          assert dn.job_ids == []            dn.lock_edit()          assert dn.last_edit_date is None          assert not dn.is_ready_for_reading          assert dn.job_ids == []            dn.write(\"toto\", job_id := JobId(\"a_job_id\"))          assert dn.last_edit_date is not None          assert dn.is_ready_for_reading          assert dn.job_ids == [job_id]        def test_is_valid_no_validity_period(self):          # Test Never been writen          dn = InMemoryDataNode(\"foo\", Scope.SCENARIO, DataNodeId(\"id\"), \"name\", \"owner_id\")          assert not dn.is_valid            # test has been writen          dn.write(\"My data\")          assert dn.is_valid        def test_is_valid_with_30_min_validity_period(self):          # Test Never been writen          dn = InMemoryDataNode(              \"foo\", Scope.SCENARIO, DataNodeId(\"id\"), \"name\", \"owner_id\", validity_period=timedelta(minutes=30)          )          assert dn.is_valid is False            # Has been writen less than 30 minutes ago          dn.write(\"My data\")          assert dn.is_valid is True            # Has been writen more than 30 minutes ago          dn.last_edit_date = datetime.now() + timedelta(days=-1)          assert dn.is_valid is False        def test_is_valid_with_5_days_validity_period(self):          # Test Never been writen          dn = InMemoryDataNode(\"foo\", Scope.SCENARIO, validity_period=timedelta(days=5))          assert dn.is_valid is False            # Has been writen less than 30 minutes ago          dn.write(\"My data\")          assert dn.is_valid is True            # Has been writen more than 30 minutes ago          dn._last_edit_date = datetime.now() - timedelta(days=6)          _DataManager()._set(dn)          assert dn.is_valid is False        def test_is_up_to_date(self, current_datetime):          dn_confg_1 = Config.configure_in_memory_data_node(\"dn_1\")          dn_confg_2 = Config.configure_in_memory_data_node(\"dn_2\")          dn_confg_3 = Config.configure_in_memory_data_node(\"dn_3\", scope=Scope.GLOBAL)          task_config_1 = Config.configure_task(\"t1\", print, [dn_confg_1], [dn_confg_2])          task_config_2 = Config.configure_task(\"t2\", print, [dn_confg_2], [dn_confg_3])          scenario_config = Config.configure_scenario(\"sc\", [task_config_1, task_config_2])            scenario_1 = tp.create_scenario(scenario_config)          assert len(_DataManager._get_all()) == 3            dn_1_1 = scenario_1.data_nodes[\"dn_1\"]          dn_2_1 = scenario_1.data_nodes[\"dn_2\"]          dn_3_1 = scenario_1.data_nodes[\"dn_3\"]            assert dn_1_1.last_edit_date is None          assert dn_2_1.last_edit_date is None          assert dn_3_1.last_edit_date is None            dn_1_1.last_edit_date = current_datetime + timedelta(1)          dn_2_1.last_edit_date = current_datetime + timedelta(2)          dn_3_1.last_edit_date = current_datetime + timedelta(3)          assert dn_1_1.is_up_to_date          assert dn_2_1.is_up_to_date          assert dn_3_1.is_up_to_date            dn_2_1.last_edit_date = current_datetime + timedelta(4)          assert dn_1_1.is_up_to_date          assert dn_2_1.is_up_to_date          assert not dn_3_1.is_up_to_date            dn_1_1.last_edit_date = current_datetime + timedelta(5)          assert dn_1_1.is_up_to_date          assert not dn_2_1.is_up_to_date          assert not dn_3_1.is_up_to_date            dn_1_1.last_edit_date = current_datetime + timedelta(1)          dn_2_1.last_edit_date = current_datetime + timedelta(2)          dn_3_1.last_edit_date = current_datetime + timedelta(3)        def test_is_up_to_date_across_scenarios(self, current_datetime):          dn_confg_1 = Config.configure_in_memory_data_node(\"dn_1\", scope=Scope.SCENARIO)          dn_confg_2 = Config.configure_in_memory_data_node(\"dn_2\", scope=Scope.SCENARIO)          dn_confg_3 = Config.configure_in_memory_data_node(\"dn_3\", scope=Scope.GLOBAL)          task_config_1 = Config.configure_task(\"t1\", print, [dn_confg_1], [dn_confg_2])          task_config_2 = Config.configure_task(\"t2\", print, [dn_confg_2], [dn_confg_3])          scenario_config = Config.configure_scenario(\"sc\", [task_config_1, task_config_2])            scenario_1 = tp.create_scenario(scenario_config)          scenario_2 = tp.create_scenario(scenario_config)          assert len(_DataManager._get_all()) == 5            dn_1_1 = scenario_1.data_nodes[\"dn_1\"]          dn_2_1 = scenario_1.data_nodes[\"dn_2\"]          dn_1_2 = scenario_2.data_nodes[\"dn_1\"]          dn_2_2 = scenario_2.data_nodes[\"dn_2\"]          dn_3 = scenario_1.data_nodes[\"dn_3\"]          assert dn_3 == scenario_2.data_nodes[\"dn_3\"]            assert dn_1_1.last_edit_date is None          assert dn_2_1.last_edit_date is None          assert dn_1_2.last_edit_date is None          assert dn_2_2.last_edit_date is None          assert dn_3.last_edit_date is None            dn_1_1.last_edit_date = current_datetime + timedelta(1)          dn_2_1.last_edit_date = current_datetime + timedelta(2)          dn_1_2.last_edit_date = current_datetime + timedelta(3)          dn_2_2.last_edit_date = current_datetime + timedelta(4)          dn_3.last_edit_date = current_datetime + timedelta(5)          assert dn_1_1.is_up_to_date          assert dn_2_1.is_up_to_date          assert dn_1_2.is_up_to_date          assert dn_2_2.is_up_to_date          assert dn_3.is_up_to_date            dn_2_1.last_edit_date = current_datetime + timedelta(6)          assert dn_1_1.is_up_to_date          assert dn_2_1.is_up_to_date          assert dn_1_2.is_up_to_date          assert dn_2_2.is_up_to_date          assert not dn_3.is_up_to_date            dn_2_1.last_edit_date = current_datetime + timedelta(2)          dn_2_2.last_edit_date = current_datetime + timedelta(6)          assert dn_1_1.is_up_to_date          assert dn_2_1.is_up_to_date          assert dn_1_2.is_up_to_date          assert dn_2_2.is_up_to_date          assert not dn_3.is_up_to_date            dn_2_2.last_edit_date = current_datetime + timedelta(4)          dn_1_1.last_edit_date = current_datetime + timedelta(6)          assert dn_1_1.is_up_to_date          assert not dn_2_1.is_up_to_date          assert dn_1_2.is_up_to_date          assert dn_2_2.is_up_to_date          assert not dn_3.is_up_to_date            dn_1_2.last_edit_date = current_datetime + timedelta(6)          assert dn_1_1.is_up_to_date          assert not dn_2_1.is_up_to_date          assert dn_1_2.is_up_to_date          assert not dn_2_2.is_up_to_date          assert not dn_3.is_up_to_date        def test_do_not_recompute_data_node_valid_but_continue_sequence_execution(self):          Config.configure_job_executions(mode=JobConfig._DEVELOPMENT_MODE)            a = Config.configure_data_node(\"A\", \"pickle\", default_data=\"A\")          b = Config.configure_data_node(\"B\", \"pickle\")          c = Config.configure_data_node(\"C\", \"pickle\")          d = Config.configure_data_node(\"D\", \"pickle\")            task_a_b = Config.configure_task(\"task_a_b\", funct_a_b, input=a, output=b, skippable=True)          task_b_c = Config.configure_task(\"task_b_c\", funct_b_c, input=b, output=c)          task_b_d = Config.configure_task(\"task_b_d\", funct_b_d, input=b, output=d)          scenario_cfg = Config.configure_scenario(\"scenario\", [task_a_b, task_b_c, task_b_d])            _OrchestratorFactory._build_dispatcher()            scenario = tp.create_scenario(scenario_cfg)          scenario.submit()          assert scenario.A.read() == \"A\"          assert scenario.B.read() == \"B\"          assert scenario.C.read() == \"C\"          assert scenario.D.read() == \"D\"            scenario.submit()            assert len(tp.get_jobs()) == 6          jobs_and_status = [(job.task.config_id, job.status) for job in tp.get_jobs()]          assert (\"task_a_b\", tp.Status.COMPLETED) in jobs_and_status          assert (\"task_a_b\", tp.Status.SKIPPED) in jobs_and_status          assert (\"task_b_c\", tp.Status.COMPLETED) in jobs_and_status          assert (\"task_b_d\", tp.Status.COMPLETED) in jobs_and_status        def test_data_node_update_after_writing(self):          dn = FakeDataNode(\"foo\")            _DataManager._set(dn)          assert not _DataManager._get(dn.id).is_ready_for_reading          dn.write(\"Any data\")            assert dn.is_ready_for_reading          assert _DataManager._get(dn.id).is_ready_for_reading        def test_expiration_date_raise_if_never_write(self):          dn = FakeDataNode(\"foo\")            with pytest.raises(NoData):              dn.expiration_date        def test_validity_null_if_never_write(self):          dn = FakeDataNode(\"foo\")            assert dn.validity_period is None        def test_auto_set_and_reload(self, current_datetime):          dn_1 = InMemoryDataNode(              \"foo\",              scope=Scope.GLOBAL,              id=DataNodeId(\"an_id\"),              owner_id=None,              parent_ids=None,              last_edit_date=current_datetime,              edits=[dict(job_id=\"a_job_id\")],              edit_in_progress=False,              validity_period=None,              properties={                  \"name\": \"foo\",              },          )            dm = _DataManager()          dm._set(dn_1)            dn_2 = dm._get(dn_1)            # auto set & reload on scope attribute          assert dn_1.scope == Scope.GLOBAL          assert dn_2.scope == Scope.GLOBAL          dn_1.scope = Scope.CYCLE          assert dn_1.scope == Scope.CYCLE          assert dn_2.scope == Scope.CYCLE          dn_2.scope = Scope.SCENARIO          assert dn_1.scope == Scope.SCENARIO          assert dn_2.scope == Scope.SCENARIO            new_datetime = current_datetime + timedelta(1)          new_datetime_1 = current_datetime + timedelta(3)            # auto set & reload on last_edit_date attribute          assert dn_1.last_edit_date == current_datetime          assert dn_2.last_edit_date == current_datetime          dn_1.last_edit_date = new_datetime_1          assert dn_1.last_edit_date == new_datetime_1          assert dn_2.last_edit_date == new_datetime_1          dn_2.last_edit_date = new_datetime          assert dn_1.last_edit_date == new_datetime          assert dn_2.last_edit_date == new_datetime            # auto set & reload on name attribute          assert dn_1.name == \"foo\"          assert dn_2.name == \"foo\"          dn_1.name = \"fed\"          assert dn_1.name == \"fed\"          assert dn_2.name == \"fed\"          dn_2.name = \"def\"          assert dn_1.name == \"def\"          assert dn_2.name == \"def\"            # auto set & reload on parent_ids attribute (set() object does not have auto set yet)          assert dn_1.parent_ids == set()          assert dn_2.parent_ids == set()          dn_1._parent_ids.update([\"sc2\"])          _DataManager._set(dn_1)          assert dn_1.parent_ids == {\"sc2\"}          assert dn_2.parent_ids == {\"sc2\"}          dn_2._parent_ids.clear()          dn_2._parent_ids.update([\"sc1\"])          _DataManager._set(dn_2)          assert dn_1.parent_ids == {\"sc1\"}          assert dn_2.parent_ids == {\"sc1\"}            # auto set & reload on edit_in_progress attribute          assert not dn_2.edit_in_progress          assert not dn_1.edit_in_progress          dn_1.edit_in_progress = True          assert dn_1.edit_in_progress          assert dn_2.edit_in_progress          dn_2.unlock_edit()          assert not dn_1.edit_in_progress          assert not dn_2.edit_in_progress          dn_1.lock_edit()          assert dn_1.edit_in_progress          assert dn_2.edit_in_progress            # auto set & reload on validity_period attribute          time_period_1 = timedelta(1)          time_period_2 = timedelta(5)          assert dn_1.validity_period is None          assert dn_2.validity_period is None          dn_1.validity_period = time_period_1          assert dn_1.validity_period == time_period_1          assert dn_2.validity_period == time_period_1          dn_2.validity_period = time_period_2          assert dn_1.validity_period == time_period_2          assert dn_2.validity_period == time_period_2            # auto set & reload on properties attribute          assert dn_1.properties == {\"name\": \"def\"}          assert dn_2.properties == {\"name\": \"def\"}          dn_1._properties[\"qux\"] = 4          assert dn_1.properties[\"qux\"] == 4          assert dn_2.properties[\"qux\"] == 4            assert dn_1.properties == {\"qux\": 4, \"name\": \"def\"}          assert dn_2.properties == {\"qux\": 4, \"name\": \"def\"}          dn_2._properties[\"qux\"] = 5          assert dn_1.properties[\"qux\"] == 5          assert dn_2.properties[\"qux\"] == 5            dn_1.properties[\"temp_key_1\"] = \"temp_value_1\"          dn_1.properties[\"temp_key_2\"] = \"temp_value_2\"          assert dn_1.properties == {              \"name\": \"def\",              \"qux\": 5,              \"temp_key_1\": \"temp_value_1\",              \"temp_key_2\": \"temp_value_2\",          }          assert dn_2.properties == {              \"name\": \"def\",              \"qux\": 5,              \"temp_key_1\": \"temp_value_1\",              \"temp_key_2\": \"temp_value_2\",          }          dn_1.properties.pop(\"temp_key_1\")          assert \"temp_key_1\" not in dn_1.properties.keys()          assert \"temp_key_1\" not in dn_1.properties.keys()          assert dn_1.properties == {              \"name\": \"def\",              \"qux\": 5,              \"temp_key_2\": \"temp_value_2\",          }          assert dn_2.properties == {              \"name\": \"def\",              \"qux\": 5,              \"temp_key_2\": \"temp_value_2\",          }          dn_2.properties.pop(\"temp_key_2\")          assert dn_1.properties == {              \"qux\": 5,              \"name\": \"def\",          }          assert dn_2.properties == {              \"qux\": 5,              \"name\": \"def\",          }          assert \"temp_key_2\" not in dn_1.properties.keys()          assert \"temp_key_2\" not in dn_2.properties.keys()            dn_1.properties[\"temp_key_3\"] = 0          assert dn_1.properties == {              \"qux\": 5,              \"temp_key_3\": 0,              \"name\": \"def\",          }          assert dn_2.properties == {              \"qux\": 5,              \"temp_key_3\": 0,              \"name\": \"def\",          }          dn_1.properties.update({\"temp_key_3\": 1})          assert dn_1.properties == {              \"qux\": 5,              \"temp_key_3\": 1,              \"name\": \"def\",          }          assert dn_2.properties == {              \"qux\": 5,              \"temp_key_3\": 1,              \"name\": \"def\",          }          dn_1.properties.update(dict())          assert dn_1.properties == {              \"qux\": 5,              \"temp_key_3\": 1,              \"name\": \"def\",          }          assert dn_2.properties == {              \"qux\": 5,              \"temp_key_3\": 1,              \"name\": \"def\",          }          dn_1.properties[\"temp_key_4\"] = 0          dn_1.properties[\"temp_key_5\"] = 0            dn_1.last_edit_date = new_datetime            assert len(dn_1.job_ids) == 1          assert len(dn_2.job_ids) == 1            with dn_1 as dn:              assert dn.config_id == \"foo\"              assert dn.owner_id is None              assert dn.scope == Scope.SCENARIO              assert dn.last_edit_date == new_datetime              assert dn.name == \"def\"              assert dn.edit_in_progress              assert dn.validity_period == time_period_2              assert len(dn.job_ids) == 1              assert dn._is_in_context              assert dn.properties[\"qux\"] == 5              assert dn.properties[\"temp_key_3\"] == 1              assert dn.properties[\"temp_key_4\"] == 0              assert dn.properties[\"temp_key_5\"] == 0                new_datetime_2 = new_datetime + timedelta(5)                dn.scope = Scope.CYCLE              dn.last_edit_date = new_datetime_2              dn.name = \"abc\"              dn.edit_in_progress = False              dn.validity_period = None              dn.properties[\"qux\"] = 9              dn.properties.pop(\"temp_key_3\")              dn.properties.pop(\"temp_key_4\")              dn.properties.update({\"temp_key_4\": 1})              dn.properties.update({\"temp_key_5\": 2})              dn.properties.pop(\"temp_key_5\")              dn.properties.update(dict())                assert dn.config_id == \"foo\"              assert dn.owner_id is None              assert dn.scope == Scope.SCENARIO              assert dn.last_edit_date == new_datetime              assert dn.name == \"def\"              assert dn.edit_in_progress              assert dn.validity_period == time_period_2              assert len(dn.job_ids) == 1              assert dn.properties[\"qux\"] == 5              assert dn.properties[\"temp_key_3\"] == 1              assert dn.properties[\"temp_key_4\"] == 0              assert dn.properties[\"temp_key_5\"] == 0            assert dn_1.config_id == \"foo\"          assert dn_1.owner_id is None          assert dn_1.scope == Scope.CYCLE          assert dn_1.last_edit_date == new_datetime_2          assert dn_1.name == \"abc\"          assert not dn_1.edit_in_progress          assert dn_1.validity_period is None          assert not dn_1._is_in_context          assert len(dn_1.job_ids) == 1          assert dn_1.properties[\"qux\"] == 9          assert \"temp_key_3\" not in dn_1.properties.keys()          assert dn_1.properties[\"temp_key_4\"] == 1          assert \"temp_key_5\" not in dn_1.properties.keys()        def test_get_parents(self, data_node):          with mock.patch(\"src.taipy.core.get_parents\") as mck:              data_node.get_parents()              mck.assert_called_once_with(data_node)        def test_cacheable_deprecated_false(self):          dn = FakeDataNode(\"foo\")          with pytest.warns(DeprecationWarning):              dn.cacheable          assert dn.cacheable is False        def test_cacheable_deprecated_true(self):          dn = FakeDataNode(\"foo\", properties={\"cacheable\": True})          with pytest.warns(DeprecationWarning):              dn.cacheable          assert dn.cacheable is True        def test_data_node_with_env_variable_value_not_stored(self):          dn_config = Config.configure_data_node(\"A\", prop=\"ENV[FOO]\")          with mock.patch.dict(os.environ, {\"FOO\": \"bar\"}):              dn = _DataManager._bulk_get_or_create([dn_config])[dn_config]              assert dn._properties.data[\"prop\"] == \"ENV[FOO]\"              assert dn.properties[\"prop\"] == \"bar\"              assert dn.prop == \"bar\"        def test_path_populated_with_config_default_path(self):          dn_config = Config.configure_data_node(\"data_node\", \"pickle\", default_path=\"foo.p\")          assert dn_config.default_path == \"foo.p\"          data_node = _DataManager._bulk_get_or_create([dn_config])[dn_config]          assert data_node.path == \"foo.p\"          data_node.path = \"baz.p\"          assert data_node.path == \"baz.p\"        def test_track_edit(self):          dn_config = Config.configure_data_node(\"A\")          data_node = _DataManager._bulk_get_or_create([dn_config])[dn_config]            data_node.write(data=\"1\", job_id=\"job_1\")          data_node.write(data=\"2\", job_id=\"job_1\")          data_node.write(data=\"3\", job_id=\"job_1\")            assert len(data_node.edits) == 3          assert len(data_node.job_ids) == 3          assert data_node.edits[-1] == data_node.get_last_edit()          assert data_node.last_edit_date == data_node.get_last_edit().get(\"timestamp\")            date = datetime(2050, 1, 1, 12, 12)          data_node.write(data=\"4\", timestamp=date, message=\"This is a comment on this edit\", env=\"staging\")            assert len(data_node.edits) == 4          assert len(data_node.job_ids) == 3          assert data_node.edits[-1] == data_node.get_last_edit()            last_edit = data_node.get_last_edit()          assert last_edit[\"message\"] == \"This is a comment on this edit\"          assert last_edit[\"env\"] == \"staging\"          assert last_edit[\"timestamp\"] == date        def test_label(self):          a_date = datetime.now()          dn = DataNode(              \"foo_bar\",              Scope.SCENARIO,              DataNodeId(\"an_id\"),              \"a_scenario_id\",              {\"a_parent_id\"},              a_date,              [dict(job_id=\"a_job_id\")],              edit_in_progress=False,              prop=\"erty\",              name=\"a name\",          )          with mock.patch(\"src.taipy.core.get\") as get_mck:                class MockOwner:                  label = \"owner_label\"                    def get_label(self):                      return self.label                get_mck.return_value = MockOwner()              assert dn.get_label() == \"owner_label > \" + dn.name              assert dn.get_simple_label() == dn.name        def test_explicit_label(self):          a_date = datetime.now()          dn = DataNode(              \"foo_bar\",              Scope.SCENARIO,              DataNodeId(\"an_id\"),              \"a_scenario_id\",              {\"a_parent_id\"},              a_date,              [dict(job_id=\"a_job_id\")],              edit_in_progress=False,              label=\"a label\",              name=\"a name\",          )          assert dn.get_label() == \"a label\"          assert dn.get_simple_label() == \"a label\"        def test_change_data_node_name(self):          cgf = Config.configure_data_node(\"foo\", scope=Scope.GLOBAL)          dn = tp.create_global_data_node(cgf)            dn.name = \"bar\"          assert dn.name == \"bar\"            # This new syntax will be the only one allowed: https://github.com/Avaiga/taipy-core/issues/806          dn.properties[\"name\"] = \"baz\"          assert dn.name == \"baz\" "}
{"text": "import os  import pathlib  from datetime import datetime  from time import sleep    import modin.pandas as modin_pd  import numpy as np  import pandas as pd  import pytest  from modin.pandas.test.utils import df_equals  from pandas.testing import assert_frame_equal    from src.taipy.core.data._data_manager import _DataManager  from src.taipy.core.data.csv import CSVDataNode  from src.taipy.core.data.data_node_id import DataNodeId  from src.taipy.core.data.operator import JoinOperator, Operator  from src.taipy.core.exceptions.exceptions import InvalidExposedType, NoData  from taipy.config.common.scope import Scope  from taipy.config.config import Config  from taipy.config.exceptions.exceptions import InvalidConfigurationId      @pytest.fixture(scope=\"function\", autouse=True)  def cleanup():      yield      path = os.path.join(pathlib.Path(__file__).parent.resolve(), \"data_sample/temp.csv\")      if os.path.isfile(path):          os.remove(path)      class MyCustomObject:      def __init__(self, id, integer, text):          self.id = id          self.integer = integer          self.text = text      class TestCSVDataNode:      def test_create(self):          path = \"data/node/path\"          dn = CSVDataNode(              \"foo_bar\", Scope.SCENARIO, properties={\"path\": path, \"has_header\": False, \"name\": \"super name\"}          )          assert isinstance(dn, CSVDataNode)          assert dn.storage_type() == \"csv\"          assert dn.config_id == \"foo_bar\"          assert dn.name == \"super name\"          assert dn.scope == Scope.SCENARIO          assert dn.id is not None          assert dn.owner_id is None          assert dn.last_edit_date is None          assert dn.job_ids == []          assert not dn.is_ready_for_reading          assert dn.path == path          assert dn.has_header is False          assert dn.exposed_type == \"pandas\"            with pytest.raises(InvalidConfigurationId):              dn = CSVDataNode(                  \"foo bar\", Scope.SCENARIO, properties={\"path\": path, \"has_header\": False, \"name\": \"super name\"}              )        def test_get_user_properties(self, csv_file):          dn_1 = CSVDataNode(\"dn_1\", Scope.SCENARIO, properties={\"path\": \"data/node/path\"})          assert dn_1._get_user_properties() == {}            dn_2 = CSVDataNode(              \"dn_2\",              Scope.SCENARIO,              properties={                  \"exposed_type\": \"numpy\",                  \"default_data\": \"foo\",                  \"default_path\": csv_file,                  \"has_header\": False,                  \"foo\": \"bar\",              },          )            # exposed_type, default_data, default_path, path, has_header, sheet_name are filtered out          assert dn_2._get_user_properties() == {\"foo\": \"bar\"}        def test_new_csv_data_node_with_existing_file_is_ready_for_reading(self):          not_ready_dn_cfg = Config.configure_data_node(\"not_ready_data_node_config_id\", \"csv\", path=\"NOT_EXISTING.csv\")          not_ready_dn = _DataManager._bulk_get_or_create([not_ready_dn_cfg])[not_ready_dn_cfg]          assert not not_ready_dn.is_ready_for_reading            path = os.path.join(pathlib.Path(__file__).parent.resolve(), \"data_sample/example.csv\")          ready_dn_cfg = Config.configure_data_node(\"ready_data_node_config_id\", \"csv\", path=path)          ready_dn = _DataManager._bulk_get_or_create([ready_dn_cfg])[ready_dn_cfg]          assert ready_dn.is_ready_for_reading        @pytest.mark.parametrize(          [\"properties\", \"exists\"],          [              ({}, False),              ({\"default_data\": [\"foo\", \"bar\"]}, True),          ],      )      def test_create_with_default_data(self, properties, exists):          dn = CSVDataNode(\"foo\", Scope.SCENARIO, DataNodeId(\"dn_id\"), properties=properties)          assert os.path.exists(dn.path) is exists        def test_read_with_header(self):          not_existing_csv = CSVDataNode(\"foo\", Scope.SCENARIO, properties={\"path\": \"WRONG.csv\", \"has_header\": True})          with pytest.raises(NoData):              assert not_existing_csv.read() is None              not_existing_csv.read_or_raise()            path = os.path.join(pathlib.Path(__file__).parent.resolve(), \"data_sample/example.csv\")          # # Create CSVDataNode without exposed_type (Default is pandas.DataFrame)          csv_data_node_as_pandas = CSVDataNode(\"bar\", Scope.SCENARIO, properties={\"path\": path})          data_pandas = csv_data_node_as_pandas.read()          assert isinstance(data_pandas, pd.DataFrame)          assert len(data_pandas) == 10          assert np.array_equal(data_pandas.to_numpy(), pd.read_csv(path).to_numpy())            # Create CSVDataNode with modin exposed_type          csv_data_node_as_modin = CSVDataNode(\"bar\", Scope.SCENARIO, properties={\"path\": path, \"exposed_type\": \"modin\"})          data_modin = csv_data_node_as_modin.read()          assert isinstance(data_modin, modin_pd.DataFrame)          assert len(data_modin) == 10          assert np.array_equal(data_modin.to_numpy(), modin_pd.read_csv(path).to_numpy())            # Create CSVDataNode with numpy exposed_type          csv_data_node_as_numpy = CSVDataNode(              \"bar\", Scope.SCENARIO, properties={\"path\": path, \"has_header\": True, \"exposed_type\": \"numpy\"}          )          data_numpy = csv_data_node_as_numpy.read()          assert isinstance(data_numpy, np.ndarray)          assert len(data_numpy) == 10          assert np.array_equal(data_numpy, pd.read_csv(path).to_numpy())            # Create the same CSVDataNode but with custom exposed_type          csv_data_node_as_custom_object = CSVDataNode(              \"bar\", Scope.SCENARIO, properties={\"path\": path, \"exposed_type\": MyCustomObject}          )          data_custom = csv_data_node_as_custom_object.read()          assert isinstance(data_custom, list)          assert len(data_custom) == 10            for (index, row_pandas), row_custom in zip(data_pandas.iterrows(), data_custom):              assert isinstance(row_custom, MyCustomObject)              assert row_pandas[\"id\"] == row_custom.id              assert str(row_pandas[\"integer\"]) == row_custom.integer              assert row_pandas[\"text\"] == row_custom.text        def test_read_without_header(self):          not_existing_csv = CSVDataNode(\"foo\", Scope.SCENARIO, properties={\"path\": \"WRONG.csv\", \"has_header\": False})          with pytest.raises(NoData):              assert not_existing_csv.read() is None              not_existing_csv.read_or_raise()            path = os.path.join(pathlib.Path(__file__).parent.resolve(), \"data_sample/example.csv\")          # Create CSVDataNode without exposed_type (Default is pandas.DataFrame)          csv_data_node_as_pandas = CSVDataNode(\"bar\", Scope.SCENARIO, properties={\"path\": path, \"has_header\": False})          data_pandas = csv_data_node_as_pandas.read()          assert isinstance(data_pandas, pd.DataFrame)          assert len(data_pandas) == 11          assert np.array_equal(data_pandas.to_numpy(), pd.read_csv(path, header=None).to_numpy())            # Create CSVDataNode with modin exposed_type          csv_data_node_as_modin = CSVDataNode(              \"baz\", Scope.SCENARIO, properties={\"path\": path, \"has_header\": False, \"exposed_type\": \"modin\"}          )          data_modin = csv_data_node_as_modin.read()          assert isinstance(data_modin, modin_pd.DataFrame)          assert len(data_modin) == 11          assert np.array_equal(data_modin.to_numpy(), modin_pd.read_csv(path, header=None).to_numpy())            # Create CSVDataNode with numpy exposed_type          csv_data_node_as_numpy = CSVDataNode(              \"qux\", Scope.SCENARIO, properties={\"path\": path, \"has_header\": False, \"exposed_type\": \"numpy\"}          )          data_numpy = csv_data_node_as_numpy.read()          assert isinstance(data_numpy, np.ndarray)          assert len(data_numpy) == 11          assert np.array_equal(data_numpy, pd.read_csv(path, header=None).to_numpy())            # Create the same CSVDataNode but with custom exposed_type          csv_data_node_as_custom_object = CSVDataNode(              \"quux\", Scope.SCENARIO, properties={\"path\": path, \"has_header\": False, \"exposed_type\": MyCustomObject}          )          data_custom = csv_data_node_as_custom_object.read()          assert isinstance(data_custom, list)          assert len(data_custom) == 11            for (index, row_pandas), row_custom in zip(data_pandas.iterrows(), data_custom):              assert isinstance(row_custom, MyCustomObject)              assert row_pandas[0] == row_custom.id              assert str(row_pandas[1]) == row_custom.integer              assert row_pandas[2] == row_custom.text        @pytest.mark.parametrize(          \"content\",          [              ([{\"a\": 11, \"b\": 22, \"c\": 33}, {\"a\": 44, \"b\": 55, \"c\": 66}]),              (pd.DataFrame([{\"a\": 11, \"b\": 22, \"c\": 33}, {\"a\": 44, \"b\": 55, \"c\": 66}])),              ([[11, 22, 33], [44, 55, 66]]),          ],      )      def test_append(self, csv_file, default_data_frame, content):          csv_dn = CSVDataNode(\"foo\", Scope.SCENARIO, properties={\"path\": csv_file})          assert_frame_equal(csv_dn.read(), default_data_frame)            csv_dn.append(content)          assert_frame_equal(              csv_dn.read(),              pd.concat([default_data_frame, pd.DataFrame(content, columns=[\"a\", \"b\", \"c\"])]).reset_index(drop=True),          )        @pytest.mark.parametrize(          \"content\",          [              ([{\"a\": 11, \"b\": 22, \"c\": 33}, {\"a\": 44, \"b\": 55, \"c\": 66}]),              (pd.DataFrame([{\"a\": 11, \"b\": 22, \"c\": 33}, {\"a\": 44, \"b\": 55, \"c\": 66}])),              ([[11, 22, 33], [44, 55, 66]]),          ],      )      def test_append_modin(self, csv_file, default_data_frame, content):          csv_dn = CSVDataNode(\"foo\", Scope.SCENARIO, properties={\"path\": csv_file, \"exposed_type\": \"modin\"})          df_equals(csv_dn.read(), modin_pd.DataFrame(default_data_frame))            csv_dn.append(content)          df_equals(              csv_dn.read(),              modin_pd.concat([default_data_frame, pd.DataFrame(content, columns=[\"a\", \"b\", \"c\"])]).reset_index(                  drop=True              ),          )        @pytest.mark.parametrize(          \"content,columns\",          [              ([{\"a\": 11, \"b\": 22, \"c\": 33}, {\"a\": 44, \"b\": 55, \"c\": 66}], None),              ([[11, 22, 33], [44, 55, 66]], None),              ([[11, 22, 33], [44, 55, 66]], [\"e\", \"f\", \"g\"]),          ],      )      def test_write(self, csv_file, default_data_frame, content, columns):          csv_dn = CSVDataNode(\"foo\", Scope.SCENARIO, properties={\"path\": csv_file})          assert np.array_equal(csv_dn.read().values, default_data_frame.values)          if not columns:              csv_dn.write(content)              df = pd.DataFrame(content)          else:              csv_dn.write_with_column_names(content, columns)              df = pd.DataFrame(content, columns=columns)          assert np.array_equal(csv_dn.read().values, df.values)            csv_dn.write(None)          assert len(csv_dn.read()) == 0        def test_write_with_different_encoding(self, csv_file):          data = pd.DataFrame([{\"\u2265a\": 1, \"b\": 2}])            utf8_dn = CSVDataNode(\"utf8_dn\", Scope.SCENARIO, properties={\"default_path\": csv_file})          utf16_dn = CSVDataNode(\"utf16_dn\", Scope.SCENARIO, properties={\"default_path\": csv_file, \"encoding\": \"utf-16\"})            # If a file is written with utf-8 encoding, it can only be read with utf-8, not utf-16 encoding          utf8_dn.write(data)          assert np.array_equal(utf8_dn.read(), data)          with pytest.raises(UnicodeError):              utf16_dn.read()            # If a file is written with utf-16 encoding, it can only be read with utf-16, not utf-8 encoding          utf16_dn.write(data)          assert np.array_equal(utf16_dn.read(), data)          with pytest.raises(UnicodeError):              utf8_dn.read()        @pytest.mark.parametrize(          \"content,columns\",          [              ([{\"a\": 11, \"b\": 22, \"c\": 33}, {\"a\": 44, \"b\": 55, \"c\": 66}], None),              ([[11, 22, 33], [44, 55, 66]], None),              ([[11, 22, 33], [44, 55, 66]], [\"e\", \"f\", \"g\"]),          ],      )      def test_write_modin(self, csv_file, default_data_frame, content, columns):          default_data_frame = modin_pd.DataFrame(default_data_frame)          csv_dn = CSVDataNode(\"foo\", Scope.SCENARIO, properties={\"path\": csv_file, \"exposed_type\": \"modin\"})          assert np.array_equal(csv_dn.read().values, default_data_frame.values)          if not columns:              csv_dn.write(content)              df = pd.DataFrame(content)          else:              csv_dn.write_with_column_names(content, columns)              df = pd.DataFrame(content, columns=columns)          assert np.array_equal(csv_dn.read().values, df.values)            csv_dn.write(None)          assert len(csv_dn.read()) == 0        def test_write_modin_with_different_encoding(self, csv_file):          data = pd.DataFrame([{\"\u2265a\": 1, \"b\": 2}])            utf8_dn = CSVDataNode(\"utf8_dn\", Scope.SCENARIO, properties={\"path\": csv_file, \"exposed_type\": \"modin\"})          utf16_dn = CSVDataNode(              \"utf16_dn\", Scope.SCENARIO, properties={\"path\": csv_file, \"exposed_type\": \"modin\", \"encoding\": \"utf-16\"}          )            # If a file is written with utf-8 encoding, it can only be read with utf-8, not utf-16 encoding          utf8_dn.write(data)          assert np.array_equal(utf8_dn.read(), data)          with pytest.raises(UnicodeError):              utf16_dn.read()            # If a file is written with utf-16 encoding, it can only be read with utf-16, not utf-8 encoding          utf16_dn.write(data)          assert np.array_equal(utf16_dn.read(), data)          with pytest.raises(UnicodeError):              utf8_dn.read()        def test_set_path(self):          dn = CSVDataNode(\"foo\", Scope.SCENARIO, properties={\"default_path\": \"foo.csv\"})          assert dn.path == \"foo.csv\"          dn.path = \"bar.csv\"          assert dn.path == \"bar.csv\"        def test_read_write_after_modify_path(self):          path = os.path.join(pathlib.Path(__file__).parent.resolve(), \"data_sample/example.csv\")          new_path = os.path.join(pathlib.Path(__file__).parent.resolve(), \"data_sample/temp.csv\")          dn = CSVDataNode(\"foo\", Scope.SCENARIO, properties={\"default_path\": path})          read_data = dn.read()          assert read_data is not None          dn.path = new_path          with pytest.raises(FileNotFoundError):              dn.read()          dn.write(read_data)          assert dn.read().equals(read_data)        def test_pandas_exposed_type(self):          path = os.path.join(pathlib.Path(__file__).parent.resolve(), \"data_sample/example.csv\")          dn = CSVDataNode(\"foo\", Scope.SCENARIO, properties={\"path\": path, \"exposed_type\": \"pandas\"})          assert isinstance(dn.read(), pd.DataFrame)        def test_filter_pandas_exposed_type(self, csv_file):          dn = CSVDataNode(\"foo\", Scope.SCENARIO, properties={\"path\": csv_file, \"exposed_type\": \"pandas\"})          dn.write(              [                  {\"foo\": 1, \"bar\": 1},                  {\"foo\": 1, \"bar\": 2},                  {\"foo\": 1},                  {\"foo\": 2, \"bar\": 2},                  {\"bar\": 2},              ]          )            # Test datanode indexing and slicing          assert dn[\"foo\"].equals(pd.Series([1, 1, 1, 2, None]))          assert dn[\"bar\"].equals(pd.Series([1, 2, None, 2, 2]))          assert dn[:2].equals(pd.DataFrame([{\"foo\": 1.0, \"bar\": 1.0}, {\"foo\": 1.0, \"bar\": 2.0}]))            # Test filter data          filtered_by_filter_method = dn.filter((\"foo\", 1, Operator.EQUAL))          filtered_by_indexing = dn[dn[\"foo\"] == 1]          expected_data = pd.DataFrame([{\"foo\": 1.0, \"bar\": 1.0}, {\"foo\": 1.0, \"bar\": 2.0}, {\"foo\": 1.0}])          assert_frame_equal(filtered_by_filter_method.reset_index(drop=True), expected_data)          assert_frame_equal(filtered_by_indexing.reset_index(drop=True), expected_data)            filtered_by_filter_method = dn.filter((\"foo\", 1, Operator.NOT_EQUAL))          filtered_by_indexing = dn[dn[\"foo\"] != 1]          expected_data = pd.DataFrame([{\"foo\": 2.0, \"bar\": 2.0}, {\"bar\": 2.0}])          assert_frame_equal(filtered_by_filter_method.reset_index(drop=True), expected_data)          assert_frame_equal(filtered_by_indexing.reset_index(drop=True), expected_data)            filtered_by_filter_method = dn.filter((\"bar\", 2, Operator.EQUAL))          filtered_by_indexing = dn[dn[\"bar\"] == 2]          expected_data = pd.DataFrame([{\"foo\": 1.0, \"bar\": 2.0}, {\"foo\": 2.0, \"bar\": 2.0}, {\"bar\": 2.0}])          assert_frame_equal(filtered_by_filter_method.reset_index(drop=True), expected_data)          assert_frame_equal(filtered_by_indexing.reset_index(drop=True), expected_data)            filtered_by_filter_method = dn.filter([(\"bar\", 1, Operator.EQUAL), (\"bar\", 2, Operator.EQUAL)], JoinOperator.OR)          filtered_by_indexing = dn[(dn[\"bar\"] == 1) | (dn[\"bar\"] == 2)]          expected_data = pd.DataFrame(              [                  {\"foo\": 1.0, \"bar\": 1.0},                  {\"foo\": 1.0, \"bar\": 2.0},                  {\"foo\": 2.0, \"bar\": 2.0},                  {\"bar\": 2.0},              ]          )          assert_frame_equal(filtered_by_filter_method.reset_index(drop=True), expected_data)          assert_frame_equal(filtered_by_indexing.reset_index(drop=True), expected_data)        def test_filter_modin_exposed_type(self, csv_file):          dn = CSVDataNode(\"foo\", Scope.SCENARIO, properties={\"path\": csv_file, \"exposed_type\": \"modin\"})          dn.write(              [                  {\"foo\": 1, \"bar\": 1},                  {\"foo\": 1, \"bar\": 2},                  {\"foo\": 1},                  {\"foo\": 2, \"bar\": 2},                  {\"bar\": 2},              ]          )            # Test datanode indexing and slicing          assert dn[\"foo\"].equals(modin_pd.Series([1, 1, 1, 2, None]))          assert dn[\"bar\"].equals(modin_pd.Series([1, 2, None, 2, 2]))          assert dn[:2].equals(modin_pd.DataFrame([{\"foo\": 1.0, \"bar\": 1.0}, {\"foo\": 1.0, \"bar\": 2.0}]))            # Test filter data          filtered_by_filter_method = dn.filter((\"foo\", 1, Operator.EQUAL))          filtered_by_indexing = dn[dn[\"foo\"] == 1]          expected_data = modin_pd.DataFrame([{\"foo\": 1.0, \"bar\": 1.0}, {\"foo\": 1.0, \"bar\": 2.0}, {\"foo\": 1.0}])          df_equals(filtered_by_filter_method.reset_index(drop=True), expected_data)          df_equals(filtered_by_indexing.reset_index(drop=True), expected_data)            filtered_by_filter_method = dn.filter((\"foo\", 1, Operator.NOT_EQUAL))          filtered_by_indexing = dn[dn[\"foo\"] != 1]          expected_data = modin_pd.DataFrame([{\"foo\": 2.0, \"bar\": 2.0}, {\"bar\": 2.0}])          df_equals(filtered_by_filter_method.reset_index(drop=True), expected_data)          df_equals(filtered_by_indexing.reset_index(drop=True), expected_data)            filtered_by_filter_method = dn.filter((\"bar\", 2, Operator.EQUAL))          filtered_by_indexing = dn[dn[\"bar\"] == 2]          expected_data = modin_pd.DataFrame([{\"foo\": 1.0, \"bar\": 2.0}, {\"foo\": 2.0, \"bar\": 2.0}, {\"bar\": 2.0}])          df_equals(filtered_by_filter_method.reset_index(drop=True), expected_data)          df_equals(filtered_by_indexing.reset_index(drop=True), expected_data)            filtered_by_filter_method = dn.filter([(\"bar\", 1, Operator.EQUAL), (\"bar\", 2, Operator.EQUAL)], JoinOperator.OR)          filtered_by_indexing = dn[(dn[\"bar\"] == 1) | (dn[\"bar\"] == 2)]          expected_data = modin_pd.DataFrame(              [                  {\"foo\": 1.0, \"bar\": 1.0},                  {\"foo\": 1.0, \"bar\": 2.0},                  {\"foo\": 2.0, \"bar\": 2.0},                  {\"bar\": 2.0},              ]          )          df_equals(filtered_by_filter_method.reset_index(drop=True), expected_data)          df_equals(filtered_by_indexing.reset_index(drop=True), expected_data)        def test_filter_numpy_exposed_type(self, csv_file):          dn = CSVDataNode(\"foo\", Scope.SCENARIO, properties={\"path\": csv_file, \"exposed_type\": \"numpy\"})          dn.write(              [                  [1, 1],                  [1, 2],                  [1, 3],                  [2, 1],                  [2, 2],                  [2, 3],              ]          )            # Test datanode indexing and slicing          assert np.array_equal(dn[0], np.array([1, 1]))          assert np.array_equal(dn[1], np.array([1, 2]))          assert np.array_equal(dn[:3], np.array([[1, 1], [1, 2], [1, 3]]))          assert np.array_equal(dn[:, 0], np.array([1, 1, 1, 2, 2, 2]))          assert np.array_equal(dn[1:4, :1], np.array([[1], [1], [2]]))            # Test filter data          assert np.array_equal(dn.filter((0, 1, Operator.EQUAL)), np.array([[1, 1], [1, 2], [1, 3]]))          assert np.array_equal(dn[dn[:, 0] == 1], np.array([[1, 1], [1, 2], [1, 3]]))            assert np.array_equal(dn.filter((0, 1, Operator.NOT_EQUAL)), np.array([[2, 1], [2, 2], [2, 3]]))          assert np.array_equal(dn[dn[:, 0] != 1], np.array([[2, 1], [2, 2], [2, 3]]))            assert np.array_equal(dn.filter((1, 2, Operator.EQUAL)), np.array([[1, 2], [2, 2]]))          assert np.array_equal(dn[dn[:, 1] == 2], np.array([[1, 2], [2, 2]]))            assert np.array_equal(              dn.filter([(1, 1, Operator.EQUAL), (1, 2, Operator.EQUAL)], JoinOperator.OR),              np.array([[1, 1], [1, 2], [2, 1], [2, 2]]),          )          assert np.array_equal(dn[(dn[:, 1] == 1) | (dn[:, 1] == 2)], np.array([[1, 1], [1, 2], [2, 1], [2, 2]]))        def test_raise_error_invalid_exposed_type(self):          path = os.path.join(pathlib.Path(__file__).parent.resolve(), \"data_sample/example.csv\")          with pytest.raises(InvalidExposedType):              CSVDataNode(\"foo\", Scope.SCENARIO, properties={\"path\": path, \"exposed_type\": \"foo\"})        def test_get_system_modified_date_instead_of_last_edit_date(self, tmpdir_factory):          temp_file_path = str(tmpdir_factory.mktemp(\"data\").join(\"temp.csv\"))          pd.DataFrame([]).to_csv(temp_file_path)          dn = CSVDataNode(\"foo\", Scope.SCENARIO, properties={\"path\": temp_file_path, \"exposed_type\": \"pandas\"})            dn.write(pd.DataFrame([1, 2, 3]))          previous_edit_date = dn.last_edit_date            sleep(0.1)            pd.DataFrame([4, 5, 6]).to_csv(temp_file_path)          new_edit_date = datetime.fromtimestamp(os.path.getmtime(temp_file_path))            assert previous_edit_date < dn.last_edit_date          assert new_edit_date == dn.last_edit_date            sleep(0.1)            dn.write(pd.DataFrame([7, 8, 9]))          assert new_edit_date < dn.last_edit_date          os.unlink(temp_file_path) "}
{"text": "import os  import pathlib  from datetime import datetime  from time import sleep    import modin.pandas as modin_pd  import pandas as pd  import pytest    from src.taipy.core.data._data_manager import _DataManager  from src.taipy.core.data.pickle import PickleDataNode  from src.taipy.core.exceptions.exceptions import NoData  from taipy.config.common.scope import Scope  from taipy.config.config import Config  from taipy.config.exceptions.exceptions import InvalidConfigurationId      @pytest.fixture(scope=\"function\", autouse=True)  def cleanup():      yield      path = os.path.join(pathlib.Path(__file__).parent.resolve(), \"data_sample/temp.p\")      if os.path.isfile(path):          os.remove(path)      class TestPickleDataNodeEntity:      @pytest.fixture(scope=\"function\", autouse=True)      def remove_pickle_files(self):          yield          import glob            for f in glob.glob(\"*.p\"):              print(f\"deleting file {f}\")              os.remove(f)        def test_create(self):          dn = PickleDataNode(\"foobar_bazxyxea\", Scope.SCENARIO, properties={\"default_data\": \"Data\"})          assert os.path.isfile(Config.core.storage_folder + \"pickles/\" + dn.id + \".p\")          assert isinstance(dn, PickleDataNode)          assert dn.storage_type() == \"pickle\"          assert dn.config_id == \"foobar_bazxyxea\"          assert dn.scope == Scope.SCENARIO          assert dn.id is not None          assert dn.name is None          assert dn.owner_id is None          assert dn.last_edit_date is not None          assert dn.job_ids == []          assert dn.is_ready_for_reading          assert dn.read() == \"Data\"          assert dn.last_edit_date is not None          assert dn.job_ids == []            with pytest.raises(InvalidConfigurationId):              PickleDataNode(\"foobar bazxyxea\", Scope.SCENARIO, properties={\"default_data\": \"Data\"})        def test_get_user_properties(self, pickle_file_path):          dn_1 = PickleDataNode(\"dn_1\", Scope.SCENARIO, properties={\"path\": pickle_file_path})          assert dn_1._get_user_properties() == {}            dn_2 = PickleDataNode(              \"dn_2\",              Scope.SCENARIO,              properties={                  \"default_data\": \"foo\",                  \"default_path\": pickle_file_path,                  \"foo\": \"bar\",              },          )            # default_data, default_path, path, is_generated are filtered out          assert dn_2._get_user_properties() == {\"foo\": \"bar\"}        def test_new_pickle_data_node_with_existing_file_is_ready_for_reading(self):          not_ready_dn_cfg = Config.configure_data_node(\"not_ready_data_node_config_id\", \"pickle\", path=\"NOT_EXISTING.p\")          path = os.path.join(pathlib.Path(__file__).parent.resolve(), \"data_sample/example.p\")          ready_dn_cfg = Config.configure_data_node(\"ready_data_node_config_id\", \"pickle\", path=path)            dns = _DataManager._bulk_get_or_create([not_ready_dn_cfg, ready_dn_cfg])            assert not dns[not_ready_dn_cfg].is_ready_for_reading          assert dns[ready_dn_cfg].is_ready_for_reading        def test_create_with_file_name(self):          dn = PickleDataNode(\"foo\", Scope.SCENARIO, properties={\"default_data\": \"bar\", \"path\": \"foo.FILE.p\"})          assert os.path.isfile(\"foo.FILE.p\")          assert dn.read() == \"bar\"          dn.write(\"qux\")          assert dn.read() == \"qux\"          dn.write(1998)          assert dn.read() == 1998        def test_read_and_write(self):          no_data_dn = PickleDataNode(\"foo\", Scope.SCENARIO)          with pytest.raises(NoData):              assert no_data_dn.read() is None              no_data_dn.read_or_raise()          pickle_str = PickleDataNode(\"foo\", Scope.SCENARIO, properties={\"default_data\": \"bar\"})          assert isinstance(pickle_str.read(), str)          assert pickle_str.read() == \"bar\"          pickle_str.properties[\"default_data\"] = \"baz\"  # this modifies the default data value but not the data itself          assert pickle_str.read() == \"bar\"          pickle_str.write(\"qux\")          assert pickle_str.read() == \"qux\"          pickle_str.write(1998)          assert pickle_str.read() == 1998          assert isinstance(pickle_str.read(), int)          pickle_int = PickleDataNode(\"foo\", Scope.SCENARIO, properties={\"default_data\": 197})          assert isinstance(pickle_int.read(), int)          assert pickle_int.read() == 197          pickle_dict = PickleDataNode(              \"foo\", Scope.SCENARIO, properties={\"default_data\": {\"bar\": 12, \"baz\": \"qux\", \"quux\": [13]}}          )          assert isinstance(pickle_dict.read(), dict)          assert pickle_dict.read() == {\"bar\": 12, \"baz\": \"qux\", \"quux\": [13]}            default_pandas = pd.DataFrame({\"a\": [1, 2, 3], \"b\": [4, 5, 6]})          new_pandas_df = pd.DataFrame({\"c\": [7, 8, 9], \"d\": [10, 11, 12]})            default_modin = modin_pd.DataFrame({\"a\": [1, 2, 3], \"b\": [4, 5, 6]})          new_modin_df = modin_pd.DataFrame({\"c\": [7, 8, 9], \"d\": [10, 11, 12]})            pickle_pandas = PickleDataNode(\"foo\", Scope.SCENARIO, properties={\"default_data\": default_pandas})          assert isinstance(pickle_pandas.read(), pd.DataFrame)          assert default_pandas.equals(pickle_pandas.read())          pickle_pandas.write(new_pandas_df)          assert new_pandas_df.equals(pickle_pandas.read())          assert isinstance(pickle_pandas.read(), pd.DataFrame)          pickle_pandas.write(new_modin_df)          assert new_modin_df.equals(pickle_pandas.read())          assert isinstance(pickle_pandas.read(), modin_pd.DataFrame)          pickle_pandas.write(1998)          assert pickle_pandas.read() == 1998          assert isinstance(pickle_pandas.read(), int)            pickle_modin = PickleDataNode(\"foo\", Scope.SCENARIO, properties={\"default_data\": default_modin})          assert isinstance(pickle_modin.read(), modin_pd.DataFrame)          assert default_modin.equals(pickle_modin.read())          pickle_modin.write(new_modin_df)          assert new_modin_df.equals(pickle_modin.read())          assert isinstance(pickle_modin.read(), modin_pd.DataFrame)          pickle_modin.write(new_pandas_df)          assert new_pandas_df.equals(pickle_modin.read())          assert isinstance(pickle_modin.read(), pd.DataFrame)          pickle_modin.write(1998)          assert pickle_modin.read() == 1998          assert isinstance(pickle_modin.read(), int)        def test_path_overrides_default_path(self):          dn = PickleDataNode(              \"foo\",              Scope.SCENARIO,              properties={                  \"default_data\": \"bar\",                  \"default_path\": \"foo.FILE.p\",                  \"path\": \"bar.FILE.p\",              },          )          assert dn.path == \"bar.FILE.p\"        def test_set_path(self):          dn = PickleDataNode(\"foo\", Scope.SCENARIO, properties={\"default_path\": \"foo.p\"})          assert dn.path == \"foo.p\"          dn.path = \"bar.p\"          assert dn.path == \"bar.p\"        def test_is_generated(self):          dn = PickleDataNode(\"foo\", Scope.SCENARIO, properties={})          assert dn.is_generated          dn.path = \"bar.p\"          assert not dn.is_generated        def test_read_write_after_modify_path(self):          path = os.path.join(pathlib.Path(__file__).parent.resolve(), \"data_sample/example.p\")          new_path = os.path.join(pathlib.Path(__file__).parent.resolve(), \"data_sample/temp.p\")          dn = PickleDataNode(\"foo\", Scope.SCENARIO, properties={\"default_path\": path})          read_data = dn.read()          assert read_data is not None          dn.path = new_path          with pytest.raises(FileNotFoundError):              dn.read()          dn.write({\"other\": \"stuff\"})          assert dn.read() == {\"other\": \"stuff\"}        def test_get_system_modified_date_instead_of_last_edit_date(self, tmpdir_factory):          temp_file_path = str(tmpdir_factory.mktemp(\"data\").join(\"temp.pickle\"))          pd.DataFrame([]).to_pickle(temp_file_path)          dn = PickleDataNode(\"foo\", Scope.SCENARIO, properties={\"path\": temp_file_path, \"exposed_type\": \"pandas\"})            dn.write(pd.DataFrame([1, 2, 3]))          previous_edit_date = dn.last_edit_date            sleep(0.1)            pd.DataFrame([4, 5, 6]).to_pickle(temp_file_path)          new_edit_date = datetime.fromtimestamp(os.path.getmtime(temp_file_path))            assert previous_edit_date < dn.last_edit_date          assert new_edit_date == dn.last_edit_date            sleep(0.1)            dn.write(pd.DataFrame([7, 8, 9]))          assert new_edit_date < dn.last_edit_date          os.unlink(temp_file_path) "}
{"text": "import pytest    from src.taipy.core.data.data_node import DataNode  from src.taipy.core.data.data_node_id import DataNodeId  from src.taipy.core.data.generic import GenericDataNode  from src.taipy.core.exceptions.exceptions import MissingReadFunction, MissingRequiredProperty, MissingWriteFunction  from taipy.config.common.scope import Scope  from taipy.config.exceptions.exceptions import InvalidConfigurationId      def read_fct():      return TestGenericDataNode.data      def read_fct_with_args(inp):      return [i + inp for i in TestGenericDataNode.data]      def write_fct(data):      data.append(data[-1] + 1)      def write_fct_with_args(data, inp):      for _ in range(inp):          data.append(data[-1] + 1)      def read_fct_modify_data_node_name(data_node_id: DataNodeId, name: str):      import src.taipy.core as tp        data_node = tp.get(data_node_id)      assert isinstance(data_node, DataNode)      data_node.name = name  # type:ignore      return data_node      def reset_data():      TestGenericDataNode.data = [i for i in range(10)]      class TestGenericDataNode:      data = [i for i in range(10)]        def test_create(self):          dn = GenericDataNode(              \"foo_bar\", Scope.SCENARIO, properties={\"read_fct\": read_fct, \"write_fct\": write_fct, \"name\": \"super name\"}          )          assert isinstance(dn, GenericDataNode)          assert dn.storage_type() == \"generic\"          assert dn.config_id == \"foo_bar\"          assert dn.name == \"super name\"          assert dn.scope == Scope.SCENARIO          assert dn.id is not None          assert dn.owner_id is None          assert dn.last_edit_date is not None          assert dn.job_ids == []          assert dn.is_ready_for_reading          assert dn.properties[\"read_fct\"] == read_fct          assert dn.properties[\"write_fct\"] == write_fct            dn_1 = GenericDataNode(              \"foo\", Scope.SCENARIO, properties={\"read_fct\": read_fct, \"write_fct\": None, \"name\": \"foo\"}          )          assert isinstance(dn, GenericDataNode)          assert dn_1.storage_type() == \"generic\"          assert dn_1.config_id == \"foo\"          assert dn_1.name == \"foo\"          assert dn_1.scope == Scope.SCENARIO          assert dn_1.id is not None          assert dn_1.owner_id is None          assert dn_1.last_edit_date is not None          assert dn_1.job_ids == []          assert dn_1.is_ready_for_reading          assert dn_1.properties[\"read_fct\"] == read_fct          assert dn_1.properties[\"write_fct\"] is None            dn_2 = GenericDataNode(              \"xyz\", Scope.SCENARIO, properties={\"read_fct\": None, \"write_fct\": write_fct, \"name\": \"xyz\"}          )          assert isinstance(dn, GenericDataNode)          assert dn_2.storage_type() == \"generic\"          assert dn_2.config_id == \"xyz\"          assert dn_2.name == \"xyz\"          assert dn_2.scope == Scope.SCENARIO          assert dn_2.id is not None          assert dn_2.owner_id is None          assert dn_2.last_edit_date is not None          assert dn_2.job_ids == []          assert dn_2.is_ready_for_reading          assert dn_2.properties[\"read_fct\"] is None          assert dn_2.properties[\"write_fct\"] == write_fct            dn_3 = GenericDataNode(\"xyz\", Scope.SCENARIO, properties={\"read_fct\": read_fct, \"name\": \"xyz\"})          assert isinstance(dn, GenericDataNode)          assert dn_3.storage_type() == \"generic\"          assert dn_3.config_id == \"xyz\"          assert dn_3.name == \"xyz\"          assert dn_3.scope == Scope.SCENARIO          assert dn_3.id is not None          assert dn_3.owner_id is None          assert dn_3.last_edit_date is not None          assert dn_3.job_ids == []          assert dn_3.is_ready_for_reading          assert dn_3.properties[\"read_fct\"] == read_fct          assert dn_3.properties[\"write_fct\"] is None            dn_4 = GenericDataNode(\"xyz\", Scope.SCENARIO, properties={\"write_fct\": write_fct, \"name\": \"xyz\"})          assert isinstance(dn, GenericDataNode)          assert dn_4.storage_type() == \"generic\"          assert dn_4.config_id == \"xyz\"          assert dn_4.name == \"xyz\"          assert dn_4.scope == Scope.SCENARIO          assert dn_4.id is not None          assert dn_4.owner_id is None          assert dn_4.last_edit_date is not None          assert dn_4.job_ids == []          assert dn_4.is_ready_for_reading          assert dn_4.properties[\"read_fct\"] is None          assert dn_4.properties[\"write_fct\"] == write_fct            with pytest.raises(InvalidConfigurationId):              GenericDataNode(\"foo bar\", Scope.SCENARIO, properties={\"read_fct\": read_fct, \"write_fct\": write_fct})        def test_get_user_properties(self):          dn_1 = GenericDataNode(              \"dn_1\",              Scope.SCENARIO,              properties={                  \"read_fct\": read_fct,                  \"write_fct\": write_fct,                  \"read_fct_args\": 1,                  \"write_fct_args\": 2,                  \"foo\": \"bar\",              },          )            # read_fct, read_fct_args, write_fct, write_fct_args are filtered out          assert dn_1._get_user_properties() == {\"foo\": \"bar\"}        def test_create_with_missing_parameters(self):          with pytest.raises(MissingRequiredProperty):              GenericDataNode(\"foo\", Scope.SCENARIO, DataNodeId(\"dn_id\"))          with pytest.raises(MissingRequiredProperty):              GenericDataNode(\"foo\", Scope.SCENARIO, DataNodeId(\"dn_id\"), properties={})        def test_read_write_generic_datanode(self):          generic_dn = GenericDataNode(\"foo\", Scope.SCENARIO, properties={\"read_fct\": read_fct, \"write_fct\": write_fct})            assert generic_dn.read() == self.data          assert len(generic_dn.read()) == 10            generic_dn.write(self.data)          assert generic_dn.read() == self.data          assert len(generic_dn.read()) == 11            generic_dn_1 = GenericDataNode(\"bar\", Scope.SCENARIO, properties={\"read_fct\": read_fct, \"write_fct\": None})            assert generic_dn_1.read() == self.data          assert len(generic_dn_1.read()) == 11            with pytest.raises(MissingWriteFunction):              generic_dn_1.write(self.data)            generic_dn_2 = GenericDataNode(\"xyz\", Scope.SCENARIO, properties={\"read_fct\": None, \"write_fct\": write_fct})            generic_dn_2.write(self.data)          assert len(self.data) == 12            with pytest.raises(MissingReadFunction):              generic_dn_2.read()            generic_dn_3 = GenericDataNode(\"bar\", Scope.SCENARIO, properties={\"read_fct\": None, \"write_fct\": None})            with pytest.raises(MissingReadFunction):              generic_dn_3.read()          with pytest.raises(MissingWriteFunction):              generic_dn_3.write(self.data)            reset_data()        def test_read_write_generic_datanode_with_arguments(self):          generic_dn = GenericDataNode(              \"foo\",              Scope.SCENARIO,              properties={                  \"read_fct\": read_fct_with_args,                  \"write_fct\": write_fct_with_args,                  \"read_fct_args\": [1],                  \"write_fct_args\": [2],              },          )            assert all([a + 1 == b for a, b in zip(self.data, generic_dn.read())])          assert len(generic_dn.read()) == 10            generic_dn.write(self.data)          assert len(generic_dn.read()) == 12            reset_data()        def test_read_write_generic_datanode_with_non_list_arguments(self):          generic_dn = GenericDataNode(              \"foo\",              Scope.SCENARIO,              properties={                  \"read_fct\": read_fct_with_args,                  \"write_fct\": write_fct_with_args,                  \"read_fct_args\": 1,                  \"write_fct_args\": 2,              },          )            assert all([a + 1 == b for a, b in zip(self.data, generic_dn.read())])          assert len(generic_dn.read()) == 10            generic_dn.write(self.data)          assert len(generic_dn.read()) == 12            reset_data()        def test_save_data_node_when_read(self):          generic_dn = GenericDataNode(              \"foo\", Scope.SCENARIO, properties={\"read_fct\": read_fct_modify_data_node_name, \"write_fct\": write_fct}          )          generic_dn._properties[\"read_fct_args\"] = (generic_dn.id, \"bar\")          generic_dn.read()          assert generic_dn.name == \"bar\" "}
{"text": "  from dataclasses import dataclass  from datetime import datetime  from unittest.mock import patch    import mongomock  import pymongo  import pytest  from bson import ObjectId  from bson.errors import InvalidDocument    from src.taipy.core import MongoDefaultDocument  from src.taipy.core.common._mongo_connector import _connect_mongodb  from src.taipy.core.data.data_node_id import DataNodeId  from src.taipy.core.data.mongo import MongoCollectionDataNode  from src.taipy.core.data.operator import JoinOperator, Operator  from src.taipy.core.exceptions.exceptions import InvalidCustomDocument, MissingRequiredProperty  from taipy.config.common.scope import Scope      @pytest.fixture(scope=\"function\", autouse=True)  def clear_mongo_connection_cache():      _connect_mongodb.cache_clear()      @dataclass  class CustomObjectWithoutArgs:      def __init__(self, foo=None, bar=None):          self.foo = foo          self.bar = bar      class CustomObjectWithCustomEncoder:      def __init__(self, _id=None, integer=None, text=None, time=None):          self.id = _id          self.integer = integer          self.text = text          self.time = time        def encode(self):          return {\"_id\": self.id, \"integer\": self.integer, \"text\": self.text, \"time\": self.time.isoformat()}      class CustomObjectWithCustomEncoderDecoder(CustomObjectWithCustomEncoder):      @classmethod      def decode(cls, data):          return cls(data[\"_id\"], data[\"integer\"], data[\"text\"], datetime.fromisoformat(data[\"time\"]))      class TestMongoCollectionDataNode:      __properties = [          {              \"db_username\": \"\",              \"db_password\": \"\",              \"db_name\": \"taipy\",              \"collection_name\": \"foo\",              \"custom_document\": MongoDefaultDocument,              \"db_extra_args\": {                  \"ssl\": \"true\",                  \"retrywrites\": \"false\",                  \"maxIdleTimeMS\": \"120000\",              },          }      ]        @pytest.mark.parametrize(\"properties\", __properties)      def test_create(self, properties):          mongo_dn = MongoCollectionDataNode(              \"foo_bar\",              Scope.SCENARIO,              properties=properties,          )          assert isinstance(mongo_dn, MongoCollectionDataNode)          assert mongo_dn.storage_type() == \"mongo_collection\"          assert mongo_dn.config_id == \"foo_bar\"          assert mongo_dn.scope == Scope.SCENARIO          assert mongo_dn.id is not None          assert mongo_dn.owner_id is None          assert mongo_dn.job_ids == []          assert mongo_dn.is_ready_for_reading          assert mongo_dn.custom_document == MongoDefaultDocument        @pytest.mark.parametrize(\"properties\", __properties)      def test_get_user_properties(self, properties):          custom_properties = properties.copy()          custom_properties[\"foo\"] = \"bar\"          mongo_dn = MongoCollectionDataNode(              \"foo_bar\",              Scope.SCENARIO,              properties=custom_properties,          )          assert mongo_dn._get_user_properties() == {\"foo\": \"bar\"}        @pytest.mark.parametrize(          \"properties\",          [              {},              {\"db_username\": \"foo\"},              {\"db_username\": \"foo\", \"db_password\": \"foo\"},              {\"db_username\": \"foo\", \"db_password\": \"foo\", \"db_name\": \"foo\"},          ],      )      def test_create_with_missing_parameters(self, properties):          with pytest.raises(MissingRequiredProperty):              MongoCollectionDataNode(\"foo\", Scope.SCENARIO, DataNodeId(\"dn_id\"))          with pytest.raises(MissingRequiredProperty):              MongoCollectionDataNode(\"foo\", Scope.SCENARIO, DataNodeId(\"dn_id\"), properties=properties)        @pytest.mark.parametrize(\"properties\", __properties)      def test_raise_error_invalid_custom_document(self, properties):          custom_properties = properties.copy()          custom_properties[\"custom_document\"] = \"foo\"          with pytest.raises(InvalidCustomDocument):              MongoCollectionDataNode(                  \"foo\",                  Scope.SCENARIO,                  properties=custom_properties,              )        @mongomock.patch(servers=((\"localhost\", 27017),))      @pytest.mark.parametrize(\"properties\", __properties)      def test_read(self, properties):          mock_client = pymongo.MongoClient(\"localhost\")          mock_client[properties[\"db_name\"]][properties[\"collection_name\"]].insert_many(              [                  {\"foo\": \"baz\", \"bar\": \"qux\"},                  {\"foo\": \"quux\", \"bar\": \"quuz\"},                  {\"foo\": \"corge\"},                  {\"bar\": \"grault\"},                  {\"KWARGS_KEY\": \"KWARGS_VALUE\"},                  {},              ]          )            mongo_dn = MongoCollectionDataNode(              \"foo\",              Scope.SCENARIO,              properties=properties,          )            data = mongo_dn.read()            assert isinstance(data, list)          assert isinstance(data[0], MongoDefaultDocument)          assert isinstance(data[1], MongoDefaultDocument)          assert isinstance(data[2], MongoDefaultDocument)          assert isinstance(data[3], MongoDefaultDocument)          assert isinstance(data[4], MongoDefaultDocument)          assert isinstance(data[5], MongoDefaultDocument)            assert isinstance(data[0]._id, ObjectId)          assert data[0].foo == \"baz\"          assert data[0].bar == \"qux\"          assert isinstance(data[1]._id, ObjectId)          assert data[1].foo == \"quux\"          assert data[1].bar == \"quuz\"          assert isinstance(data[2]._id, ObjectId)          assert data[2].foo == \"corge\"          assert isinstance(data[3]._id, ObjectId)          assert data[3].bar == \"grault\"          assert isinstance(data[4]._id, ObjectId)          assert data[4].KWARGS_KEY == \"KWARGS_VALUE\"          assert isinstance(data[5]._id, ObjectId)        @mongomock.patch(servers=((\"localhost\", 27017),))      @pytest.mark.parametrize(\"properties\", __properties)      def test_read_empty_as(self, properties):          mongo_dn = MongoCollectionDataNode(              \"foo\",              Scope.SCENARIO,              properties=properties,          )          data = mongo_dn.read()          assert isinstance(data, list)          assert len(data) == 0        @mongomock.patch(servers=((\"localhost\", 27017),))      @pytest.mark.parametrize(\"properties\", __properties)      @pytest.mark.parametrize(          \"data\",          [              ([{\"foo\": 1, \"a\": 2}, {\"foo\": 3, \"bar\": 4}]),              ({\"a\": 1, \"bar\": 2}),          ],      )      def test_read_wrong_object_properties_name(self, properties, data):          custom_properties = properties.copy()          custom_properties[\"custom_document\"] = CustomObjectWithoutArgs          mongo_dn = MongoCollectionDataNode(              \"foo\",              Scope.SCENARIO,              properties=custom_properties,          )          mongo_dn.write(data)            with pytest.raises(TypeError):              data = mongo_dn.read()        @mongomock.patch(servers=((\"localhost\", 27017),))      @pytest.mark.parametrize(\"properties\", __properties)      @pytest.mark.parametrize(          \"data\",          [              ([{\"foo\": 11, \"bar\": 22}, {\"foo\": 33, \"bar\": 44}]),              ({\"foz\": 1, \"baz\": 2}),          ],      )      def test_append(self, properties, data):          mongo_dn = MongoCollectionDataNode(\"foo\", Scope.SCENARIO, properties=properties)          mongo_dn.append(data)            original_data = [{\"foo\": 1, \"bar\": 2}, {\"foo\": 3, \"bar\": 4}]          mongo_dn.write(original_data)            mongo_dn.append(data)          assert len(mongo_dn.read()) == len(data if isinstance(data, list) else [data]) + len(original_data)        @mongomock.patch(servers=((\"localhost\", 27017),))      @pytest.mark.parametrize(\"properties\", __properties)      @pytest.mark.parametrize(          \"data,written_data\",          [              ([{\"foo\": 1, \"bar\": 2}, {\"foo\": 3, \"bar\": 4}], [{\"foo\": 1, \"bar\": 2}, {\"foo\": 3, \"bar\": 4}]),              ({\"foo\": 1, \"bar\": 2}, [{\"foo\": 1, \"bar\": 2}]),          ],      )      def test_write(self, properties, data, written_data):          mongo_dn = MongoCollectionDataNode(\"foo\", Scope.SCENARIO, properties=properties)          mongo_dn.write(data)            read_objects = mongo_dn.read()            for read_object, written_dict in zip(read_objects, written_data):              assert isinstance(read_object._id, ObjectId)              assert read_object.foo == written_dict[\"foo\"]              assert read_object.bar == written_dict[\"bar\"]        @mongomock.patch(servers=((\"localhost\", 27017),))      @pytest.mark.parametrize(\"properties\", __properties)      @pytest.mark.parametrize(          \"data\",          [              [],          ],      )      def test_write_empty_list(self, properties, data):          mongo_dn = MongoCollectionDataNode(              \"foo\",              Scope.SCENARIO,              properties=properties,          )          mongo_dn.write(data)            assert len(mongo_dn.read()) == 0        @mongomock.patch(servers=((\"localhost\", 27017),))      @pytest.mark.parametrize(\"properties\", __properties)      def test_write_non_serializable(self, properties):          mongo_dn = MongoCollectionDataNode(\"foo\", Scope.SCENARIO, properties=properties)          data = {\"a\": 1, \"b\": mongo_dn}          with pytest.raises(InvalidDocument):              mongo_dn.write(data)        @mongomock.patch(servers=((\"localhost\", 27017),))      @pytest.mark.parametrize(\"properties\", __properties)      def test_write_custom_encoder(self, properties):          custom_properties = properties.copy()          custom_properties[\"custom_document\"] = CustomObjectWithCustomEncoder          mongo_dn = MongoCollectionDataNode(\"foo\", Scope.SCENARIO, properties=custom_properties)          data = [              CustomObjectWithCustomEncoder(\"1\", 1, \"abc\", datetime.now()),              CustomObjectWithCustomEncoder(\"2\", 2, \"def\", datetime.now()),          ]          mongo_dn.write(data)            read_data = mongo_dn.read()            assert isinstance(read_data[0], CustomObjectWithCustomEncoder)          assert isinstance(read_data[1], CustomObjectWithCustomEncoder)          assert read_data[0].id == \"1\"          assert read_data[0].integer == 1          assert read_data[0].text == \"abc\"          assert isinstance(read_data[0].time, str)          assert read_data[1].id == \"2\"          assert read_data[1].integer == 2          assert read_data[1].text == \"def\"          assert isinstance(read_data[1].time, str)        @mongomock.patch(servers=((\"localhost\", 27017),))      @pytest.mark.parametrize(\"properties\", __properties)      def test_write_custom_encoder_decoder(self, properties):          custom_properties = properties.copy()          custom_properties[\"custom_document\"] = CustomObjectWithCustomEncoderDecoder          mongo_dn = MongoCollectionDataNode(\"foo\", Scope.SCENARIO, properties=custom_properties)          data = [              CustomObjectWithCustomEncoderDecoder(\"1\", 1, \"abc\", datetime.now()),              CustomObjectWithCustomEncoderDecoder(\"2\", 2, \"def\", datetime.now()),          ]          mongo_dn.write(data)            read_data = mongo_dn.read()            assert isinstance(read_data[0], CustomObjectWithCustomEncoderDecoder)          assert isinstance(read_data[1], CustomObjectWithCustomEncoderDecoder)          assert read_data[0].id == \"1\"          assert read_data[0].integer == 1          assert read_data[0].text == \"abc\"          assert isinstance(read_data[0].time, datetime)          assert read_data[1].id == \"2\"          assert read_data[1].integer == 2          assert read_data[1].text == \"def\"          assert isinstance(read_data[1].time, datetime)        @mongomock.patch(servers=((\"localhost\", 27017),))      @pytest.mark.parametrize(\"properties\", __properties)      def test_filter(self, properties):          mock_client = pymongo.MongoClient(\"localhost\")          mock_client[properties[\"db_name\"]][properties[\"collection_name\"]].insert_many(              [                  {\"foo\": 1, \"bar\": 1},                  {\"foo\": 1, \"bar\": 2},                  {\"foo\": 1},                  {\"foo\": 2, \"bar\": 2},                  {\"bar\": 2},                  {\"KWARGS_KEY\": \"KWARGS_VALUE\"},              ]          )            mongo_dn = MongoCollectionDataNode(              \"foo\",              Scope.SCENARIO,              properties=properties,          )            assert len(mongo_dn.filter((\"foo\", 1, Operator.EQUAL))) == 3          assert len(mongo_dn.filter((\"foo\", 1, Operator.NOT_EQUAL))) == 3          assert len(mongo_dn.filter((\"bar\", 2, Operator.EQUAL))) == 3          assert len(mongo_dn.filter([(\"bar\", 1, Operator.EQUAL), (\"bar\", 2, Operator.EQUAL)], JoinOperator.OR)) == 4            assert mongo_dn[\"foo\"] == [1, 1, 1, 2, None, None]          assert mongo_dn[\"bar\"] == [1, 2, None, 2, 2, None]          assert [m.__dict__ for m in mongo_dn[:3]] == [m.__dict__ for m in mongo_dn.read()[:3]]          assert mongo_dn[[\"foo\", \"bar\"]] == [              {\"foo\": 1, \"bar\": 1},              {\"foo\": 1, \"bar\": 2},              {\"foo\": 1},              {\"foo\": 2, \"bar\": 2},              {\"bar\": 2},              {},          ]        @mongomock.patch(servers=((\"localhost\", 27017),))      @pytest.mark.parametrize(\"properties\", __properties)      def test_filter_does_not_read_all_entities(self, properties):          mongo_dn = MongoCollectionDataNode(\"foo\", Scope.SCENARIO, properties=properties)            # MongoCollectionDataNode.filter() should not call the MongoCollectionDataNode._read() method          with patch.object(MongoCollectionDataNode, \"_read\") as read_mock:              mongo_dn.filter((\"foo\", 1, Operator.EQUAL))              mongo_dn.filter((\"bar\", 2, Operator.NOT_EQUAL))              mongo_dn.filter([(\"bar\", 1, Operator.EQUAL), (\"bar\", 2, Operator.EQUAL)], JoinOperator.OR)                assert read_mock[\"_read\"].call_count == 0 "}
{"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": "import os  import pathlib  from datetime import datetime  from time import sleep  from typing import Dict    import modin.pandas as modin_pd  import numpy as np  import pandas as pd  import pytest  from modin.pandas.test.utils import df_equals  from pandas.testing import assert_frame_equal    from src.taipy.core.data._data_manager import _DataManager  from src.taipy.core.data.data_node_id import DataNodeId  from src.taipy.core.data.excel import ExcelDataNode  from src.taipy.core.data.operator import JoinOperator, Operator  from src.taipy.core.exceptions.exceptions import (      ExposedTypeLengthMismatch,      InvalidExposedType,      NoData,      NonExistingExcelSheet,      SheetNameLengthMismatch,  )  from taipy.config.common.scope import Scope  from taipy.config.config import Config      @pytest.fixture(scope=\"function\", autouse=True)  def cleanup():      yield      path = os.path.join(pathlib.Path(__file__).parent.resolve(), \"data_sample/temp.xlsx\")      if os.path.exists(path):          os.remove(path)      class MyCustomObject:      def __init__(self, id, integer, text):          self.id = id          self.integer = integer          self.text = text      class MyCustomObject1:      def __init__(self, id, integer, text):          self.id = id          self.integer = integer          self.text = text      class MyCustomObject2:      def __init__(self, id, integer, text):          self.id = id          self.integer = integer          self.text = text      class TestExcelDataNode:      def test_new_excel_data_node_with_existing_file_is_ready_for_reading(self):          not_ready_dn_cfg = Config.configure_data_node(\"not_ready_data_node_config_id\", \"excel\", path=\"NOT_EXISTING.csv\")          path = os.path.join(pathlib.Path(__file__).parent.resolve(), \"data_sample/example.xlsx\")          ready_dn_cfg = Config.configure_data_node(\"ready_data_node_config_id\", \"excel\", path=path)            dns = _DataManager._bulk_get_or_create([not_ready_dn_cfg, ready_dn_cfg])            assert not dns[not_ready_dn_cfg].is_ready_for_reading          assert dns[ready_dn_cfg].is_ready_for_reading        def test_create(self):          path = \"data/node/path\"          sheet_names = [\"sheet_name_1\", \"sheet_name_2\"]          dn = ExcelDataNode(              \"foo_bar\",              Scope.SCENARIO,              properties={\"path\": path, \"has_header\": False, \"sheet_name\": sheet_names, \"name\": \"super name\"},          )          assert isinstance(dn, ExcelDataNode)          assert dn.storage_type() == \"excel\"          assert dn.config_id == \"foo_bar\"          assert dn.name == \"super name\"          assert dn.scope == Scope.SCENARIO          assert dn.id is not None          assert dn.owner_id is None          assert dn.parent_ids == set()          assert dn.last_edit_date is None          assert dn.job_ids == []          assert not dn.is_ready_for_reading          assert dn.path == path          assert dn.has_header is False          assert dn.sheet_name == sheet_names        def test_get_user_properties(self, excel_file):          dn_1 = ExcelDataNode(\"dn_1\", Scope.SCENARIO, properties={\"path\": \"data/node/path\"})          assert dn_1._get_user_properties() == {}            dn_2 = ExcelDataNode(              \"dn_2\",              Scope.SCENARIO,              properties={                  \"exposed_type\": \"numpy\",                  \"default_data\": \"foo\",                  \"default_path\": excel_file,                  \"has_header\": False,                  \"sheet_name\": [\"sheet_name_1\", \"sheet_name_2\"],                  \"foo\": \"bar\",              },          )            # exposed_type, default_data, default_path, path, has_header are filtered out          assert dn_2._get_user_properties() == {\"foo\": \"bar\"}        def test_read_with_header(self):          with pytest.raises(NoData):              not_existing_excel = ExcelDataNode(\"foo\", Scope.SCENARIO, properties={\"path\": \"WRONG.xlsx\"})              assert not_existing_excel.read() is None              not_existing_excel.read_or_raise()            empty_excel_path = os.path.join(pathlib.Path(__file__).parent.resolve(), \"data_sample/empty.xlsx\")          empty_excel = ExcelDataNode(              \"foo\",              Scope.SCENARIO,              properties={\"path\": empty_excel_path, \"exposed_type\": MyCustomObject, \"has_header\": True},          )          assert len(empty_excel.read()) == 0            path = os.path.join(pathlib.Path(__file__).parent.resolve(), \"data_sample/example.xlsx\")            # Create ExcelDataNode without exposed_type (Default is pandas.DataFrame)          excel_data_node_as_pandas = ExcelDataNode(              \"bar\", Scope.SCENARIO, properties={\"path\": path, \"sheet_name\": \"Sheet1\"}          )            data_pandas = excel_data_node_as_pandas.read()          assert isinstance(data_pandas, pd.DataFrame)          assert len(data_pandas) == 5          assert np.array_equal(data_pandas.to_numpy(), pd.read_excel(path).to_numpy())            # Create ExcelDataNode with modin exposed_type          excel_data_node_as_modin = ExcelDataNode(              \"bar\", Scope.SCENARIO, properties={\"path\": path, \"sheet_name\": \"Sheet1\", \"exposed_type\": \"modin\"}          )            data_modin = excel_data_node_as_modin.read()          assert isinstance(data_modin, modin_pd.DataFrame)          assert len(data_modin) == 5          assert np.array_equal(data_modin.to_numpy(), pd.read_excel(path).to_numpy())            # Create ExcelDataNode with numpy exposed_type          excel_data_node_as_numpy = ExcelDataNode(              \"bar\", Scope.SCENARIO, properties={\"path\": path, \"exposed_type\": \"numpy\", \"sheet_name\": \"Sheet1\"}          )            data_numpy = excel_data_node_as_numpy.read()          assert isinstance(data_numpy, np.ndarray)          assert len(data_numpy) == 5          assert np.array_equal(data_numpy, pd.read_excel(path).to_numpy())            # Create the same ExcelDataNode but with custom exposed_type          non_existing_sheet_name_custom = ExcelDataNode(              \"bar\",              Scope.SCENARIO,              properties={\"path\": path, \"sheet_name\": \"abc\", \"exposed_type\": MyCustomObject},          )          with pytest.raises(NonExistingExcelSheet):              non_existing_sheet_name_custom.read()            excel_data_node_as_custom_object = ExcelDataNode(              \"bar\",              Scope.SCENARIO,              properties={\"path\": path, \"exposed_type\": MyCustomObject, \"sheet_name\": \"Sheet1\"},          )            data_custom = excel_data_node_as_custom_object.read()          assert isinstance(data_custom, list)          assert len(data_custom) == 5            for (_, row_pandas), row_custom in zip(data_pandas.iterrows(), data_custom):              assert isinstance(row_custom, MyCustomObject)              assert row_pandas[\"id\"] == row_custom.id              assert row_pandas[\"integer\"] == row_custom.integer              assert row_pandas[\"text\"] == row_custom.text        def test_read_without_header(self):          not_existing_excel = ExcelDataNode(              \"foo\", Scope.SCENARIO, properties={\"path\": \"WRONG.xlsx\", \"has_header\": False}          )          with pytest.raises(NoData):              assert not_existing_excel.read() is None              not_existing_excel.read_or_raise()            path = os.path.join(pathlib.Path(__file__).parent.resolve(), \"data_sample/example.xlsx\")            # Create ExcelDataNode without exposed_type (Default is pandas.DataFrame)          excel_data_node_as_pandas = ExcelDataNode(              \"bar\", Scope.SCENARIO, properties={\"path\": path, \"has_header\": False, \"sheet_name\": \"Sheet1\"}          )          data_pandas = excel_data_node_as_pandas.read()          assert isinstance(data_pandas, pd.DataFrame)          assert len(data_pandas) == 6          assert np.array_equal(data_pandas.to_numpy(), pd.read_excel(path, header=None).to_numpy())            # Create ExcelDataNode with modin exposed_type          excel_data_node_as_modin = ExcelDataNode(              \"bar\",              Scope.SCENARIO,              properties={\"path\": path, \"has_header\": False, \"sheet_name\": \"Sheet1\", \"exposed_type\": \"modin\"},          )          data_modin = excel_data_node_as_modin.read()          assert isinstance(data_modin, modin_pd.DataFrame)          assert len(data_modin) == 6          assert np.array_equal(data_modin.to_numpy(), pd.read_excel(path, header=None).to_numpy())            # Create ExcelDataNode with numpy exposed_type          excel_data_node_as_numpy = ExcelDataNode(              \"bar\",              Scope.SCENARIO,              properties={\"path\": path, \"has_header\": False, \"exposed_type\": \"numpy\", \"sheet_name\": \"Sheet1\"},          )            data_numpy = excel_data_node_as_numpy.read()          assert isinstance(data_numpy, np.ndarray)          assert len(data_numpy) == 6          assert np.array_equal(data_numpy, pd.read_excel(path, header=None).to_numpy())            # Create the same ExcelDataNode but with custom exposed_type          non_existing_sheet_name_custom = ExcelDataNode(              \"bar\",              Scope.SCENARIO,              properties={\"path\": path, \"has_header\": False, \"sheet_name\": \"abc\", \"exposed_type\": MyCustomObject},          )          with pytest.raises(NonExistingExcelSheet):              non_existing_sheet_name_custom.read()            excel_data_node_as_custom_object = ExcelDataNode(              \"bar\",              Scope.SCENARIO,              properties={                  \"path\": path,                  \"has_header\": False,                  \"exposed_type\": MyCustomObject,                  \"sheet_name\": \"Sheet1\",              },          )            data_custom = excel_data_node_as_custom_object.read()          assert isinstance(data_custom, list)          assert len(data_custom) == 6            for (_, row_pandas), row_custom in zip(data_pandas.iterrows(), data_custom):              assert isinstance(row_custom, MyCustomObject)              assert row_pandas[0] == row_custom.id              assert row_pandas[1] == row_custom.integer              assert row_pandas[2] == row_custom.text        @pytest.mark.parametrize(          \"content,columns\",          [              ([{\"a\": 11, \"b\": 22, \"c\": 33}, {\"a\": 44, \"b\": 55, \"c\": 66}], None),              ([[11, 22, 33], [44, 55, 66]], None),              ([[11, 22, 33], [44, 55, 66]], [\"e\", \"f\", \"g\"]),          ],      )      def test_write(self, excel_file, default_data_frame, content, columns):          excel_dn = ExcelDataNode(\"foo\", Scope.SCENARIO, properties={\"path\": excel_file, \"sheet_name\": \"Sheet1\"})          assert np.array_equal(excel_dn.read().values, default_data_frame.values)          if not columns:              excel_dn.write(content)              df = pd.DataFrame(content)          else:              excel_dn.write_with_column_names(content, columns)              df = pd.DataFrame(content, columns=columns)            assert np.array_equal(excel_dn.read().values, df.values)            excel_dn.write(None)          assert len(excel_dn.read()) == 0        @pytest.mark.parametrize(          \"content,sheet_name\",          [              ([{\"a\": 11, \"b\": 22, \"c\": 33}, {\"a\": 44, \"b\": 55, \"c\": 66}], \"sheet_name\"),              ([[11, 22, 33], [44, 55, 66]], [\"sheet_name\"]),          ],      )      def test_write_with_sheet_name(self, excel_file_with_sheet_name, default_data_frame, content, sheet_name):          excel_dn = ExcelDataNode(              \"foo\", Scope.SCENARIO, properties={\"path\": excel_file_with_sheet_name, \"sheet_name\": sheet_name}          )          df = pd.DataFrame(content)            if isinstance(sheet_name, str):              assert np.array_equal(excel_dn.read().values, default_data_frame.values)          else:              assert np.array_equal(excel_dn.read()[\"sheet_name\"].values, default_data_frame.values)            excel_dn.write(content)          if isinstance(sheet_name, str):              assert np.array_equal(excel_dn.read().values, df.values)          else:              assert np.array_equal(excel_dn.read()[\"sheet_name\"].values, df.values)            sheet_names = pd.ExcelFile(excel_file_with_sheet_name).sheet_names          expected_sheet_name = sheet_name[0] if isinstance(sheet_name, list) else sheet_name            assert sheet_names[0] == expected_sheet_name            excel_dn.write(None)          if isinstance(sheet_name, str):              assert len(excel_dn.read()) == 0          else:              assert len(excel_dn.read()) == 1        @pytest.mark.parametrize(          \"content,sheet_name\",          [              ([[11, 22, 33], [44, 55, 66]], [\"sheet_name_1\", \"sheet_name_2\"]),          ],      )      def test_raise_write_with_sheet_name_length_mismatch(          self, excel_file_with_sheet_name, default_data_frame, content, sheet_name      ):          excel_dn = ExcelDataNode(              \"foo\", Scope.SCENARIO, properties={\"path\": excel_file_with_sheet_name, \"sheet_name\": sheet_name}          )          with pytest.raises(SheetNameLengthMismatch):              excel_dn.write(content)        @pytest.mark.parametrize(          \"content\",          [              ([{\"a\": 11, \"b\": 22, \"c\": 33}, {\"a\": 44, \"b\": 55, \"c\": 66}]),          ],      )      def test_write_without_sheet_name(self, excel_file_with_sheet_name, default_data_frame, content):          excel_dn = ExcelDataNode(\"foo\", Scope.SCENARIO, properties={\"path\": excel_file_with_sheet_name})          default_data_frame = {\"sheet_name\": default_data_frame}          df = {\"Sheet1\": pd.DataFrame(content)}            assert np.array_equal(excel_dn.read()[\"sheet_name\"].values, default_data_frame[\"sheet_name\"].values)            excel_dn.write(content)          assert np.array_equal(excel_dn.read()[\"Sheet1\"].values, df[\"Sheet1\"].values)            sheet_names = pd.ExcelFile(excel_file_with_sheet_name).sheet_names          expected_sheet_name = \"Sheet1\"            assert sheet_names[0] == expected_sheet_name            excel_dn.write(None)          assert len(excel_dn.read()) == 1        @pytest.mark.parametrize(          \"content,columns,sheet_name\",          [              ([[11, 22, 33], [44, 55, 66]], [\"e\", \"f\", \"g\"], \"sheet_name\"),              ([[11, 22, 33], [44, 55, 66]], [\"e\", \"f\", \"g\"], [\"sheet_name\"]),          ],      )      def test_write_with_column_and_sheet_name(          self, excel_file_with_sheet_name, default_data_frame, content, columns, sheet_name      ):          excel_dn = ExcelDataNode(              \"foo\", Scope.SCENARIO, properties={\"path\": excel_file_with_sheet_name, \"sheet_name\": sheet_name}          )          df = pd.DataFrame(content)            if isinstance(sheet_name, str):              assert np.array_equal(excel_dn.read().values, default_data_frame.values)          else:              assert np.array_equal(excel_dn.read()[\"sheet_name\"].values, default_data_frame.values)            excel_dn.write_with_column_names(content, columns)            if isinstance(sheet_name, str):              assert np.array_equal(excel_dn.read().values, df.values)          else:              assert np.array_equal(excel_dn.read()[\"sheet_name\"].values, df.values)            sheet_names = pd.ExcelFile(excel_file_with_sheet_name).sheet_names          expected_sheet_name = sheet_name[0] if isinstance(sheet_name, list) else sheet_name            assert sheet_names[0] == expected_sheet_name            excel_dn.write(None)          if isinstance(sheet_name, str):              assert len(excel_dn.read()) == 0          else:              assert len(excel_dn.read()) == 1        @pytest.mark.parametrize(          \"content,columns\",          [              ([{\"a\": 11, \"b\": 22, \"c\": 33}, {\"a\": 44, \"b\": 55, \"c\": 66}], None),              ([[11, 22, 33], [44, 55, 66]], None),              ([[11, 22, 33], [44, 55, 66]], [\"e\", \"f\", \"g\"]),          ],      )      def test_write_modin(self, excel_file, default_data_frame, content, columns):          excel_dn = ExcelDataNode(              \"foo\", Scope.SCENARIO, properties={\"path\": excel_file, \"sheet_name\": \"Sheet1\", \"exposed_type\": \"modin\"}          )          assert np.array_equal(excel_dn.read().values, default_data_frame.values)          if not columns:              excel_dn.write(content)              df = modin_pd.DataFrame(content)          else:              excel_dn.write_with_column_names(content, columns)              df = modin_pd.DataFrame(content, columns=columns)            assert np.array_equal(excel_dn.read().values, df.values)            excel_dn.write(None)          assert len(excel_dn.read()) == 0        def test_read_multi_sheet_with_header(self):          not_existing_excel = ExcelDataNode(              \"foo\",              Scope.SCENARIO,              properties={\"path\": \"WRONG.xlsx\", \"sheet_name\": [\"sheet_name_1\", \"sheet_name_2\"]},          )          with pytest.raises(NoData):              assert not_existing_excel.read() is None              not_existing_excel.read_or_raise()            path = os.path.join(pathlib.Path(__file__).parent.resolve(), \"data_sample/example.xlsx\")          sheet_names = [\"Sheet1\", \"Sheet2\"]            # Create ExcelDataNode without exposed_type (Default is pandas.DataFrame)          excel_data_node_as_pandas = ExcelDataNode(              \"bar\", Scope.SCENARIO, properties={\"path\": path, \"sheet_name\": sheet_names}          )            data_pandas = excel_data_node_as_pandas.read()          assert isinstance(data_pandas, Dict)          assert len(data_pandas) == 2          assert all(              len(data_pandas[sheet_name] == 5) and isinstance(data_pandas[sheet_name], pd.DataFrame)              for sheet_name in sheet_names          )          assert list(data_pandas.keys()) == sheet_names          for sheet_name in sheet_names:              assert data_pandas[sheet_name].equals(pd.read_excel(path, sheet_name=sheet_name))            excel_data_node_as_pandas_no_sheet_name = ExcelDataNode(\"bar\", Scope.SCENARIO, properties={\"path\": path})            data_pandas_no_sheet_name = excel_data_node_as_pandas_no_sheet_name.read()          assert isinstance(data_pandas_no_sheet_name, Dict)          for key in data_pandas_no_sheet_name.keys():              assert isinstance(data_pandas_no_sheet_name[key], pd.DataFrame)              assert data_pandas[key].equals(data_pandas_no_sheet_name[key])            # Create ExcelDataNode with modin exposed_type          excel_data_node_as_modin = ExcelDataNode(              \"bar\", Scope.SCENARIO, properties={\"path\": path, \"sheet_name\": sheet_names, \"exposed_type\": \"modin\"}          )            data_modin = excel_data_node_as_modin.read()          assert isinstance(data_modin, Dict)          assert len(data_modin) == 2          assert all(              len(data_modin[sheet_name] == 5) and isinstance(data_modin[sheet_name], modin_pd.DataFrame)              for sheet_name in sheet_names          )          assert list(data_modin.keys()) == sheet_names          for sheet_name in sheet_names:              assert data_modin[sheet_name].equals(modin_pd.read_excel(path, sheet_name=sheet_name))            excel_data_node_as_pandas_no_sheet_name = ExcelDataNode(              \"bar\", Scope.SCENARIO, properties={\"path\": path, \"exposed_type\": \"modin\"}          )            data_modin_no_sheet_name = excel_data_node_as_pandas_no_sheet_name.read()          assert isinstance(data_modin_no_sheet_name, Dict)          for key in data_modin_no_sheet_name.keys():              assert isinstance(data_modin_no_sheet_name[key], modin_pd.DataFrame)              assert data_modin[key].equals(data_modin_no_sheet_name[key])            # Create ExcelDataNode with numpy exposed_type          excel_data_node_as_numpy = ExcelDataNode(              \"bar\",              Scope.SCENARIO,              properties={\"path\": path, \"sheet_name\": sheet_names, \"exposed_type\": \"numpy\"},          )            data_numpy = excel_data_node_as_numpy.read()          assert isinstance(data_numpy, Dict)          assert len(data_numpy) == 2          assert all(              len(data_numpy[sheet_name] == 5) and isinstance(data_numpy[sheet_name], np.ndarray)              for sheet_name in sheet_names          )          assert list(data_numpy.keys()) == sheet_names          for sheet_name in sheet_names:              assert np.array_equal(data_pandas[sheet_name], pd.read_excel(path, sheet_name=sheet_name).to_numpy())            excel_data_node_as_numpy_no_sheet_name = ExcelDataNode(              \"bar\",              Scope.SCENARIO,              properties={\"path\": path, \"exposed_type\": \"numpy\"},          )            data_numpy_no_sheet_name = excel_data_node_as_numpy_no_sheet_name.read()          assert isinstance(data_numpy_no_sheet_name, Dict)          for key in data_numpy_no_sheet_name.keys():              assert isinstance(data_numpy_no_sheet_name[key], np.ndarray)              assert np.array_equal(data_numpy[key], data_numpy_no_sheet_name[key])            # Create the same ExcelDataNode but with custom exposed_type          non_existing_sheet_name_custom = ExcelDataNode(              \"bar\",              Scope.SCENARIO,              properties={                  \"path\": path,                  \"sheet_name\": [\"Sheet1\", \"xyz\"],                  \"exposed_type\": MyCustomObject1,              },          )          with pytest.raises(NonExistingExcelSheet):              non_existing_sheet_name_custom.read()            excel_data_node_as_custom_object = ExcelDataNode(              \"bar\",              Scope.SCENARIO,              properties={\"path\": path, \"sheet_name\": sheet_names, \"exposed_type\": MyCustomObject1},          )            data_custom = excel_data_node_as_custom_object.read()          assert isinstance(data_custom, Dict)          assert len(data_custom) == 2          assert all(len(data_custom[sheet_name]) == 5 for sheet_name in sheet_names)          assert list(data_custom.keys()) == sheet_names            for sheet_name in sheet_names:              sheet_data_pandas, sheet_data_custom = data_pandas[sheet_name], data_custom[sheet_name]              for (_, row_pandas), row_custom in zip(sheet_data_pandas.iterrows(), sheet_data_custom):                  assert isinstance(row_custom, MyCustomObject1)                  assert row_pandas[\"id\"] == row_custom.id                  assert row_pandas[\"integer\"] == row_custom.integer                  assert row_pandas[\"text\"] == row_custom.text            excel_data_node_as_custom_object_no_sheet_name = ExcelDataNode(              \"bar\",              Scope.SCENARIO,              properties={\"path\": path, \"exposed_type\": MyCustomObject1},          )            data_custom_no_sheet_name = excel_data_node_as_custom_object_no_sheet_name.read()          assert isinstance(data_custom_no_sheet_name, Dict)          assert len(data_custom_no_sheet_name) == 2          assert data_custom.keys() == data_custom_no_sheet_name.keys()            for sheet_name in sheet_names:              sheet_data_custom_no_sheet_name, sheet_data_custom = (                  data_custom_no_sheet_name[sheet_name],                  data_custom[sheet_name],              )              for row_custom_no_sheet_name, row_custom in zip(sheet_data_custom_no_sheet_name, sheet_data_custom):                  assert isinstance(row_custom_no_sheet_name, MyCustomObject1)                  assert row_custom_no_sheet_name.id == row_custom.id                  assert row_custom_no_sheet_name.integer == row_custom.integer                  assert row_custom_no_sheet_name.text == row_custom.text            with pytest.raises(ExposedTypeLengthMismatch):              dn = ExcelDataNode(                  \"bar\",                  Scope.SCENARIO,                  properties={                      \"path\": path,                      \"sheet_name\": [\"Sheet1\"],                      \"exposed_type\": [MyCustomObject1, MyCustomObject2],                  },              )              dn.read()            custom_class_dict = {\"Sheet1\": MyCustomObject1, \"Sheet2\": MyCustomObject2}            excel_data_node_as_multi_custom_object = ExcelDataNode(              \"bar\",              Scope.SCENARIO,              properties={\"path\": path, \"sheet_name\": sheet_names, \"exposed_type\": custom_class_dict},          )          assert excel_data_node_as_multi_custom_object.properties[\"exposed_type\"] == custom_class_dict            excel_data_node_as_multi_custom_object = ExcelDataNode(              \"bar\",              Scope.SCENARIO,              properties={\"path\": path, \"sheet_name\": sheet_names, \"exposed_type\": [MyCustomObject1, MyCustomObject2]},          )          assert excel_data_node_as_multi_custom_object.properties[\"exposed_type\"] == [MyCustomObject1, MyCustomObject2]            multi_data_custom = excel_data_node_as_multi_custom_object.read()          assert isinstance(multi_data_custom, Dict)          assert len(multi_data_custom) == 2          assert all(len(multi_data_custom[sheet_name]) == 5 for sheet_name in sheet_names)          assert list(multi_data_custom.keys()) == sheet_names            for sheet_name, custom_class in custom_class_dict.items():              sheet_data_pandas, sheet_data_custom = data_pandas[sheet_name], multi_data_custom[sheet_name]              for (_, row_pandas), row_custom in zip(sheet_data_pandas.iterrows(), sheet_data_custom):                  assert isinstance(row_custom, custom_class)                  assert row_pandas[\"id\"] == row_custom.id                  assert row_pandas[\"integer\"] == row_custom.integer                  assert row_pandas[\"text\"] == row_custom.text            excel_data_node_as_multi_custom_object_no_sheet_name = ExcelDataNode(              \"bar\",              Scope.SCENARIO,              properties={\"path\": path, \"exposed_type\": custom_class_dict},          )          assert excel_data_node_as_multi_custom_object_no_sheet_name.properties[\"exposed_type\"] == custom_class_dict            multi_data_custom_no_sheet_name = excel_data_node_as_multi_custom_object_no_sheet_name.read()          assert isinstance(multi_data_custom_no_sheet_name, Dict)          assert len(multi_data_custom_no_sheet_name) == 2          assert multi_data_custom.keys() == multi_data_custom_no_sheet_name.keys()            for sheet_name, custom_class in custom_class_dict.items():              sheet_data_custom_no_sheet_name, sheet_data_custom = (                  multi_data_custom_no_sheet_name[sheet_name],                  multi_data_custom[sheet_name],              )              for row_custom_no_sheet_name, row_custom in zip(sheet_data_custom_no_sheet_name, sheet_data_custom):                  assert isinstance(row_custom_no_sheet_name, custom_class)                  assert row_custom_no_sheet_name.id == row_custom.id                  assert row_custom_no_sheet_name.integer == row_custom.integer                  assert row_custom_no_sheet_name.text == row_custom.text        def test_read_multi_sheet_without_header(self):          not_existing_excel = ExcelDataNode(              \"foo\",              Scope.SCENARIO,              properties={\"path\": \"WRONG.xlsx\", \"has_header\": False, \"sheet_name\": [\"sheet_name_1\", \"sheet_name_2\"]},          )          with pytest.raises(NoData):              assert not_existing_excel.read() is None              not_existing_excel.read_or_raise()            path = os.path.join(pathlib.Path(__file__).parent.resolve(), \"data_sample/example.xlsx\")          sheet_names = [\"Sheet1\", \"Sheet2\"]            # Create ExcelDataNode without exposed_type (Default is pandas.DataFrame)          excel_data_node_as_pandas = ExcelDataNode(              \"bar\", Scope.SCENARIO, properties={\"path\": path, \"has_header\": False, \"sheet_name\": sheet_names}          )          data_pandas = excel_data_node_as_pandas.read()          assert isinstance(data_pandas, Dict)          assert len(data_pandas) == 2          assert all(len(data_pandas[sheet_name]) == 6 for sheet_name in sheet_names)          assert list(data_pandas.keys()) == sheet_names          for sheet_name in sheet_names:              assert isinstance(data_pandas[sheet_name], pd.DataFrame)              assert data_pandas[sheet_name].equals(pd.read_excel(path, header=None, sheet_name=sheet_name))            excel_data_node_as_pandas_no_sheet_name = ExcelDataNode(              \"bar\", Scope.SCENARIO, properties={\"path\": path, \"has_header\": False}          )          data_pandas_no_sheet_name = excel_data_node_as_pandas_no_sheet_name.read()          assert isinstance(data_pandas_no_sheet_name, Dict)          for key in data_pandas_no_sheet_name.keys():              assert isinstance(data_pandas_no_sheet_name[key], pd.DataFrame)              assert data_pandas[key].equals(data_pandas_no_sheet_name[key])            # Create ExcelDataNode with modin exposed_type          excel_data_node_as_modin = ExcelDataNode(              \"bar\",              Scope.SCENARIO,              properties={\"path\": path, \"has_header\": False, \"sheet_name\": sheet_names, \"exposed_type\": \"modin\"},          )          data_modin = excel_data_node_as_modin.read()          assert isinstance(data_modin, Dict)          assert len(data_modin) == 2          assert all(len(data_modin[sheet_name]) == 6 for sheet_name in sheet_names)          assert list(data_modin.keys()) == sheet_names          for sheet_name in sheet_names:              assert isinstance(data_modin[sheet_name], modin_pd.DataFrame)              assert data_modin[sheet_name].equals(pd.read_excel(path, header=None, sheet_name=sheet_name))            excel_data_node_as_modin_no_sheet_name = ExcelDataNode(              \"bar\", Scope.SCENARIO, properties={\"path\": path, \"has_header\": False, \"exposed_type\": \"modin\"}          )          data_modin_no_sheet_name = excel_data_node_as_modin_no_sheet_name.read()          assert isinstance(data_modin_no_sheet_name, Dict)          for key in data_modin_no_sheet_name.keys():              assert isinstance(data_modin_no_sheet_name[key], modin_pd.DataFrame)              assert data_modin[key].equals(data_modin_no_sheet_name[key])            # Create ExcelDataNode with numpy exposed_type          excel_data_node_as_numpy = ExcelDataNode(              \"bar\",              Scope.SCENARIO,              properties={\"path\": path, \"has_header\": False, \"sheet_name\": sheet_names, \"exposed_type\": \"numpy\"},          )            data_numpy = excel_data_node_as_numpy.read()          assert isinstance(data_numpy, Dict)          assert len(data_numpy) == 2          assert all(              len(data_numpy[sheet_name] == 6) and isinstance(data_numpy[sheet_name], np.ndarray)              for sheet_name in sheet_names          )          assert list(data_numpy.keys()) == sheet_names          for sheet_name in sheet_names:              assert np.array_equal(                  data_pandas[sheet_name], pd.read_excel(path, header=None, sheet_name=sheet_name).to_numpy()              )            excel_data_node_as_numpy_no_sheet_name = ExcelDataNode(              \"bar\",              Scope.SCENARIO,              properties={\"path\": path, \"has_header\": False, \"exposed_type\": \"numpy\"},          )            data_numpy_no_sheet_name = excel_data_node_as_numpy_no_sheet_name.read()          assert isinstance(data_numpy_no_sheet_name, Dict)          for key in data_numpy_no_sheet_name.keys():              assert isinstance(data_numpy_no_sheet_name[key], np.ndarray)              assert np.array_equal(data_numpy[key], data_numpy_no_sheet_name[key])            # Create the same ExcelDataNode but with custom exposed_type          non_existing_sheet_name_custom = ExcelDataNode(              \"bar\",              Scope.SCENARIO,              properties={                  \"path\": path,                  \"has_header\": False,                  \"sheet_name\": [\"Sheet1\", \"xyz\"],                  \"exposed_type\": MyCustomObject1,              },          )          with pytest.raises(NonExistingExcelSheet):              non_existing_sheet_name_custom.read()            excel_data_node_as_custom_object = ExcelDataNode(              \"bar\",              Scope.SCENARIO,              properties={                  \"path\": path,                  \"has_header\": False,                  \"sheet_name\": sheet_names,                  \"exposed_type\": MyCustomObject1,              },          )            data_custom = excel_data_node_as_custom_object.read()          assert excel_data_node_as_custom_object.exposed_type == MyCustomObject1          assert isinstance(data_custom, Dict)          assert len(data_custom) == 2          assert all(len(data_custom[sheet_name]) == 6 for sheet_name in sheet_names)          assert list(data_custom.keys()) == sheet_names            for sheet_name in sheet_names:              sheet_data_pandas, sheet_data_custom = data_pandas[sheet_name], data_custom[sheet_name]              for (_, row_pandas), row_custom in zip(sheet_data_pandas.iterrows(), sheet_data_custom):                  assert isinstance(row_custom, MyCustomObject1)                  assert row_pandas[0] == row_custom.id                  assert row_pandas[1] == row_custom.integer                  assert row_pandas[2] == row_custom.text            excel_data_node_as_custom_object_no_sheet_name = ExcelDataNode(              \"bar\",              Scope.SCENARIO,              properties={\"path\": path, \"has_header\": False, \"exposed_type\": MyCustomObject1},          )            data_custom_no_sheet_name = excel_data_node_as_custom_object_no_sheet_name.read()          assert isinstance(data_custom_no_sheet_name, Dict)          assert len(data_custom_no_sheet_name) == 2          assert data_custom.keys() == data_custom_no_sheet_name.keys()            for sheet_name in sheet_names:              sheet_data_custom_no_sheet_name, sheet_data_custom = (                  data_custom_no_sheet_name[sheet_name],                  data_custom[sheet_name],              )              for row_custom_no_sheet_name, row_custom in zip(sheet_data_custom_no_sheet_name, sheet_data_custom):                  assert isinstance(row_custom_no_sheet_name, MyCustomObject1)                  assert row_custom_no_sheet_name.id == row_custom.id                  assert row_custom_no_sheet_name.integer == row_custom.integer                  assert row_custom_no_sheet_name.text == row_custom.text            with pytest.raises(ExposedTypeLengthMismatch):              dn = ExcelDataNode(                  \"bar\",                  Scope.SCENARIO,                  properties={                      \"path\": path,                      \"sheet_name\": [\"Sheet1\"],                      \"exposed_type\": [MyCustomObject1, MyCustomObject2],                      \"has_header\": False,                  },              )              dn.read()            custom_class_dict = {\"Sheet1\": MyCustomObject1, \"Sheet2\": MyCustomObject2}            excel_data_node_as_multi_custom_object = ExcelDataNode(              \"bar\",              Scope.SCENARIO,              properties={                  \"path\": path,                  \"sheet_name\": sheet_names,                  \"exposed_type\": custom_class_dict,                  \"has_header\": False,              },          )          assert excel_data_node_as_multi_custom_object.properties[\"exposed_type\"] == custom_class_dict            excel_data_node_as_multi_custom_object = ExcelDataNode(              \"bar\",              Scope.SCENARIO,              properties={                  \"path\": path,                  \"sheet_name\": sheet_names,                  \"exposed_type\": [MyCustomObject1, MyCustomObject2],                  \"has_header\": False,              },          )          assert excel_data_node_as_multi_custom_object.properties[\"exposed_type\"] == [MyCustomObject1, MyCustomObject2]            multi_data_custom = excel_data_node_as_multi_custom_object.read()          assert isinstance(multi_data_custom, Dict)          assert len(multi_data_custom) == 2          assert all(len(multi_data_custom[sheet_name]) == 6 for sheet_name in sheet_names)          assert list(multi_data_custom.keys()) == sheet_names            for sheet_name, custom_class in custom_class_dict.items():              sheet_data_pandas, sheet_data_custom = data_pandas[sheet_name], multi_data_custom[sheet_name]              for (_, row_pandas), row_custom in zip(sheet_data_pandas.iterrows(), sheet_data_custom):                  assert isinstance(row_custom, custom_class)                  assert row_pandas[0] == row_custom.id                  assert row_pandas[1] == row_custom.integer                  assert row_pandas[2] == row_custom.text            excel_data_node_as_multi_custom_object_no_sheet_name = ExcelDataNode(              \"bar\",              Scope.SCENARIO,              properties={\"path\": path, \"has_header\": False, \"exposed_type\": custom_class_dict},          )            multi_data_custom_no_sheet_name = excel_data_node_as_multi_custom_object_no_sheet_name.read()          assert isinstance(multi_data_custom_no_sheet_name, Dict)          assert len(multi_data_custom_no_sheet_name) == 2          assert multi_data_custom.keys() == multi_data_custom_no_sheet_name.keys()            for sheet_name, custom_class in custom_class_dict.items():              sheet_data_custom_no_sheet_name, sheet_data_custom = (                  multi_data_custom_no_sheet_name[sheet_name],                  multi_data_custom[sheet_name],              )              for row_custom_no_sheet_name, row_custom in zip(sheet_data_custom_no_sheet_name, sheet_data_custom):                  assert isinstance(row_custom_no_sheet_name, custom_class)                  assert row_custom_no_sheet_name.id == row_custom.id                  assert row_custom_no_sheet_name.integer == row_custom.integer                  assert row_custom_no_sheet_name.text == row_custom.text        @pytest.mark.parametrize(          \"content,columns\",          [              ([{\"a\": 11, \"b\": 22, \"c\": 33}, {\"a\": 44, \"b\": 55, \"c\": 66}], None),              ([[11, 22, 33], [44, 55, 66]], None),              ([[11, 22, 33], [44, 55, 66]], [\"e\", \"f\", \"g\"]),          ],      )      def test_write_multi_sheet(self, excel_file_with_multi_sheet, default_multi_sheet_data_frame, content, columns):          sheet_names = [\"Sheet1\", \"Sheet2\"]            excel_dn = ExcelDataNode(              \"foo\",              Scope.SCENARIO,              properties={\"path\": excel_file_with_multi_sheet, \"sheet_name\": sheet_names},          )            for sheet_name in sheet_names:              assert np.array_equal(excel_dn.read()[sheet_name].values, default_multi_sheet_data_frame[sheet_name].values)            multi_sheet_content = {sheet_name: pd.DataFrame(content) for sheet_name in sheet_names}            excel_dn.write(multi_sheet_content)            for sheet_name in sheet_names:              assert np.array_equal(excel_dn.read()[sheet_name].values, multi_sheet_content[sheet_name].values)        def test_write_multi_sheet_numpy(self, excel_file_with_multi_sheet):          sheet_names = [\"Sheet1\", \"Sheet2\"]            excel_dn = ExcelDataNode(              \"foo\",              Scope.SCENARIO,              properties={\"path\": excel_file_with_multi_sheet, \"sheet_name\": sheet_names, \"exposed_type\": \"numpy\"},          )            sheets_data = [[11, 22, 33], [44, 55, 66]]          data = {              sheet_name: pd.DataFrame(sheet_data).to_numpy() for sheet_name, sheet_data in zip(sheet_names, sheets_data)          }          excel_dn.write(data)          read_data = excel_dn.read()          assert all(np.array_equal(data[sheet_name], read_data[sheet_name]) for sheet_name in sheet_names)        @pytest.mark.parametrize(          \"content,columns\",          [              ([{\"a\": 11, \"b\": 22, \"c\": 33}, {\"a\": 44, \"b\": 55, \"c\": 66}], None),              ([[11, 22, 33], [44, 55, 66]], None),              ([[11, 22, 33], [44, 55, 66]], [\"e\", \"f\", \"g\"]),          ],      )      def test_write_multi_sheet_with_modin(          self, excel_file_with_multi_sheet, default_multi_sheet_data_frame, content, columns      ):          sheet_names = [\"Sheet1\", \"Sheet2\"]            excel_dn = ExcelDataNode(              \"foo\",              Scope.SCENARIO,              properties={\"path\": excel_file_with_multi_sheet, \"sheet_name\": sheet_names, \"exposed_type\": \"modin\"},          )            for sheet_name in sheet_names:              assert np.array_equal(excel_dn.read()[sheet_name].values, default_multi_sheet_data_frame[sheet_name].values)            multi_sheet_content = {sheet_name: modin_pd.DataFrame(content) for sheet_name in sheet_names}            excel_dn.write(multi_sheet_content)            for sheet_name in sheet_names:              assert np.array_equal(excel_dn.read()[sheet_name].values, multi_sheet_content[sheet_name].values)        @pytest.mark.parametrize(          \"content\",          [              ([{\"a\": 11, \"b\": 22, \"c\": 33}, {\"a\": 44, \"b\": 55, \"c\": 66}]),              (pd.DataFrame([{\"a\": 11, \"b\": 22, \"c\": 33}, {\"a\": 44, \"b\": 55, \"c\": 66}])),              ([[11, 22, 33], [44, 55, 66]]),          ],      )      def test_append_pandas_with_sheetname(self, excel_file, default_data_frame, content):          dn = ExcelDataNode(\"foo\", Scope.SCENARIO, properties={\"path\": excel_file, \"sheet_name\": \"Sheet1\"})          assert_frame_equal(dn.read(), default_data_frame)            dn.append(content)          assert_frame_equal(              dn.read(),              pd.concat([default_data_frame, pd.DataFrame(content, columns=[\"a\", \"b\", \"c\"])]).reset_index(drop=True),          )        @pytest.mark.parametrize(          \"content\",          [              ([{\"a\": 11, \"b\": 22, \"c\": 33}, {\"a\": 44, \"b\": 55, \"c\": 66}]),              (pd.DataFrame([{\"a\": 11, \"b\": 22, \"c\": 33}, {\"a\": 44, \"b\": 55, \"c\": 66}])),              ([[11, 22, 33], [44, 55, 66]]),          ],      )      def test_append_pandas_without_sheetname(self, excel_file, default_data_frame, content):          dn = ExcelDataNode(\"foo\", Scope.SCENARIO, properties={\"path\": excel_file})          assert_frame_equal(dn.read()[\"Sheet1\"], default_data_frame)            dn.append(content)          assert_frame_equal(              dn.read()[\"Sheet1\"],              pd.concat([default_data_frame, pd.DataFrame(content, columns=[\"a\", \"b\", \"c\"])]).reset_index(drop=True),          )        @pytest.mark.parametrize(          \"content\",          [              (                  {                      \"Sheet1\": pd.DataFrame([{\"a\": 11, \"b\": 22, \"c\": 33}]),                      \"Sheet2\": pd.DataFrame([{\"a\": 44, \"b\": 55, \"c\": 66}]),                  }              ),              (                  {                      \"Sheet1\": pd.DataFrame({\"a\": [11, 44], \"b\": [22, 55], \"c\": [33, 66]}),                      \"Sheet2\": pd.DataFrame([{\"a\": 77, \"b\": 88, \"c\": 99}]),                  }              ),              ({\"Sheet1\": np.array([[11, 22, 33], [44, 55, 66]]), \"Sheet2\": np.array([[77, 88, 99]])}),          ],      )      def test_append_pandas_multisheet(self, excel_file_with_multi_sheet, default_multi_sheet_data_frame, content):          dn = ExcelDataNode(              \"foo\", Scope.SCENARIO, properties={\"path\": excel_file_with_multi_sheet, \"sheet_name\": [\"Sheet1\", \"Sheet2\"]}          )          assert_frame_equal(dn.read()[\"Sheet1\"], default_multi_sheet_data_frame[\"Sheet1\"])          assert_frame_equal(dn.read()[\"Sheet2\"], default_multi_sheet_data_frame[\"Sheet2\"])            dn.append(content)            assert_frame_equal(              dn.read()[\"Sheet1\"],              pd.concat(                  [default_multi_sheet_data_frame[\"Sheet1\"], pd.DataFrame(content[\"Sheet1\"], columns=[\"a\", \"b\", \"c\"])]              ).reset_index(drop=True),          )          assert_frame_equal(              dn.read()[\"Sheet2\"],              pd.concat(                  [default_multi_sheet_data_frame[\"Sheet2\"], pd.DataFrame(content[\"Sheet2\"], columns=[\"a\", \"b\", \"c\"])]              ).reset_index(drop=True),          )        @pytest.mark.parametrize(          \"content\",          [              ({\"Sheet1\": pd.DataFrame([{\"a\": 11, \"b\": 22, \"c\": 33}])}),              (pd.DataFrame({\"a\": [11, 44], \"b\": [22, 55], \"c\": [33, 66]})),              ([[11, 22, 33], [44, 55, 66]]),          ],      )      def test_append_only_first_sheet_of_a_multisheet_file(          self, excel_file_with_multi_sheet, default_multi_sheet_data_frame, content      ):          dn = ExcelDataNode(              \"foo\", Scope.SCENARIO, properties={\"path\": excel_file_with_multi_sheet, \"sheet_name\": [\"Sheet1\", \"Sheet2\"]}          )          assert_frame_equal(dn.read()[\"Sheet1\"], default_multi_sheet_data_frame[\"Sheet1\"])          assert_frame_equal(dn.read()[\"Sheet2\"], default_multi_sheet_data_frame[\"Sheet2\"])            dn.append(content)            appended_content = content[\"Sheet1\"] if isinstance(content, dict) else content          assert_frame_equal(              dn.read()[\"Sheet1\"],              pd.concat(                  [default_multi_sheet_data_frame[\"Sheet1\"], pd.DataFrame(appended_content, columns=[\"a\", \"b\", \"c\"])]              ).reset_index(drop=True),          )          assert_frame_equal(dn.read()[\"Sheet2\"], default_multi_sheet_data_frame[\"Sheet2\"])        @pytest.mark.parametrize(          \"content\",          [              ([{\"a\": 11, \"b\": 22, \"c\": 33}, {\"a\": 44, \"b\": 55, \"c\": 66}]),              (modin_pd.DataFrame([{\"a\": 11, \"b\": 22, \"c\": 33}, {\"a\": 44, \"b\": 55, \"c\": 66}])),              ([[11, 22, 33], [44, 55, 66]]),          ],      )      def test_append_modin_with_sheetname(self, excel_file, default_data_frame, content):          dn = ExcelDataNode(              \"foo\", Scope.SCENARIO, properties={\"path\": excel_file, \"sheet_name\": \"Sheet1\", \"exposed_type\": \"modin\"}          )          df_equals(dn.read(), modin_pd.DataFrame(default_data_frame))            dn.append(content)          df_equals(              dn.read(),              modin_pd.concat(                  [modin_pd.DataFrame(default_data_frame), modin_pd.DataFrame(content, columns=[\"a\", \"b\", \"c\"])]              ).reset_index(drop=True),          )        @pytest.mark.parametrize(          \"content\",          [              ([{\"a\": 11, \"b\": 22, \"c\": 33}, {\"a\": 44, \"b\": 55, \"c\": 66}]),              (modin_pd.DataFrame([{\"a\": 11, \"b\": 22, \"c\": 33}, {\"a\": 44, \"b\": 55, \"c\": 66}])),              ([[11, 22, 33], [44, 55, 66]]),          ],      )      def test_append_modin_without_sheetname(self, excel_file, default_data_frame, content):          dn = ExcelDataNode(\"foo\", Scope.SCENARIO, properties={\"path\": excel_file, \"exposed_type\": \"modin\"})          df_equals(dn.read()[\"Sheet1\"], default_data_frame)            dn.append(content)          df_equals(              dn.read()[\"Sheet1\"],              modin_pd.concat([default_data_frame, modin_pd.DataFrame(content, columns=[\"a\", \"b\", \"c\"])]).reset_index(                  drop=True              ),          )        @pytest.mark.parametrize(          \"content\",          [              (                  {                      \"Sheet1\": modin_pd.DataFrame([{\"a\": 11, \"b\": 22, \"c\": 33}]),                      \"Sheet2\": modin_pd.DataFrame([{\"a\": 44, \"b\": 55, \"c\": 66}]),                  }              ),              (                  {                      \"Sheet1\": modin_pd.DataFrame({\"a\": [11, 44], \"b\": [22, 55], \"c\": [33, 66]}),                      \"Sheet2\": modin_pd.DataFrame([{\"a\": 77, \"b\": 88, \"c\": 99}]),                  }              ),              ({\"Sheet1\": np.array([[11, 22, 33], [44, 55, 66]]), \"Sheet2\": np.array([[77, 88, 99]])}),          ],      )      def test_append_modin_multisheet(self, excel_file_with_multi_sheet, default_multi_sheet_data_frame, content):          dn = ExcelDataNode(              \"foo\",              Scope.SCENARIO,              properties={                  \"path\": excel_file_with_multi_sheet,                  \"sheet_name\": [\"Sheet1\", \"Sheet2\"],                  \"exposed_type\": \"modin\",              },          )          df_equals(dn.read()[\"Sheet1\"], default_multi_sheet_data_frame[\"Sheet1\"])          df_equals(dn.read()[\"Sheet2\"], default_multi_sheet_data_frame[\"Sheet2\"])            dn.append(content)            df_equals(              dn.read()[\"Sheet1\"],              modin_pd.concat(                  [                      default_multi_sheet_data_frame[\"Sheet1\"],                      modin_pd.DataFrame(content[\"Sheet1\"], columns=[\"a\", \"b\", \"c\"]),                  ]              ).reset_index(drop=True),          )          df_equals(              dn.read()[\"Sheet2\"],              modin_pd.concat(                  [                      default_multi_sheet_data_frame[\"Sheet2\"],                      modin_pd.DataFrame(content[\"Sheet2\"], columns=[\"a\", \"b\", \"c\"]),                  ]              ).reset_index(drop=True),          )        def test_filter_pandas_exposed_type_with_sheetname(self, excel_file):          dn = ExcelDataNode(              \"foo\", Scope.SCENARIO, properties={\"path\": excel_file, \"sheet_name\": \"Sheet1\", \"exposed_type\": \"pandas\"}          )          dn.write(              [                  {\"foo\": 1, \"bar\": 1},                  {\"foo\": 1, \"bar\": 2},                  {\"foo\": 1},                  {\"foo\": 2, \"bar\": 2},                  {\"bar\": 2},              ]          )            # Test datanode indexing and slicing          assert dn[\"foo\"].equals(pd.Series([1, 1, 1, 2, None]))          assert dn[\"bar\"].equals(pd.Series([1, 2, None, 2, 2]))          assert dn[:2].equals(pd.DataFrame([{\"foo\": 1.0, \"bar\": 1.0}, {\"foo\": 1.0, \"bar\": 2.0}]))            # Test filter data          filtered_by_filter_method = dn.filter((\"foo\", 1, Operator.EQUAL))          filtered_by_indexing = dn[dn[\"foo\"] == 1]          expected_data = pd.DataFrame([{\"foo\": 1.0, \"bar\": 1.0}, {\"foo\": 1.0, \"bar\": 2.0}, {\"foo\": 1.0}])          assert_frame_equal(filtered_by_filter_method.reset_index(drop=True), expected_data)          assert_frame_equal(filtered_by_indexing.reset_index(drop=True), expected_data)            filtered_by_filter_method = dn.filter((\"foo\", 1, Operator.NOT_EQUAL))          filtered_by_indexing = dn[dn[\"foo\"] != 1]          expected_data = pd.DataFrame([{\"foo\": 2.0, \"bar\": 2.0}, {\"bar\": 2.0}])          assert_frame_equal(filtered_by_filter_method.reset_index(drop=True), expected_data)          assert_frame_equal(filtered_by_indexing.reset_index(drop=True), expected_data)            filtered_by_filter_method = dn.filter((\"bar\", 2, Operator.EQUAL))          filtered_by_indexing = dn[dn[\"bar\"] == 2]          expected_data = pd.DataFrame([{\"foo\": 1.0, \"bar\": 2.0}, {\"foo\": 2.0, \"bar\": 2.0}, {\"bar\": 2.0}])          assert_frame_equal(filtered_by_filter_method.reset_index(drop=True), expected_data)          assert_frame_equal(filtered_by_indexing.reset_index(drop=True), expected_data)            filtered_by_filter_method = dn.filter([(\"bar\", 1, Operator.EQUAL), (\"bar\", 2, Operator.EQUAL)], JoinOperator.OR)          filtered_by_indexing = dn[(dn[\"bar\"] == 1) | (dn[\"bar\"] == 2)]          expected_data = pd.DataFrame(              [                  {\"foo\": 1.0, \"bar\": 1.0},                  {\"foo\": 1.0, \"bar\": 2.0},                  {\"foo\": 2.0, \"bar\": 2.0},                  {\"bar\": 2.0},              ]          )          assert_frame_equal(filtered_by_filter_method.reset_index(drop=True), expected_data)          assert_frame_equal(filtered_by_indexing.reset_index(drop=True), expected_data)        def test_filter_pandas_exposed_type_without_sheetname(self, excel_file):          dn = ExcelDataNode(\"foo\", Scope.SCENARIO, properties={\"path\": excel_file, \"exposed_type\": \"pandas\"})          dn.write(              [                  {\"foo\": 1, \"bar\": 1},                  {\"foo\": 1, \"bar\": 2},                  {\"foo\": 1},                  {\"foo\": 2, \"bar\": 2},                  {\"bar\": 2},              ]          )            assert len(dn.filter((\"foo\", 1, Operator.EQUAL))[\"Sheet1\"]) == 3          assert len(dn.filter((\"foo\", 1, Operator.NOT_EQUAL))[\"Sheet1\"]) == 2          assert len(dn.filter((\"bar\", 2, Operator.EQUAL))[\"Sheet1\"]) == 3          assert len(dn.filter([(\"bar\", 1, Operator.EQUAL), (\"bar\", 2, Operator.EQUAL)], JoinOperator.OR)[\"Sheet1\"]) == 4            assert dn[\"Sheet1\"][\"foo\"].equals(pd.Series([1, 1, 1, 2, None]))          assert dn[\"Sheet1\"][\"bar\"].equals(pd.Series([1, 2, None, 2, 2]))          assert dn[\"Sheet1\"][:2].equals(pd.DataFrame([{\"foo\": 1.0, \"bar\": 1.0}, {\"foo\": 1.0, \"bar\": 2.0}]))        def test_filter_pandas_exposed_type_multisheet(self, excel_file):          dn = ExcelDataNode(              \"foo\",              Scope.SCENARIO,              properties={\"path\": excel_file, \"sheet_name\": [\"sheet_1\", \"sheet_2\"], \"exposed_type\": \"pandas\"},          )          dn.write(              {                  \"sheet_1\": pd.DataFrame(                      [                          {\"foo\": 1, \"bar\": 1},                          {\"foo\": 1, \"bar\": 2},                          {\"foo\": 1},                          {\"foo\": 2, \"bar\": 2},                          {\"bar\": 2},                      ]                  ),                  \"sheet_2\": pd.DataFrame(                      [                          {\"foo\": 1, \"bar\": 3},                          {\"foo\": 1, \"bar\": 4},                          {\"foo\": 1},                          {\"foo\": 2, \"bar\": 4},                          {\"bar\": 4},                      ]                  ),              }          )            assert len(dn.filter((\"foo\", 1, Operator.EQUAL))) == 2          assert len(dn.filter((\"foo\", 1, Operator.EQUAL))[\"sheet_1\"]) == 3          assert len(dn.filter((\"foo\", 1, Operator.EQUAL))[\"sheet_2\"]) == 3            assert len(dn.filter((\"foo\", 1, Operator.NOT_EQUAL))) == 2          assert len(dn.filter((\"foo\", 1, Operator.NOT_EQUAL))[\"sheet_1\"]) == 2          assert len(dn.filter((\"foo\", 1, Operator.NOT_EQUAL))[\"sheet_2\"]) == 2            assert len(dn.filter((\"bar\", 2, Operator.EQUAL))) == 2          assert len(dn.filter((\"bar\", 2, Operator.EQUAL))[\"sheet_1\"]) == 3          assert len(dn.filter((\"bar\", 2, Operator.EQUAL))[\"sheet_2\"]) == 0            assert len(dn.filter([(\"bar\", 1, Operator.EQUAL), (\"bar\", 2, Operator.EQUAL)], JoinOperator.OR)) == 2          assert len(dn.filter([(\"bar\", 1, Operator.EQUAL), (\"bar\", 2, Operator.EQUAL)], JoinOperator.OR)[\"sheet_1\"]) == 4          assert len(dn.filter([(\"bar\", 1, Operator.EQUAL), (\"bar\", 2, Operator.EQUAL)], JoinOperator.OR)[\"sheet_2\"]) == 0            assert dn[\"sheet_1\"][\"foo\"].equals(pd.Series([1, 1, 1, 2, None]))          assert dn[\"sheet_2\"][\"foo\"].equals(pd.Series([1, 1, 1, 2, None]))          assert dn[\"sheet_1\"][\"bar\"].equals(pd.Series([1, 2, None, 2, 2]))          assert dn[\"sheet_2\"][\"bar\"].equals(pd.Series([3, 4, None, 4, 4]))          assert dn[\"sheet_1\"][:2].equals(pd.DataFrame([{\"foo\": 1.0, \"bar\": 1.0}, {\"foo\": 1.0, \"bar\": 2.0}]))          assert dn[\"sheet_2\"][:2].equals(pd.DataFrame([{\"foo\": 1.0, \"bar\": 3.0}, {\"foo\": 1.0, \"bar\": 4.0}]))        def test_filter_modin_exposed_type_with_sheetname(self, excel_file):          dn = ExcelDataNode(              \"foo\", Scope.SCENARIO, properties={\"path\": excel_file, \"sheet_name\": \"Sheet1\", \"exposed_type\": \"modin\"}          )          dn.write(              [                  {\"foo\": 1, \"bar\": 1},                  {\"foo\": 1, \"bar\": 2},                  {\"foo\": 1},                  {\"foo\": 2, \"bar\": 2},                  {\"bar\": 2},              ]          )            # Test datanode indexing and slicing          assert dn[\"foo\"].equals(modin_pd.Series([1, 1, 1, 2, None]))          assert dn[\"bar\"].equals(modin_pd.Series([1, 2, None, 2, 2]))          assert dn[:2].equals(modin_pd.DataFrame([{\"foo\": 1.0, \"bar\": 1.0}, {\"foo\": 1.0, \"bar\": 2.0}]))            # Test filter data          filtered_by_filter_method = dn.filter((\"foo\", 1, Operator.EQUAL))          filtered_by_indexing = dn[dn[\"foo\"] == 1]          expected_data = modin_pd.DataFrame([{\"foo\": 1.0, \"bar\": 1.0}, {\"foo\": 1.0, \"bar\": 2.0}, {\"foo\": 1.0}])          df_equals(filtered_by_filter_method.reset_index(drop=True), expected_data)          df_equals(filtered_by_indexing.reset_index(drop=True), expected_data)            filtered_by_filter_method = dn.filter((\"foo\", 1, Operator.NOT_EQUAL))          filtered_by_indexing = dn[dn[\"foo\"] != 1]          expected_data = modin_pd.DataFrame([{\"foo\": 2.0, \"bar\": 2.0}, {\"bar\": 2.0}])          df_equals(filtered_by_filter_method.reset_index(drop=True), expected_data)          df_equals(filtered_by_indexing.reset_index(drop=True), expected_data)            filtered_by_filter_method = dn.filter((\"bar\", 2, Operator.EQUAL))          filtered_by_indexing = dn[dn[\"bar\"] == 2]          expected_data = modin_pd.DataFrame([{\"foo\": 1.0, \"bar\": 2.0}, {\"foo\": 2.0, \"bar\": 2.0}, {\"bar\": 2.0}])          df_equals(filtered_by_filter_method.reset_index(drop=True), expected_data)          df_equals(filtered_by_indexing.reset_index(drop=True), expected_data)            filtered_by_filter_method = dn.filter([(\"bar\", 1, Operator.EQUAL), (\"bar\", 2, Operator.EQUAL)], JoinOperator.OR)          filtered_by_indexing = dn[(dn[\"bar\"] == 1) | (dn[\"bar\"] == 2)]          expected_data = modin_pd.DataFrame(              [                  {\"foo\": 1.0, \"bar\": 1.0},                  {\"foo\": 1.0, \"bar\": 2.0},                  {\"foo\": 2.0, \"bar\": 2.0},                  {\"bar\": 2.0},              ]          )          df_equals(filtered_by_filter_method.reset_index(drop=True), expected_data)          df_equals(filtered_by_indexing.reset_index(drop=True), expected_data)        def test_filter_modin_exposed_type_without_sheetname(self, excel_file):          dn = ExcelDataNode(\"foo\", Scope.SCENARIO, properties={\"path\": excel_file, \"exposed_type\": \"modin\"})          dn.write(              [                  {\"foo\": 1, \"bar\": 1},                  {\"foo\": 1, \"bar\": 2},                  {\"foo\": 1},                  {\"foo\": 2, \"bar\": 2},                  {\"bar\": 2},              ]          )            assert len(dn.filter((\"foo\", 1, Operator.EQUAL))[\"Sheet1\"]) == 3          assert len(dn.filter((\"foo\", 1, Operator.NOT_EQUAL))[\"Sheet1\"]) == 2          assert len(dn.filter((\"bar\", 2, Operator.EQUAL))[\"Sheet1\"]) == 3          assert len(dn.filter([(\"bar\", 1, Operator.EQUAL), (\"bar\", 2, Operator.EQUAL)], JoinOperator.OR)[\"Sheet1\"]) == 4            assert dn[\"Sheet1\"][\"foo\"].equals(modin_pd.Series([1, 1, 1, 2, None]))          assert dn[\"Sheet1\"][\"bar\"].equals(modin_pd.Series([1, 2, None, 2, 2]))          assert dn[\"Sheet1\"][:2].equals(modin_pd.DataFrame([{\"foo\": 1.0, \"bar\": 1.0}, {\"foo\": 1.0, \"bar\": 2.0}]))        def test_filter_modin_exposed_type_multisheet(self, excel_file):          dn = ExcelDataNode(              \"foo\",              Scope.SCENARIO,              properties={\"path\": excel_file, \"sheet_name\": [\"sheet_1\", \"sheet_2\"], \"exposed_type\": \"modin\"},          )          dn.write(              {                  \"sheet_1\": pd.DataFrame(                      [                          {\"foo\": 1, \"bar\": 1},                          {\"foo\": 1, \"bar\": 2},                          {\"foo\": 1},                          {\"foo\": 2, \"bar\": 2},                          {\"bar\": 2},                      ]                  ),                  \"sheet_2\": pd.DataFrame(                      [                          {\"foo\": 1, \"bar\": 3},                          {\"foo\": 1, \"bar\": 4},                          {\"foo\": 1},                          {\"foo\": 2, \"bar\": 4},                          {\"bar\": 4},                      ]                  ),              }          )            assert len(dn.filter((\"foo\", 1, Operator.EQUAL))) == 2          assert len(dn.filter((\"foo\", 1, Operator.EQUAL))[\"sheet_1\"]) == 3          assert len(dn.filter((\"foo\", 1, Operator.EQUAL))[\"sheet_2\"]) == 3            assert len(dn.filter((\"foo\", 1, Operator.NOT_EQUAL))) == 2          assert len(dn.filter((\"foo\", 1, Operator.NOT_EQUAL))[\"sheet_1\"]) == 2          assert len(dn.filter((\"foo\", 1, Operator.NOT_EQUAL))[\"sheet_2\"]) == 2            assert len(dn.filter((\"bar\", 2, Operator.EQUAL))) == 2          assert len(dn.filter((\"bar\", 2, Operator.EQUAL))[\"sheet_1\"]) == 3          assert len(dn.filter((\"bar\", 2, Operator.EQUAL))[\"sheet_2\"]) == 0            assert len(dn.filter([(\"bar\", 1, Operator.EQUAL), (\"bar\", 2, Operator.EQUAL)], JoinOperator.OR)) == 2          assert len(dn.filter([(\"bar\", 1, Operator.EQUAL), (\"bar\", 2, Operator.EQUAL)], JoinOperator.OR)[\"sheet_1\"]) == 4          assert len(dn.filter([(\"bar\", 1, Operator.EQUAL), (\"bar\", 2, Operator.EQUAL)], JoinOperator.OR)[\"sheet_2\"]) == 0            assert dn[\"sheet_1\"][\"foo\"].equals(modin_pd.Series([1, 1, 1, 2, None]))          assert dn[\"sheet_2\"][\"foo\"].equals(modin_pd.Series([1, 1, 1, 2, None]))          assert dn[\"sheet_1\"][\"bar\"].equals(modin_pd.Series([1, 2, None, 2, 2]))          assert dn[\"sheet_2\"][\"bar\"].equals(modin_pd.Series([3, 4, None, 4, 4]))          assert dn[\"sheet_1\"][:2].equals(modin_pd.DataFrame([{\"foo\": 1.0, \"bar\": 1.0}, {\"foo\": 1.0, \"bar\": 2.0}]))          assert dn[\"sheet_2\"][:2].equals(modin_pd.DataFrame([{\"foo\": 1.0, \"bar\": 3.0}, {\"foo\": 1.0, \"bar\": 4.0}]))        def test_filter_numpy_exposed_type_with_sheetname(self, excel_file):          dn = ExcelDataNode(              \"foo\", Scope.SCENARIO, properties={\"path\": excel_file, \"sheet_name\": \"Sheet1\", \"exposed_type\": \"numpy\"}          )          dn.write(              [                  [1, 1],                  [1, 2],                  [1, 3],                  [2, 1],                  [2, 2],                  [2, 3],              ]          )            # Test datanode indexing and slicing          assert np.array_equal(dn[0], np.array([1, 1]))          assert np.array_equal(dn[1], np.array([1, 2]))          assert np.array_equal(dn[:3], np.array([[1, 1], [1, 2], [1, 3]]))          assert np.array_equal(dn[:, 0], np.array([1, 1, 1, 2, 2, 2]))          assert np.array_equal(dn[1:4, :1], np.array([[1], [1], [2]]))            # Test filter data          assert np.array_equal(dn.filter((0, 1, Operator.EQUAL)), np.array([[1, 1], [1, 2], [1, 3]]))          assert np.array_equal(dn[dn[:, 0] == 1], np.array([[1, 1], [1, 2], [1, 3]]))            assert np.array_equal(dn.filter((0, 1, Operator.NOT_EQUAL)), np.array([[2, 1], [2, 2], [2, 3]]))          assert np.array_equal(dn[dn[:, 0] != 1], np.array([[2, 1], [2, 2], [2, 3]]))            assert np.array_equal(dn.filter((1, 2, Operator.EQUAL)), np.array([[1, 2], [2, 2]]))          assert np.array_equal(dn[dn[:, 1] == 2], np.array([[1, 2], [2, 2]]))            assert np.array_equal(              dn.filter([(1, 1, Operator.EQUAL), (1, 2, Operator.EQUAL)], JoinOperator.OR),              np.array([[1, 1], [1, 2], [2, 1], [2, 2]]),          )          assert np.array_equal(dn[(dn[:, 1] == 1) | (dn[:, 1] == 2)], np.array([[1, 1], [1, 2], [2, 1], [2, 2]]))        def test_filter_numpy_exposed_type_without_sheetname(self, excel_file):          dn = ExcelDataNode(\"foo\", Scope.SCENARIO, properties={\"path\": excel_file, \"exposed_type\": \"numpy\"})          dn.write(              [                  [1, 1],                  [1, 2],                  [1, 3],                  [2, 1],                  [2, 2],                  [2, 3],              ]          )            assert len(dn.filter((0, 1, Operator.EQUAL))[\"Sheet1\"]) == 3          assert len(dn.filter((0, 1, Operator.NOT_EQUAL))[\"Sheet1\"]) == 3          assert len(dn.filter((1, 2, Operator.EQUAL))[\"Sheet1\"]) == 2          assert len(dn.filter([(0, 1, Operator.EQUAL), (1, 2, Operator.EQUAL)], JoinOperator.OR)[\"Sheet1\"]) == 4            assert np.array_equal(dn[\"Sheet1\"][0], np.array([1, 1]))          assert np.array_equal(dn[\"Sheet1\"][1], np.array([1, 2]))          assert np.array_equal(dn[\"Sheet1\"][:3], np.array([[1, 1], [1, 2], [1, 3]]))          assert np.array_equal(dn[\"Sheet1\"][:, 0], np.array([1, 1, 1, 2, 2, 2]))          assert np.array_equal(dn[\"Sheet1\"][1:4, :1], np.array([[1], [1], [2]]))        def test_filter_numpy_exposed_type_multisheet(self, excel_file):          dn = ExcelDataNode(              \"foo\",              Scope.SCENARIO,              properties={\"path\": excel_file, \"sheet_name\": [\"sheet_1\", \"sheet_2\"], \"exposed_type\": \"numpy\"},          )          dn.write(              {                  \"sheet_1\": pd.DataFrame(                      [                          [1, 1],                          [1, 2],                          [1, 3],                          [2, 1],                          [2, 2],                          [2, 3],                      ]                  ),                  \"sheet_2\": pd.DataFrame(                      [                          [1, 4],                          [1, 5],                          [1, 6],                          [2, 4],                          [2, 5],                          [2, 6],                      ]                  ),              }          )            assert len(dn.filter((0, 1, Operator.EQUAL))) == 2          assert len(dn.filter((0, 1, Operator.EQUAL))[\"sheet_1\"]) == 3          assert len(dn.filter((0, 1, Operator.EQUAL))[\"sheet_2\"]) == 3            assert len(dn.filter((0, 1, Operator.NOT_EQUAL))) == 2          assert len(dn.filter((0, 1, Operator.NOT_EQUAL))[\"sheet_1\"]) == 3          assert len(dn.filter((0, 1, Operator.NOT_EQUAL))[\"sheet_2\"]) == 3            assert len(dn.filter((1, 2, Operator.EQUAL))) == 2          assert len(dn.filter((1, 2, Operator.EQUAL))[\"sheet_1\"]) == 2          assert len(dn.filter((1, 2, Operator.EQUAL))[\"sheet_2\"]) == 0            assert len(dn.filter([(1, 1, Operator.EQUAL), (1, 2, Operator.EQUAL)], JoinOperator.OR)) == 2          assert len(dn.filter([(1, 1, Operator.EQUAL), (1, 2, Operator.EQUAL)], JoinOperator.OR)[\"sheet_1\"]) == 4          assert len(dn.filter([(1, 1, Operator.EQUAL), (1, 2, Operator.EQUAL)], JoinOperator.OR)[\"sheet_2\"]) == 0            assert np.array_equal(dn[\"sheet_1\"][0], np.array([1, 1]))          assert np.array_equal(dn[\"sheet_2\"][0], np.array([1, 4]))          assert np.array_equal(dn[\"sheet_1\"][1], np.array([1, 2]))          assert np.array_equal(dn[\"sheet_2\"][1], np.array([1, 5]))          assert np.array_equal(dn[\"sheet_1\"][:3], np.array([[1, 1], [1, 2], [1, 3]]))          assert np.array_equal(dn[\"sheet_2\"][:3], np.array([[1, 4], [1, 5], [1, 6]]))          assert np.array_equal(dn[\"sheet_1\"][:, 0], np.array([1, 1, 1, 2, 2, 2]))          assert np.array_equal(dn[\"sheet_2\"][:, 1], np.array([4, 5, 6, 4, 5, 6]))          assert np.array_equal(dn[\"sheet_1\"][1:4, :1], np.array([[1], [1], [2]]))          assert np.array_equal(dn[\"sheet_2\"][1:4, 1:2], np.array([[5], [6], [4]]))        def test_set_path(self):          dn = ExcelDataNode(\"foo\", Scope.SCENARIO, properties={\"default_path\": \"foo.xlsx\"})          assert dn.path == \"foo.xlsx\"          dn.path = \"bar.xlsx\"          assert dn.path == \"bar.xlsx\"        @pytest.mark.parametrize(          [\"properties\", \"exists\"],          [              ({}, False),              ({\"default_data\": {\"a\": [\"foo\", \"bar\"]}}, True),          ],      )      def test_create_with_default_data(self, properties, exists):          dn = ExcelDataNode(\"foo\", Scope.SCENARIO, DataNodeId(\"dn_id\"), properties=properties)          assert os.path.exists(dn.path) is exists        def test_read_write_after_modify_path(self):          path = os.path.join(pathlib.Path(__file__).parent.resolve(), \"data_sample/example.xlsx\")          new_path = os.path.join(pathlib.Path(__file__).parent.resolve(), \"data_sample/temp.xlsx\")          dn = ExcelDataNode(\"foo\", Scope.SCENARIO, properties={\"default_path\": path})          read_data = dn.read()          assert read_data is not None          dn.path = new_path          with pytest.raises(FileNotFoundError):              dn.read()          dn.write(read_data)          for sheet, df in dn.read().items():              assert np.array_equal(df.values, read_data[sheet].values)        def test_exposed_type_custom_class_after_modify_path(self):          path = os.path.join(pathlib.Path(__file__).parent.resolve(), \"data_sample/example.xlsx\")  # [\"Sheet1\", \"Sheet2\"]          new_path = os.path.join(              pathlib.Path(__file__).parent.resolve(), \"data_sample/example_2.xlsx\"          )  # [\"Sheet1\", \"Sheet2\", \"Sheet3\"]          dn = ExcelDataNode(\"foo\", Scope.SCENARIO, properties={\"default_path\": path, \"exposed_type\": MyCustomObject1})          assert dn.exposed_type == MyCustomObject1          dn.read()          dn.path = new_path          dn.read()            dn = ExcelDataNode(              \"foo\",              Scope.SCENARIO,              properties={\"default_path\": path, \"exposed_type\": MyCustomObject1, \"sheet_name\": [\"Sheet4\"]},          )          assert dn.exposed_type == MyCustomObject1          with pytest.raises(NonExistingExcelSheet):              dn.read()        def test_exposed_type_dict(self):          path = os.path.join(pathlib.Path(__file__).parent.resolve(), \"data_sample/example.xlsx\")  # [\"Sheet1\", \"Sheet2\"]          dn = ExcelDataNode(              \"foo\",              Scope.SCENARIO,              properties={                  \"default_path\": path,                  \"exposed_type\": {                      \"Sheet1\": MyCustomObject1,                      \"Sheet2\": MyCustomObject2,                      \"Sheet3\": MyCustomObject1,                  },              },          )          data = dn.read()          assert isinstance(data, Dict)          assert isinstance(data[\"Sheet1\"][0], MyCustomObject1)          assert isinstance(data[\"Sheet2\"][0], MyCustomObject2)        def test_exposed_type_list(self):          path_1 = os.path.join(              pathlib.Path(__file__).parent.resolve(), \"data_sample/example.xlsx\"          )  # [\"Sheet1\", \"Sheet2\"]          path_2 = os.path.join(              pathlib.Path(__file__).parent.resolve(), \"data_sample/example_2.xlsx\"          )  # [\"Sheet1\", \"Sheet2\", \"Sheet3\"]            dn = ExcelDataNode(              \"foo\",              Scope.SCENARIO,              properties={\"default_path\": path_1, \"exposed_type\": [MyCustomObject1, MyCustomObject2]},          )          data = dn.read()          assert isinstance(data, Dict)          assert isinstance(data[\"Sheet1\"][0], MyCustomObject1)          assert isinstance(data[\"Sheet2\"][0], MyCustomObject2)            dn.path = path_2          with pytest.raises(ExposedTypeLengthMismatch):              dn.read()        def test_not_trying_to_read_sheet_names_when_exposed_type_is_set(self):          dn = ExcelDataNode(              \"foo\", Scope.SCENARIO, properties={\"default_path\": \"notexistyet.xlsx\", \"exposed_type\": MyCustomObject1}          )          assert dn.path == \"notexistyet.xlsx\"          assert dn.exposed_type == MyCustomObject1          dn = ExcelDataNode(              \"foo\",              Scope.SCENARIO,              properties={\"default_path\": \"notexistyet.xlsx\", \"exposed_type\": [MyCustomObject1, MyCustomObject2]},          )          assert dn.path == \"notexistyet.xlsx\"          assert dn.exposed_type == [MyCustomObject1, MyCustomObject2]          dn = ExcelDataNode(              \"foo\",              Scope.SCENARIO,              properties={                  \"default_path\": \"notexistyet.xlsx\",                  \"exposed_type\": {\"Sheet1\": MyCustomObject1, \"Sheet2\": MyCustomObject2},              },          )          assert dn.path == \"notexistyet.xlsx\"          assert dn.exposed_type == {\"Sheet1\": MyCustomObject1, \"Sheet2\": MyCustomObject2}        def test_exposed_type_default(self):          path = os.path.join(pathlib.Path(__file__).parent.resolve(), \"data_sample/example.xlsx\")          dn = ExcelDataNode(\"foo\", Scope.SCENARIO, properties={\"default_path\": path, \"sheet_name\": \"Sheet1\"})          assert dn.exposed_type == \"pandas\"          data = dn.read()          assert isinstance(data, pd.DataFrame)        def test_pandas_exposed_type(self):          path = os.path.join(pathlib.Path(__file__).parent.resolve(), \"data_sample/example.xlsx\")          dn = ExcelDataNode(              \"foo\", Scope.SCENARIO, properties={\"default_path\": path, \"exposed_type\": \"pandas\", \"sheet_name\": \"Sheet1\"}          )          assert dn.exposed_type == \"pandas\"          data = dn.read()          assert isinstance(data, pd.DataFrame)        def test_complex_exposed_type_dict(self):          # [\"Sheet1\", \"Sheet2\", \"Sheet3\", \"Sheet4\", \"Sheet5\"]          path = os.path.join(pathlib.Path(__file__).parent.resolve(), \"data_sample/example_4.xlsx\")          dn = ExcelDataNode(              \"foo\",              Scope.SCENARIO,              properties={                  \"default_path\": path,                  \"exposed_type\": {                      \"Sheet1\": MyCustomObject1,                      \"Sheet2\": \"numpy\",                      \"Sheet3\": \"pandas\",                  },                  \"sheet_name\": [\"Sheet1\", \"Sheet2\", \"Sheet3\", \"Sheet4\"],              },          )          data = dn.read()          assert isinstance(data, dict)          assert isinstance(data[\"Sheet1\"], list)          assert isinstance(data[\"Sheet1\"][0], MyCustomObject1)          assert isinstance(data[\"Sheet2\"], np.ndarray)          assert isinstance(data[\"Sheet3\"], pd.DataFrame)          assert isinstance(data[\"Sheet4\"], pd.DataFrame)          assert data.get(\"Sheet5\") is None        def test_complex_exposed_type_list(self):          # [\"Sheet1\", \"Sheet2\", \"Sheet3\", \"Sheet4\",\"Sheet5\"]          path = os.path.join(pathlib.Path(__file__).parent.resolve(), \"data_sample/example_4.xlsx\")          dn = ExcelDataNode(              \"foo\",              Scope.SCENARIO,              properties={                  \"default_path\": path,                  \"exposed_type\": [MyCustomObject1, \"numpy\", \"pandas\"],                  \"sheet_name\": [\"Sheet1\", \"Sheet2\", \"Sheet3\"],              },          )          data = dn.read()          assert isinstance(data, dict)          assert isinstance(data[\"Sheet1\"], list)          assert isinstance(data[\"Sheet1\"][0], MyCustomObject1)          assert isinstance(data[\"Sheet2\"], np.ndarray)          assert isinstance(data[\"Sheet3\"], pd.DataFrame)        def test_invalid_exposed_type(self):          path = os.path.join(pathlib.Path(__file__).parent.resolve(), \"data_sample/example.xlsx\")          with pytest.raises(InvalidExposedType):              ExcelDataNode(                  \"foo\",                  Scope.SCENARIO,                  properties={\"default_path\": path, \"exposed_type\": \"invalid\", \"sheet_name\": \"Sheet1\"},              )            with pytest.raises(InvalidExposedType):              ExcelDataNode(                  \"foo\",                  Scope.SCENARIO,                  properties={                      \"default_path\": path,                      \"exposed_type\": [\"numpy\", \"invalid\", \"pandas\"],                      \"sheet_name\": \"Sheet1\",                  },              )            with pytest.raises(InvalidExposedType):              ExcelDataNode(                  \"foo\",                  Scope.SCENARIO,                  properties={                      \"default_path\": path,                      \"exposed_type\": {\"Sheet1\": \"pandas\", \"Sheet2\": \"invalid\"},                      \"sheet_name\": \"Sheet1\",                  },              )        def test_get_system_modified_date_instead_of_last_edit_date(self, tmpdir_factory):          temp_file_path = str(tmpdir_factory.mktemp(\"data\").join(\"temp.xlsx\"))          pd.DataFrame([]).to_excel(temp_file_path)          dn = ExcelDataNode(\"foo\", Scope.SCENARIO, properties={\"path\": temp_file_path, \"exposed_type\": \"pandas\"})            dn.write(pd.DataFrame([1, 2, 3]))          previous_edit_date = dn.last_edit_date            sleep(0.1)            pd.DataFrame([4, 5, 6]).to_excel(temp_file_path)          new_edit_date = datetime.fromtimestamp(os.path.getmtime(temp_file_path))            assert previous_edit_date < dn.last_edit_date          assert new_edit_date == dn.last_edit_date            sleep(0.1)            dn.write(pd.DataFrame([7, 8, 9]))          assert new_edit_date < dn.last_edit_date          os.unlink(temp_file_path) "}
{"text": "import os  import pathlib    import pytest    from src.taipy.core._version._version_manager import _VersionManager  from src.taipy.core.config.data_node_config import DataNodeConfig  from src.taipy.core.data._data_manager import _DataManager  from src.taipy.core.data._data_manager_factory import _DataManagerFactory  from src.taipy.core.data.csv import CSVDataNode  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 InvalidDataNodeType, ModelNotFound  from taipy.config.common.scope import Scope  from taipy.config.config import Config      def file_exists(file_path: str) -> bool:      return os.path.exists(file_path)      def init_managers():      _DataManagerFactory._build_manager()._delete_all()      class TestDataManager:      def test_create_data_node_and_modify_properties_does_not_modify_config(self, init_sql_repo):          init_managers()            dn_config = Config.configure_data_node(id=\"name\", foo=\"bar\")          dn = _DataManager._create_and_set(dn_config, None, None)          assert dn_config.properties.get(\"foo\") == \"bar\"          assert dn_config.properties.get(\"baz\") is None            dn.properties[\"baz\"] = \"qux\"          _DataManager._set(dn)          assert dn_config.properties.get(\"foo\") == \"bar\"          assert dn_config.properties.get(\"baz\") is None          assert dn.properties.get(\"foo\") == \"bar\"          assert dn.properties.get(\"baz\") == \"qux\"        def test_create_raises_exception_with_wrong_type(self, init_sql_repo):          init_managers()            wrong_type_dn_config = DataNodeConfig(id=\"foo\", storage_type=\"bar\", scope=DataNodeConfig._DEFAULT_SCOPE)          with pytest.raises(InvalidDataNodeType):              _DataManager._create_and_set(wrong_type_dn_config, None, None)        def test_create_from_same_config_generates_new_data_node_and_new_id(self, init_sql_repo):          init_managers()            dn_config = Config.configure_data_node(id=\"foo\", storage_type=\"in_memory\")          dn = _DataManager._create_and_set(dn_config, None, None)          dn_2 = _DataManager._create_and_set(dn_config, None, None)          assert dn_2.id != dn.id        def test_create_uses_overridden_attributes_in_config_file(self, init_sql_repo):          init_managers()            Config.override(os.path.join(pathlib.Path(__file__).parent.resolve(), \"data_sample/config.toml\"))            csv_dn_cfg = Config.configure_data_node(id=\"foo\", storage_type=\"csv\", path=\"bar\", has_header=True)          csv_dn = _DataManager._create_and_set(csv_dn_cfg, None, None)          assert csv_dn.config_id == \"foo\"          assert isinstance(csv_dn, CSVDataNode)          assert csv_dn._path == \"path_from_config_file\"          assert csv_dn.has_header            csv_dn_cfg = Config.configure_data_node(id=\"baz\", storage_type=\"csv\", path=\"bar\", has_header=True)          csv_dn = _DataManager._create_and_set(csv_dn_cfg, None, None)          assert csv_dn.config_id == \"baz\"          assert isinstance(csv_dn, CSVDataNode)          assert csv_dn._path == \"bar\"          assert csv_dn.has_header        def test_get_if_not_exists(self, init_sql_repo):          init_managers()            with pytest.raises(ModelNotFound):              _DataManager._repository._load(\"test_data_node_2\")        def test_get_all(self, init_sql_repo):          init_managers()            _DataManager._delete_all()          assert len(_DataManager._get_all()) == 0          dn_config_1 = Config.configure_data_node(id=\"foo\", storage_type=\"in_memory\")          _DataManager._create_and_set(dn_config_1, None, None)          assert len(_DataManager._get_all()) == 1          dn_config_2 = Config.configure_data_node(id=\"baz\", storage_type=\"in_memory\")          _DataManager._create_and_set(dn_config_2, None, None)          _DataManager._create_and_set(dn_config_2, None, None)          assert len(_DataManager._get_all()) == 3          assert len([dn for dn in _DataManager._get_all() if dn.config_id == \"foo\"]) == 1          assert len([dn for dn in _DataManager._get_all() if dn.config_id == \"baz\"]) == 2        def test_get_all_on_multiple_versions_environment(self, init_sql_repo):          init_managers()            # Create 5 data nodes with 2 versions each          # Only version 1.0 has the data node with config_id = \"config_id_1\"          # Only version 2.0 has the data node with config_id = \"config_id_6\"          for version in range(1, 3):              for i in range(5):                  _DataManager._set(                      InMemoryDataNode(                          f\"config_id_{i+version}\",                          Scope.SCENARIO,                          id=DataNodeId(f\"id{i}_v{version}\"),                          version=f\"{version}.0\",                      )                  )            _VersionManager._set_experiment_version(\"1.0\")          assert len(_DataManager._get_all()) == 5          assert len(_DataManager._get_all_by(filters=[{\"version\": \"1.0\", \"config_id\": \"config_id_1\"}])) == 1          assert len(_DataManager._get_all_by(filters=[{\"version\": \"1.0\", \"config_id\": \"config_id_6\"}])) == 0            _VersionManager._set_development_version(\"1.0\")          assert len(_DataManager._get_all()) == 5          assert len(_DataManager._get_all_by(filters=[{\"version\": \"1.0\", \"config_id\": \"config_id_1\"}])) == 1          assert len(_DataManager._get_all_by(filters=[{\"version\": \"1.0\", \"config_id\": \"config_id_6\"}])) == 0            _VersionManager._set_experiment_version(\"2.0\")          assert len(_DataManager._get_all()) == 5          assert len(_DataManager._get_all_by(filters=[{\"version\": \"2.0\", \"config_id\": \"config_id_1\"}])) == 0          assert len(_DataManager._get_all_by(filters=[{\"version\": \"2.0\", \"config_id\": \"config_id_6\"}])) == 1            _VersionManager._set_development_version(\"2.0\")          assert len(_DataManager._get_all()) == 5          assert len(_DataManager._get_all_by(filters=[{\"version\": \"2.0\", \"config_id\": \"config_id_1\"}])) == 0          assert len(_DataManager._get_all_by(filters=[{\"version\": \"2.0\", \"config_id\": \"config_id_6\"}])) == 1        def test_set(self, init_sql_repo):          init_managers()            dn = InMemoryDataNode(              \"config_id\",              Scope.SCENARIO,              id=DataNodeId(\"id\"),              owner_id=None,              parent_ids={\"task_id_1\"},              last_edit_date=None,              edits=[],              edit_in_progress=False,              properties={\"foo\": \"bar\"},          )          assert len(_DataManager._get_all()) == 0          assert not _DataManager._exists(dn.id)          _DataManager._set(dn)          assert len(_DataManager._get_all()) == 1          assert _DataManager._exists(dn.id)            # changing data node attribute          dn.config_id = \"foo\"          assert dn.config_id == \"foo\"          _DataManager._set(dn)          assert len(_DataManager._get_all()) == 1          assert dn.config_id == \"foo\"          assert _DataManager._get(dn.id).config_id == \"foo\"        def test_delete(self, init_sql_repo):          init_managers()          _DataManager._delete_all()            dn_1 = InMemoryDataNode(\"config_id\", Scope.SCENARIO, id=\"id_1\")          dn_2 = InMemoryDataNode(\"config_id\", Scope.SCENARIO, id=\"id_2\")          dn_3 = InMemoryDataNode(\"config_id\", Scope.SCENARIO, id=\"id_3\")          assert len(_DataManager._get_all()) == 0          _DataManager._set(dn_1)          _DataManager._set(dn_2)          _DataManager._set(dn_3)          assert len(_DataManager._get_all()) == 3          assert all(_DataManager._exists(dn.id) for dn in [dn_1, dn_2, dn_3])          _DataManager._delete(dn_1.id)          assert len(_DataManager._get_all()) == 2          assert _DataManager._get(dn_2.id).id == dn_2.id          assert _DataManager._get(dn_3.id).id == dn_3.id          assert _DataManager._get(dn_1.id) is None          assert all(_DataManager._exists(dn.id) for dn in [dn_2, dn_3])          assert not _DataManager._exists(dn_1.id)          _DataManager._delete_all()          assert len(_DataManager._get_all()) == 0          assert not any(_DataManager._exists(dn.id) for dn in [dn_2, dn_3])        def test_get_or_create(self, init_sql_repo):          def _get_or_create_dn(config, *args):              return _DataManager._bulk_get_or_create([config], *args)[config]            init_managers()            global_dn_config = Config.configure_data_node(              id=\"test_data_node\", storage_type=\"in_memory\", scope=Scope.GLOBAL, data=\"In memory Data Node\"          )          cycle_dn_config = Config.configure_data_node(              id=\"test_data_node1\", storage_type=\"in_memory\", scope=Scope.CYCLE, data=\"In memory scenario\"          )          scenario_dn_config = Config.configure_data_node(              id=\"test_data_node2\", storage_type=\"in_memory\", scope=Scope.SCENARIO, data=\"In memory scenario\"          )            _DataManager._delete_all()            assert len(_DataManager._get_all()) == 0          global_dn = _get_or_create_dn(global_dn_config, None, None)          assert len(_DataManager._get_all()) == 1          global_dn_bis = _get_or_create_dn(global_dn_config, None)          assert len(_DataManager._get_all()) == 1          assert global_dn.id == global_dn_bis.id            scenario_dn = _get_or_create_dn(scenario_dn_config, None, \"scenario_id\")          assert len(_DataManager._get_all()) == 2          scenario_dn_bis = _get_or_create_dn(scenario_dn_config, None, \"scenario_id\")          assert len(_DataManager._get_all()) == 2          assert scenario_dn.id == scenario_dn_bis.id          scenario_dn_ter = _get_or_create_dn(scenario_dn_config, None, \"scenario_id\")          assert len(_DataManager._get_all()) == 2          assert scenario_dn.id == scenario_dn_bis.id          assert scenario_dn_bis.id == scenario_dn_ter.id          scenario_dn_quater = _get_or_create_dn(scenario_dn_config, None, \"scenario_id_2\")          assert len(_DataManager._get_all()) == 3          assert scenario_dn.id == scenario_dn_bis.id          assert scenario_dn_bis.id == scenario_dn_ter.id          assert scenario_dn_ter.id != scenario_dn_quater.id            assert len(_DataManager._get_all()) == 3          cycle_dn = _get_or_create_dn(cycle_dn_config, \"cycle_id\", None)          assert len(_DataManager._get_all()) == 4          cycle_dn_1 = _get_or_create_dn(cycle_dn_config, \"cycle_id\", None)          assert len(_DataManager._get_all()) == 4          assert cycle_dn.id == cycle_dn_1.id          cycle_dn_2 = _get_or_create_dn(cycle_dn_config, \"cycle_id\", \"scenario_id\")          assert len(_DataManager._get_all()) == 4          assert cycle_dn.id == cycle_dn_2.id          cycle_dn_3 = _get_or_create_dn(cycle_dn_config, \"cycle_id\", None)          assert len(_DataManager._get_all()) == 4          assert cycle_dn.id == cycle_dn_3.id          cycle_dn_4 = _get_or_create_dn(cycle_dn_config, \"cycle_id\", \"scenario_id\")          assert len(_DataManager._get_all()) == 4          assert cycle_dn.id == cycle_dn_4.id          cycle_dn_5 = _get_or_create_dn(cycle_dn_config, \"cycle_id\", \"scenario_id_2\")          assert len(_DataManager._get_all()) == 4          assert cycle_dn.id == cycle_dn_5.id            assert cycle_dn_1.id == cycle_dn_2.id          assert cycle_dn_2.id == cycle_dn_3.id          assert cycle_dn_3.id == cycle_dn_4.id          assert cycle_dn_4.id == cycle_dn_5.id        def test_get_data_nodes_by_config_id(self, init_sql_repo):          init_managers()            dn_config_1 = Config.configure_data_node(\"dn_1\", scope=Scope.SCENARIO)          dn_config_2 = Config.configure_data_node(\"dn_2\", scope=Scope.SCENARIO)          dn_config_3 = Config.configure_data_node(\"dn_3\", scope=Scope.SCENARIO)            dn_1_1 = _DataManager._create_and_set(dn_config_1, None, None)          dn_1_2 = _DataManager._create_and_set(dn_config_1, None, None)          dn_1_3 = _DataManager._create_and_set(dn_config_1, None, None)          assert len(_DataManager._get_all()) == 3            dn_2_1 = _DataManager._create_and_set(dn_config_2, None, None)          dn_2_2 = _DataManager._create_and_set(dn_config_2, None, None)          assert len(_DataManager._get_all()) == 5            dn_3_1 = _DataManager._create_and_set(dn_config_3, None, None)          assert len(_DataManager._get_all()) == 6            dn_1_datanodes = _DataManager._get_by_config_id(dn_config_1.id)          assert len(dn_1_datanodes) == 3          assert sorted([dn_1_1.id, dn_1_2.id, dn_1_3.id]) == sorted([sequence.id for sequence in dn_1_datanodes])            dn_2_datanodes = _DataManager._get_by_config_id(dn_config_2.id)          assert len(dn_2_datanodes) == 2          assert sorted([dn_2_1.id, dn_2_2.id]) == sorted([sequence.id for sequence in dn_2_datanodes])            dn_3_datanodes = _DataManager._get_by_config_id(dn_config_3.id)          assert len(dn_3_datanodes) == 1          assert sorted([dn_3_1.id]) == sorted([sequence.id for sequence in dn_3_datanodes])        def test_get_data_nodes_by_config_id_in_multiple_versions_environment(self, init_sql_repo):          init_managers()            dn_config_1 = Config.configure_data_node(\"dn_1\", scope=Scope.SCENARIO)          dn_config_2 = Config.configure_data_node(\"dn_2\", scope=Scope.SCENARIO)            _VersionManager._set_experiment_version(\"1.0\")          _DataManager._create_and_set(dn_config_1, None, None)          _DataManager._create_and_set(dn_config_1, None, None)          _DataManager._create_and_set(dn_config_1, None, None)          _DataManager._create_and_set(dn_config_2, None, None)          _DataManager._create_and_set(dn_config_2, None, None)            assert len(_DataManager._get_by_config_id(dn_config_1.id)) == 3          assert len(_DataManager._get_by_config_id(dn_config_2.id)) == 2            _VersionManager._set_experiment_version(\"2.0\")          _DataManager._create_and_set(dn_config_1, None, None)          _DataManager._create_and_set(dn_config_1, None, None)          _DataManager._create_and_set(dn_config_1, None, None)          _DataManager._create_and_set(dn_config_2, None, None)          _DataManager._create_and_set(dn_config_2, None, None)            assert len(_DataManager._get_by_config_id(dn_config_1.id)) == 3          assert len(_DataManager._get_by_config_id(dn_config_2.id)) == 2 "}
{"text": "import os    import pytest    from src.taipy.core.data._data_manager_factory import _DataManagerFactory  from src.taipy.core.exceptions import ModelNotFound  from src.taipy.core.job._job_manager_factory import _JobManagerFactory  from src.taipy.core.submission._submission_manager_factory import _SubmissionManagerFactory  from src.taipy.core.submission.submission import Submission  from src.taipy.core.task._task_manager_factory import _TaskManagerFactory  from src.taipy.core.task.task import Task  from taipy.config.config import Config  from tests.core.conftest import init_sql_repo      def configure_fs_repo():      Config.configure_core(repository_type=\"default\")      def configure_sql_repo():      init_sql_repo      class TestSubmissionRepository:      @pytest.mark.parametrize(\"configure_repo\", [configure_fs_repo, configure_sql_repo])      def test_save_and_load(self, data_node, job, configure_repo):          configure_repo()            _DataManagerFactory._build_manager()._repository._save(data_node)          task = Task(\"task_config_id\", {}, print, [data_node], [data_node])          _TaskManagerFactory._build_manager()._repository._save(task)          job._task = task          _JobManagerFactory._build_manager()._repository._save(job)            submission = Submission(task.id, task._ID_PREFIX)          submission_repository = _SubmissionManagerFactory._build_manager()._repository          submission_repository._save(submission)          submission.jobs = [job]            obj = submission_repository._load(submission.id)          assert isinstance(obj, Submission)        @pytest.mark.parametrize(\"configure_repo\", [configure_fs_repo, configure_sql_repo])      def test_exists(self, configure_repo):          configure_repo()            submission = Submission(\"entity_id\", \"ENTITY_TYPE\")          submission_repository = _SubmissionManagerFactory._build_manager()._repository          submission_repository._save(submission)            assert submission_repository._exists(submission.id)          assert not submission_repository._exists(\"not-existed-submission\")        @pytest.mark.parametrize(\"configure_repo\", [configure_fs_repo, configure_sql_repo])      def test_load_all(self, configure_repo):          configure_repo()            repository = _SubmissionManagerFactory._build_manager()._repository          submission = Submission(\"entity_id\", \"ENTITY_TYPE\")          for i in range(10):              submission.id = f\"submission-{i}\"              repository._save(submission)          submissions = repository._load_all()            assert len(submissions) == 10        @pytest.mark.parametrize(\"configure_repo\", [configure_fs_repo, configure_sql_repo])      def test_delete(self, configure_repo):          configure_repo()            repository = _SubmissionManagerFactory._build_manager()._repository            submission = Submission(\"entity_id\", \"ENTITY_TYPE\")          repository._save(submission)            repository._delete(submission.id)            with pytest.raises(ModelNotFound):              repository._load(submission.id)        @pytest.mark.parametrize(\"configure_repo\", [configure_fs_repo, configure_sql_repo])      def test_delete_all(self, configure_repo):          configure_repo()            submission_repository = _SubmissionManagerFactory._build_manager()._repository          submission = Submission(\"entity_id\", \"ENTITY_TYPE\")            for i in range(10):              submission.id = f\"submission-{i}\"              submission_repository._save(submission)            assert len(submission_repository._load_all()) == 10            submission_repository._delete_all()            assert len(submission_repository._load_all()) == 0        @pytest.mark.parametrize(\"configure_repo\", [configure_fs_repo, configure_sql_repo])      def test_delete_many(self, configure_repo):          configure_repo()            submission = Submission(\"entity_id\", \"ENTITY_TYPE\")          submission_repository = _SubmissionManagerFactory._build_manager()._repository            for i in range(10):              submission.id = f\"submission-{i}\"              submission_repository._save(submission)            objs = submission_repository._load_all()          assert len(objs) == 10          ids = [x.id for x in objs[:3]]          submission_repository._delete_many(ids)            assert len(submission_repository._load_all()) == 7        @pytest.mark.parametrize(\"configure_repo\", [configure_fs_repo, configure_sql_repo])      def test_delete_by(self, configure_repo):          configure_repo()            # Create 5 entities with version 1.0 and 5 entities with version 2.0          submission_repository = _SubmissionManagerFactory._build_manager()._repository          submission = Submission(\"entity_id\", \"ENTITY_TYPE\")            for i in range(10):              submission.id = f\"submission-{i}\"              submission._version = f\"{(i+1) // 5}.0\"              submission_repository._save(submission)            objs = submission_repository._load_all()          assert len(objs) == 10          submission_repository._delete_by(\"version\", \"1.0\")            assert len(submission_repository._load_all()) == 5        @pytest.mark.parametrize(\"configure_repo\", [configure_fs_repo, configure_sql_repo])      def test_search(self, configure_repo):          configure_repo()            submission_repository = _SubmissionManagerFactory._build_manager()._repository          submission = Submission(\"entity_id\", \"ENTITY_TYPE\", version=\"random_version_number\")          for i in range(10):              submission.id = f\"submission-{i}\"              submission_repository._save(submission)            assert len(submission_repository._load_all()) == 10            objs = submission_repository._search(\"id\", \"submission-2\")          assert len(objs) == 1          assert isinstance(objs[0], Submission)            objs = submission_repository._search(\"id\", \"submission-2\", filters=[{\"version\": \"random_version_number\"}])          assert len(objs) == 1          assert isinstance(objs[0], Submission)            assert submission_repository._search(\"id\", \"submission-2\", filters=[{\"version\": \"non_existed_version\"}]) == []        @pytest.mark.parametrize(\"configure_repo\", [configure_fs_repo, configure_sql_repo])      def test_export(self, tmpdir, configure_repo):          configure_repo()            repository = _SubmissionManagerFactory._build_manager()._repository          submission = Submission(\"entity_id\", \"ENTITY_TYPE\")          repository._save(submission)            repository._export(submission.id, tmpdir.strpath)          dir_path = (              repository.dir_path              if Config.core.repository_type == \"default\"              else os.path.join(tmpdir.strpath, \"submission\")          )            assert os.path.exists(os.path.join(dir_path, f\"{submission.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": "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 functools import partial  from typing import Union  from unittest import mock  from unittest.mock import patch    import pytest    from src.taipy.core import TaskId  from src.taipy.core.job._job_manager_factory import _JobManagerFactory  from src.taipy.core.job.job import Job  from src.taipy.core.job.status import Status  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_manager_factory import _TaskManagerFactory  from src.taipy.core.task.task import Task      def test_create_submission(scenario, job, current_datetime):      submission_1 = Submission(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      assert submission_1._version is not None        submission_2 = Submission(          scenario.id,          scenario._ID_PREFIX,          \"submission_id\",          [job],          current_datetime,          SubmissionStatus.COMPLETED,          \"version_id\",      )        assert submission_2.id == \"submission_id\"      assert submission_2.entity_id == scenario.id      assert submission_2._jobs == [job]      assert submission_2.creation_date == current_datetime      assert submission_2._submission_status == SubmissionStatus.COMPLETED      assert submission_2._version == \"version_id\"      class MockJob:      def __init__(self, id: str, status):          self.status = status          self.id = id        def is_failed(self):          return self.status == Status.FAILED        def is_canceled(self):          return self.status == Status.CANCELED        def is_blocked(self):          return self.status == Status.BLOCKED        def is_pending(self):          return self.status == Status.PENDING        def is_running(self):          return self.status == Status.RUNNING        def is_completed(self):          return self.status == Status.COMPLETED        def is_skipped(self):          return self.status == Status.SKIPPED        def is_abandoned(self):          return self.status == Status.ABANDONED        def is_submitted(self):          return self.status == Status.SUBMITTED      def __test_update_submission_status(job_ids, expected_submission_status):      jobs = {          \"job0_submitted\": MockJob(\"job0_submitted\", Status.SUBMITTED),          \"job1_failed\": MockJob(\"job1_failed\", Status.FAILED),          \"job2_canceled\": MockJob(\"job2_canceled\", Status.CANCELED),          \"job3_blocked\": MockJob(\"job3_blocked\", Status.BLOCKED),          \"job4_pending\": MockJob(\"job4_pending\", Status.PENDING),          \"job5_running\": MockJob(\"job5_running\", Status.RUNNING),          \"job6_completed\": MockJob(\"job6_completed\", Status.COMPLETED),          \"job7_skipped\": MockJob(\"job7_skipped\", Status.SKIPPED),          \"job8_abandoned\": MockJob(\"job8_abandoned\", Status.ABANDONED),      }        submission = Submission(\"submission_id\", \"ENTITY_TYPE\")      submission.jobs = [jobs[job_id] for job_id in job_ids]      for job_id in job_ids:          job = jobs[job_id]          submission._update_submission_status(job)      assert submission.submission_status == expected_submission_status      @pytest.mark.parametrize(      \"job_ids, expected_submission_status\",      [          ([\"job1_failed\"], SubmissionStatus.FAILED),          ([\"job2_canceled\"], SubmissionStatus.CANCELED),          ([\"job3_blocked\"], SubmissionStatus.BLOCKED),          ([\"job4_pending\"], SubmissionStatus.PENDING),          ([\"job5_running\"], SubmissionStatus.RUNNING),          ([\"job6_completed\"], SubmissionStatus.COMPLETED),          ([\"job7_skipped\"], SubmissionStatus.COMPLETED),          ([\"job8_abandoned\"], SubmissionStatus.UNDEFINED),      ],  )  def test_update_single_submission_status(job_ids, expected_submission_status):      __test_update_submission_status(job_ids, expected_submission_status)      @pytest.mark.parametrize(      \"job_ids, expected_submission_status\",      [          ([\"job1_failed\", \"job1_failed\"], SubmissionStatus.FAILED),          ([\"job1_failed\", \"job2_canceled\"], SubmissionStatus.FAILED),          ([\"job1_failed\", \"job3_blocked\"], SubmissionStatus.FAILED),          ([\"job1_failed\", \"job4_pending\"], SubmissionStatus.FAILED),          ([\"job1_failed\", \"job5_running\"], SubmissionStatus.FAILED),          ([\"job1_failed\", \"job6_completed\"], SubmissionStatus.FAILED),          ([\"job1_failed\", \"job7_skipped\"], SubmissionStatus.FAILED),          ([\"job1_failed\", \"job8_abandoned\"], SubmissionStatus.FAILED),          ([\"job2_canceled\", \"job1_failed\"], SubmissionStatus.FAILED),          ([\"job3_blocked\", \"job1_failed\"], SubmissionStatus.FAILED),          ([\"job4_pending\", \"job1_failed\"], SubmissionStatus.FAILED),          ([\"job5_running\", \"job1_failed\"], SubmissionStatus.FAILED),          ([\"job6_completed\", \"job1_failed\"], SubmissionStatus.FAILED),          ([\"job7_skipped\", \"job1_failed\"], SubmissionStatus.FAILED),          ([\"job8_abandoned\", \"job1_failed\"], SubmissionStatus.FAILED),      ],  )  def test_update_submission_status_with_one_failed_job_in_jobs(job_ids, expected_submission_status):      __test_update_submission_status(job_ids, expected_submission_status)      @pytest.mark.parametrize(      \"job_ids, expected_submission_status\",      [          ([\"job2_canceled\", \"job2_canceled\"], SubmissionStatus.CANCELED),          ([\"job2_canceled\", \"job3_blocked\"], SubmissionStatus.CANCELED),          ([\"job2_canceled\", \"job4_pending\"], SubmissionStatus.CANCELED),          ([\"job2_canceled\", \"job5_running\"], SubmissionStatus.CANCELED),          ([\"job2_canceled\", \"job6_completed\"], SubmissionStatus.CANCELED),          ([\"job2_canceled\", \"job7_skipped\"], SubmissionStatus.CANCELED),          ([\"job2_canceled\", \"job8_abandoned\"], SubmissionStatus.CANCELED),          ([\"job3_blocked\", \"job2_canceled\"], SubmissionStatus.CANCELED),          ([\"job4_pending\", \"job2_canceled\"], SubmissionStatus.CANCELED),          ([\"job5_running\", \"job2_canceled\"], SubmissionStatus.CANCELED),          ([\"job6_completed\", \"job2_canceled\"], SubmissionStatus.CANCELED),          ([\"job7_skipped\", \"job2_canceled\"], SubmissionStatus.CANCELED),          ([\"job8_abandoned\", \"job2_canceled\"], SubmissionStatus.CANCELED),      ],  )  def test_update_submission_status_with_one_canceled_job_in_jobs(job_ids, expected_submission_status):      __test_update_submission_status(job_ids, expected_submission_status)      @pytest.mark.parametrize(      \"job_ids, expected_submission_status\",      [          ([\"job4_pending\", \"job3_blocked\"], SubmissionStatus.PENDING),          ([\"job4_pending\", \"job4_pending\"], SubmissionStatus.PENDING),          ([\"job4_pending\", \"job6_completed\"], SubmissionStatus.PENDING),          ([\"job4_pending\", \"job7_skipped\"], SubmissionStatus.PENDING),          ([\"job3_blocked\", \"job4_pending\"], SubmissionStatus.PENDING),          ([\"job6_completed\", \"job4_pending\"], SubmissionStatus.PENDING),          ([\"job7_skipped\", \"job4_pending\"], SubmissionStatus.PENDING),      ],  )  def test_update_submission_status_with_no_failed_or_cancel_one_pending_in_jobs(job_ids, expected_submission_status):      __test_update_submission_status(job_ids, expected_submission_status)      @pytest.mark.parametrize(      \"job_ids, expected_submission_status\",      [          ([\"job5_running\", \"job3_blocked\"], SubmissionStatus.RUNNING),          ([\"job5_running\", \"job4_pending\"], SubmissionStatus.RUNNING),          ([\"job5_running\", \"job5_running\"], SubmissionStatus.RUNNING),          ([\"job5_running\", \"job6_completed\"], SubmissionStatus.RUNNING),          ([\"job5_running\", \"job7_skipped\"], SubmissionStatus.RUNNING),          ([\"job3_blocked\", \"job5_running\"], SubmissionStatus.RUNNING),          ([\"job4_pending\", \"job5_running\"], SubmissionStatus.RUNNING),          ([\"job6_completed\", \"job5_running\"], SubmissionStatus.RUNNING),          ([\"job7_skipped\", \"job5_running\"], SubmissionStatus.RUNNING),      ],  )  def test_update_submission_status_with_no_failed_cancel_nor_pending_one_running_in_jobs(      job_ids, expected_submission_status  ):      __test_update_submission_status(job_ids, expected_submission_status)      @pytest.mark.parametrize(      \"job_ids, expected_submission_status\",      [          ([\"job3_blocked\", \"job3_blocked\"], SubmissionStatus.BLOCKED),          ([\"job3_blocked\", \"job6_completed\"], SubmissionStatus.BLOCKED),          ([\"job3_blocked\", \"job7_skipped\"], SubmissionStatus.BLOCKED),          ([\"job6_completed\", \"job3_blocked\"], SubmissionStatus.BLOCKED),          ([\"job7_skipped\", \"job3_blocked\"], SubmissionStatus.BLOCKED),      ],  )  def test_update_submission_status_with_no_failed_cancel_pending_nor_running_one_blocked_in_jobs(      job_ids, expected_submission_status  ):      __test_update_submission_status(job_ids, expected_submission_status)      @pytest.mark.parametrize(      \"job_ids, expected_submission_status\",      [          ([\"job6_completed\", \"job6_completed\"], SubmissionStatus.COMPLETED),          ([\"job6_completed\", \"job7_skipped\"], SubmissionStatus.COMPLETED),          ([\"job7_skipped\", \"job6_completed\"], SubmissionStatus.COMPLETED),          ([\"job7_skipped\", \"job7_skipped\"], SubmissionStatus.COMPLETED),      ],  )  def test_update_submission_status_with_only_completed_or_skipped_in_jobs(job_ids, expected_submission_status):      __test_update_submission_status(job_ids, expected_submission_status)      @pytest.mark.parametrize(      \"job_ids, expected_submission_status\",      [          ([\"job3_blocked\", \"job8_abandoned\"], SubmissionStatus.UNDEFINED),          ([\"job4_pending\", \"job8_abandoned\"], SubmissionStatus.UNDEFINED),          ([\"job5_running\", \"job8_abandoned\"], SubmissionStatus.UNDEFINED),          ([\"job6_completed\", \"job8_abandoned\"], SubmissionStatus.UNDEFINED),          ([\"job7_skipped\", \"job8_abandoned\"], SubmissionStatus.UNDEFINED),          ([\"job8_abandoned\", \"job8_abandoned\"], SubmissionStatus.UNDEFINED),          ([\"job8_abandoned\", \"job3_blocked\"], SubmissionStatus.UNDEFINED),          ([\"job8_abandoned\", \"job4_pending\"], SubmissionStatus.UNDEFINED),          ([\"job8_abandoned\", \"job5_running\"], SubmissionStatus.UNDEFINED),          ([\"job8_abandoned\", \"job6_completed\"], SubmissionStatus.UNDEFINED),          ([\"job8_abandoned\", \"job7_skipped\"], SubmissionStatus.UNDEFINED),      ],  )  def test_update_submission_status_with_wrong_case_abandoned_without_cancel_or_failed_in_jobs(      job_ids, expected_submission_status  ):      __test_update_submission_status(job_ids, expected_submission_status)      def test_auto_set_and_reload():      task = Task(config_id=\"name_1\", properties={}, function=print, id=TaskId(\"task_1\"))      submission_1 = Submission(task.id, task._ID_PREFIX)      job_1 = Job(\"job_1\", task, submission_1.id, submission_1.entity_id)      job_2 = Job(\"job_2\", task, submission_1.id, submission_1.entity_id)        _TaskManagerFactory._build_manager()._set(task)      _SubmissionManagerFactory._build_manager()._set(submission_1)      _JobManagerFactory._build_manager()._set(job_1)      _JobManagerFactory._build_manager()._set(job_2)        submission_2 = _SubmissionManagerFactory._build_manager()._get(submission_1)        assert submission_1.id == submission_2.id      assert submission_1.entity_id == submission_2.entity_id      assert submission_1.creation_date == submission_2.creation_date      assert submission_1.submission_status == submission_2.submission_status        # auto set & reload on jobs attribute      assert submission_1.jobs == []      assert submission_2.jobs == []      submission_1.jobs = [job_1]      assert submission_1.jobs == [job_1]      assert submission_2.jobs == [job_1]      submission_2.jobs = [job_2]      assert submission_1.jobs == [job_2]      assert submission_2.jobs == [job_2]      submission_1.jobs = [job_1, job_2]      assert submission_1.jobs == [job_1, job_2]      assert submission_2.jobs == [job_1, job_2]      submission_2.jobs = [job_2, job_1]      assert submission_1.jobs == [job_2, job_1]      assert submission_2.jobs == [job_2, job_1]        # auto set & reload on submission_status attribute      assert submission_1.submission_status == SubmissionStatus.SUBMITTED      assert submission_2.submission_status == SubmissionStatus.SUBMITTED      submission_1.submission_status = SubmissionStatus.BLOCKED      assert submission_1.submission_status == SubmissionStatus.BLOCKED      assert submission_2.submission_status == SubmissionStatus.BLOCKED      submission_2.submission_status = SubmissionStatus.COMPLETED      assert submission_1.submission_status == SubmissionStatus.COMPLETED      assert submission_2.submission_status == SubmissionStatus.COMPLETED        with submission_1 as submission:          assert submission.jobs == [job_2, job_1]          assert submission.submission_status == SubmissionStatus.COMPLETED            submission.jobs = [job_1]          submission.submission_status = SubmissionStatus.PENDING            assert submission.jobs == [job_2, job_1]          assert submission.submission_status == SubmissionStatus.COMPLETED        assert submission_1.jobs == [job_1]      assert submission_1.submission_status == SubmissionStatus.PENDING      assert submission_2.jobs == [job_1]      assert submission_2.submission_status == SubmissionStatus.PENDING      @pytest.mark.parametrize(      \"job_statuses, expected_submission_statuses\",      [          (              [Status.SUBMITTED, Status.PENDING, Status.RUNNING, Status.COMPLETED],              [SubmissionStatus.PENDING, SubmissionStatus.PENDING, SubmissionStatus.RUNNING, SubmissionStatus.COMPLETED],          ),          (              [Status.SUBMITTED, Status.PENDING, Status.RUNNING, Status.SKIPPED],              [SubmissionStatus.PENDING, SubmissionStatus.PENDING, SubmissionStatus.RUNNING, SubmissionStatus.COMPLETED],          ),          (              [Status.SUBMITTED, Status.PENDING, Status.RUNNING, Status.FAILED],              [SubmissionStatus.PENDING, SubmissionStatus.PENDING, SubmissionStatus.RUNNING, SubmissionStatus.FAILED],          ),          (              [Status.SUBMITTED, Status.PENDING, Status.CANCELED],              [SubmissionStatus.PENDING, SubmissionStatus.PENDING, SubmissionStatus.CANCELED],          ),          (              [Status.SUBMITTED, Status.PENDING, Status.RUNNING, Status.CANCELED],              [SubmissionStatus.PENDING, SubmissionStatus.PENDING, SubmissionStatus.RUNNING, SubmissionStatus.CANCELED],          ),          ([Status.SUBMITTED, Status.BLOCKED], [SubmissionStatus.PENDING, SubmissionStatus.BLOCKED]),          ([Status.SUBMITTED, Status.SKIPPED], [SubmissionStatus.PENDING, SubmissionStatus.COMPLETED]),      ],  )  def test_update_submission_status_with_single_job_completed(job_statuses, expected_submission_statuses):      job = MockJob(\"job_id\", Status.SUBMITTED)      submission = Submission(\"submission_id\", \"ENTITY_TYPE\")        assert submission.submission_status == SubmissionStatus.SUBMITTED        for job_status, submission_status in zip(job_statuses, expected_submission_statuses):          job.status = job_status          submission._update_submission_status(job)          assert submission.submission_status == submission_status      def __test_update_submission_status_with_two_jobs(job_ids, job_statuses, expected_submission_statuses):      jobs = {job_id: MockJob(job_id, Status.SUBMITTED) for job_id in job_ids}      submission = Submission(\"submission_id\", \"ENTITY_TYPE\")        assert submission.submission_status == SubmissionStatus.SUBMITTED        for (job_id, job_status), submission_status in zip(job_statuses, expected_submission_statuses):          job = jobs[job_id]          job.status = job_status          submission._update_submission_status(job)          assert submission.submission_status == submission_status      @pytest.mark.parametrize(      \"job_ids, job_statuses, expected_submission_statuses\",      [          (              [\"job_1\", \"job_2\"],              [                  (\"job_1\", Status.SUBMITTED),                  (\"job_2\", Status.SUBMITTED),                  (\"job_1\", Status.PENDING),                  (\"job_2\", Status.PENDING),                  (\"job_1\", Status.RUNNING),                  (\"job_2\", Status.RUNNING),                  (\"job_1\", Status.COMPLETED),                  (\"job_2\", Status.COMPLETED),              ],              [                  SubmissionStatus.PENDING,                  SubmissionStatus.PENDING,                  SubmissionStatus.PENDING,                  SubmissionStatus.PENDING,                  SubmissionStatus.RUNNING,                  SubmissionStatus.RUNNING,                  SubmissionStatus.RUNNING,                  SubmissionStatus.COMPLETED,              ],          ),          (              [\"job_1\", \"job_2\"],              [                  (\"job_1\", Status.SUBMITTED),                  (\"job_2\", Status.SUBMITTED),                  (\"job_1\", Status.PENDING),                  (\"job_1\", Status.RUNNING),                  (\"job_2\", Status.PENDING),                  (\"job_2\", Status.RUNNING),                  (\"job_1\", Status.COMPLETED),                  (\"job_2\", Status.COMPLETED),              ],              [                  SubmissionStatus.PENDING,                  SubmissionStatus.PENDING,                  SubmissionStatus.PENDING,                  SubmissionStatus.RUNNING,                  SubmissionStatus.RUNNING,                  SubmissionStatus.RUNNING,                  SubmissionStatus.RUNNING,                  SubmissionStatus.COMPLETED,              ],          ),          (              [\"job_1\", \"job_2\"],              [                  (\"job_1\", Status.SUBMITTED),                  (\"job_2\", Status.SUBMITTED),                  (\"job_1\", Status.BLOCKED),                  (\"job_2\", Status.PENDING),                  (\"job_2\", Status.RUNNING),                  (\"job_2\", Status.COMPLETED),                  (\"job_1\", Status.PENDING),                  (\"job_1\", Status.RUNNING),                  (\"job_1\", Status.COMPLETED),              ],              [                  SubmissionStatus.PENDING,                  SubmissionStatus.PENDING,                  SubmissionStatus.PENDING,                  SubmissionStatus.PENDING,                  SubmissionStatus.RUNNING,                  SubmissionStatus.BLOCKED,                  SubmissionStatus.PENDING,                  SubmissionStatus.RUNNING,                  SubmissionStatus.COMPLETED,              ],          ),      ],  )  def test_update_submission_status_with_two_jobs_completed(job_ids, job_statuses, expected_submission_statuses):      __test_update_submission_status_with_two_jobs(job_ids, job_statuses, expected_submission_statuses)      @pytest.mark.parametrize(      \"job_ids, job_statuses, expected_submission_statuses\",      [          (              [\"job_1\", \"job_2\"],              [                  (\"job_1\", Status.SUBMITTED),                  (\"job_2\", Status.SUBMITTED),                  (\"job_1\", Status.PENDING),                  (\"job_2\", Status.PENDING),                  (\"job_1\", Status.RUNNING),                  (\"job_2\", Status.SKIPPED),                  (\"job_1\", Status.COMPLETED),              ],              [                  SubmissionStatus.PENDING,                  SubmissionStatus.PENDING,                  SubmissionStatus.PENDING,                  SubmissionStatus.PENDING,                  SubmissionStatus.RUNNING,                  SubmissionStatus.RUNNING,                  SubmissionStatus.COMPLETED,              ],          ),          (              [\"job_1\", \"job_2\"],              [                  (\"job_1\", Status.SUBMITTED),                  (\"job_2\", Status.SUBMITTED),                  (\"job_1\", Status.PENDING),                  (\"job_1\", Status.RUNNING),                  (\"job_2\", Status.PENDING),                  (\"job_2\", Status.SKIPPED),                  (\"job_1\", Status.COMPLETED),              ],              [                  SubmissionStatus.PENDING,                  SubmissionStatus.PENDING,                  SubmissionStatus.PENDING,                  SubmissionStatus.RUNNING,                  SubmissionStatus.RUNNING,                  SubmissionStatus.RUNNING,                  SubmissionStatus.COMPLETED,              ],          ),          (              [\"job_1\", \"job_2\"],              [                  (\"job_1\", Status.SUBMITTED),                  (\"job_2\", Status.SUBMITTED),                  (\"job_1\", Status.BLOCKED),                  (\"job_2\", Status.PENDING),                  (\"job_2\", Status.RUNNING),                  (\"job_2\", Status.COMPLETED),                  (\"job_1\", Status.PENDING),                  (\"job_1\", Status.SKIPPED),              ],              [                  SubmissionStatus.PENDING,                  SubmissionStatus.PENDING,                  SubmissionStatus.PENDING,                  SubmissionStatus.PENDING,                  SubmissionStatus.RUNNING,                  SubmissionStatus.BLOCKED,                  SubmissionStatus.PENDING,                  SubmissionStatus.COMPLETED,              ],          ),          (              [\"job_1\", \"job_2\"],              [                  (\"job_1\", Status.SUBMITTED),                  (\"job_2\", Status.SUBMITTED),                  (\"job_1\", Status.PENDING),                  (\"job_2\", Status.PENDING),                  (\"job_1\", Status.SKIPPED),                  (\"job_2\", Status.SKIPPED),              ],              [                  SubmissionStatus.PENDING,                  SubmissionStatus.PENDING,                  SubmissionStatus.PENDING,                  SubmissionStatus.PENDING,                  SubmissionStatus.PENDING,                  SubmissionStatus.COMPLETED,              ],          ),          (              [\"job_1\", \"job_2\"],              [                  (\"job_1\", Status.SUBMITTED),                  (\"job_2\", Status.SUBMITTED),                  (\"job_1\", Status.PENDING),                  (\"job_1\", Status.SKIPPED),                  (\"job_2\", Status.PENDING),                  (\"job_2\", Status.SKIPPED),              ],              [                  SubmissionStatus.PENDING,                  SubmissionStatus.PENDING,                  SubmissionStatus.PENDING,                  SubmissionStatus.PENDING,                  SubmissionStatus.PENDING,                  SubmissionStatus.COMPLETED,              ],          ),          (              [\"job_1\", \"job_2\"],              [                  (\"job_1\", Status.SUBMITTED),                  (\"job_2\", Status.SUBMITTED),                  (\"job_1\", Status.BLOCKED),                  (\"job_2\", Status.PENDING),                  (\"job_2\", Status.SKIPPED),                  (\"job_1\", Status.PENDING),                  (\"job_1\", Status.SKIPPED),              ],              [                  SubmissionStatus.PENDING,                  SubmissionStatus.PENDING,                  SubmissionStatus.PENDING,                  SubmissionStatus.PENDING,                  SubmissionStatus.BLOCKED,                  SubmissionStatus.PENDING,                  SubmissionStatus.COMPLETED,              ],          ),      ],  )  def test_update_submission_status_with_two_jobs_skipped(job_ids, job_statuses, expected_submission_statuses):      __test_update_submission_status_with_two_jobs(job_ids, job_statuses, expected_submission_statuses)      @pytest.mark.parametrize(      \"job_ids, job_statuses, expected_submission_statuses\",      [          (              [\"job_1\", \"job_2\"],              [                  (\"job_1\", Status.SUBMITTED),                  (\"job_2\", Status.SUBMITTED),                  (\"job_1\", Status.PENDING),                  (\"job_2\", Status.PENDING),                  (\"job_1\", Status.RUNNING),                  (\"job_2\", Status.RUNNING),                  (\"job_1\", Status.FAILED),                  (\"job_2\", Status.COMPLETED),              ],              [                  SubmissionStatus.PENDING,                  SubmissionStatus.PENDING,                  SubmissionStatus.PENDING,                  SubmissionStatus.PENDING,                  SubmissionStatus.RUNNING,                  SubmissionStatus.RUNNING,                  SubmissionStatus.FAILED,                  SubmissionStatus.FAILED,              ],          ),          (              [\"job_1\", \"job_2\"],              [                  (\"job_1\", Status.SUBMITTED),                  (\"job_2\", Status.SUBMITTED),                  (\"job_1\", Status.PENDING),                  (\"job_1\", Status.RUNNING),                  (\"job_2\", Status.PENDING),                  (\"job_2\", Status.RUNNING),                  (\"job_1\", Status.COMPLETED),                  (\"job_2\", Status.FAILED),              ],              [                  SubmissionStatus.PENDING,                  SubmissionStatus.PENDING,                  SubmissionStatus.PENDING,                  SubmissionStatus.RUNNING,                  SubmissionStatus.RUNNING,                  SubmissionStatus.RUNNING,                  SubmissionStatus.RUNNING,                  SubmissionStatus.FAILED,              ],          ),          (              [\"job_1\", \"job_2\"],              [                  (\"job_1\", Status.SUBMITTED),                  (\"job_2\", Status.SUBMITTED),                  (\"job_1\", Status.BLOCKED),                  (\"job_2\", Status.PENDING),                  (\"job_2\", Status.RUNNING),                  (\"job_2\", Status.FAILED),                  (\"job_1\", Status.ABANDONED),              ],              [                  SubmissionStatus.PENDING,                  SubmissionStatus.PENDING,                  SubmissionStatus.PENDING,                  SubmissionStatus.PENDING,                  SubmissionStatus.RUNNING,                  SubmissionStatus.FAILED,                  SubmissionStatus.FAILED,              ],          ),      ],  )  def test_update_submission_status_with_two_jobs_failed(job_ids, job_statuses, expected_submission_statuses):      __test_update_submission_status_with_two_jobs(job_ids, job_statuses, expected_submission_statuses)      @pytest.mark.parametrize(      \"job_ids, job_statuses, expected_submission_statuses\",      [          (              [\"job_1\", \"job_2\"],              [                  (\"job_1\", Status.SUBMITTED),                  (\"job_2\", Status.SUBMITTED),                  (\"job_1\", Status.PENDING),                  (\"job_2\", Status.PENDING),                  (\"job_1\", Status.RUNNING),                  (\"job_2\", Status.RUNNING),                  (\"job_1\", Status.CANCELED),                  (\"job_2\", Status.COMPLETED),              ],              [                  SubmissionStatus.PENDING,                  SubmissionStatus.PENDING,                  SubmissionStatus.PENDING,                  SubmissionStatus.PENDING,                  SubmissionStatus.RUNNING,                  SubmissionStatus.RUNNING,                  SubmissionStatus.CANCELED,                  SubmissionStatus.CANCELED,              ],          ),          (              [\"job_1\", \"job_2\"],              [                  (\"job_1\", Status.SUBMITTED),                  (\"job_2\", Status.SUBMITTED),                  (\"job_1\", Status.PENDING),                  (\"job_1\", Status.RUNNING),                  (\"job_2\", Status.PENDING),                  (\"job_2\", Status.RUNNING),                  (\"job_1\", Status.COMPLETED),                  (\"job_2\", Status.CANCELED),              ],              [                  SubmissionStatus.PENDING,                  SubmissionStatus.PENDING,                  SubmissionStatus.PENDING,                  SubmissionStatus.RUNNING,                  SubmissionStatus.RUNNING,                  SubmissionStatus.RUNNING,                  SubmissionStatus.RUNNING,                  SubmissionStatus.CANCELED,              ],          ),          (              [\"job_1\", \"job_2\"],              [                  (\"job_1\", Status.SUBMITTED),                  (\"job_2\", Status.SUBMITTED),                  (\"job_1\", Status.BLOCKED),                  (\"job_2\", Status.PENDING),                  (\"job_2\", Status.RUNNING),                  (\"job_2\", Status.CANCELED),                  (\"job_1\", Status.ABANDONED),              ],              [                  SubmissionStatus.PENDING,                  SubmissionStatus.PENDING,                  SubmissionStatus.PENDING,                  SubmissionStatus.PENDING,                  SubmissionStatus.RUNNING,                  SubmissionStatus.CANCELED,                  SubmissionStatus.CANCELED,              ],          ),      ],  )  def test_update_submission_status_with_two_jobs_canceled(job_ids, job_statuses, expected_submission_statuses):      __test_update_submission_status_with_two_jobs(job_ids, job_statuses, expected_submission_statuses) "}
{"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": "from unittest import mock    from src.taipy.config import Config  from src.taipy.config._config import _Config  from src.taipy.config._config_comparator._comparator_result import _ComparatorResult  from src.taipy.config.global_app.global_app_config import GlobalAppConfig  from tests.config.utils.section_for_tests import SectionForTest  from tests.config.utils.unique_section_for_tests import UniqueSectionForTest      class TestConfigComparator:      unique_section_1 = UniqueSectionForTest(attribute=\"unique_attribute_1\", prop=\"unique_prop_1\")      unique_section_1b = UniqueSectionForTest(attribute=\"unique_attribute_1\", prop=\"unique_prop_1b\")      section_1 = SectionForTest(\"section_1\", attribute=\"attribute_1\", prop=\"prop_1\")      section_2 = SectionForTest(\"section_2\", attribute=2, prop=\"prop_2\")      section_2b = SectionForTest(\"section_2\", attribute=\"attribute_2\", prop=\"prop_2b\")      section_3 = SectionForTest(\"section_3\", attribute=[1, 2, 3, 4], prop=[\"prop_1\"])      section_3b = SectionForTest(\"section_3\", attribute=[1, 2], prop=[\"prop_1\", \"prop_2\", \"prop_3\"])      section_3c = SectionForTest(\"section_3\", attribute=[2, 1], prop=[\"prop_3\", \"prop_1\", \"prop_2\"])        def test_comparator_compare_method_call(self):          _config_1 = _Config._default_config()          _config_2 = _Config._default_config()            with mock.patch(              \"src.taipy.config._config_comparator._config_comparator._ConfigComparator._find_conflict_config\"          ) as mck:              Config._comparator._find_conflict_config(_config_1, _config_2)              mck.assert_called_once_with(_config_1, _config_2)        def test_comparator_without_diff(self):          _config_1 = _Config._default_config()          _config_2 = _Config._default_config()            config_diff = Config._comparator._find_conflict_config(_config_1, _config_2)          assert isinstance(config_diff, _ComparatorResult)          assert config_diff == {}        def test_comparator_with_updated_global_config(self):          _config_1 = _Config._default_config()          _config_1._global_config = GlobalAppConfig(foo=\"bar\")            _config_2 = _Config._default_config()          _config_2._global_config = GlobalAppConfig(foo=\"baz\", bar=\"foo\")            config_diff = Config._comparator._find_conflict_config(_config_1, _config_2)            assert config_diff.get(\"unconflicted_sections\") is None          assert config_diff.get(\"conflicted_sections\") is not None            conflicted_config_diff = config_diff[\"conflicted_sections\"]          assert len(conflicted_config_diff[\"modified_items\"]) == 1          assert conflicted_config_diff[\"modified_items\"][0] == (              (\"Global Configuration\", \"foo\", None),              (\"bar\", \"baz\"),          )          assert len(conflicted_config_diff[\"added_items\"]) == 1          assert conflicted_config_diff[\"added_items\"][0] == (              (\"Global Configuration\", \"bar\", None),              \"foo\",          )        def test_comparator_with_new_section(self):          _config_1 = _Config._default_config()            # The first \"section_name\" is added to the Config          _config_2 = _Config._default_config()          _config_2._sections[SectionForTest.name] = {\"section_1\": self.section_1}          config_diff = Config._comparator._find_conflict_config(_config_1, _config_2)            conflicted_config_diff = config_diff[\"conflicted_sections\"]          assert len(conflicted_config_diff[\"added_items\"]) == 1          assert conflicted_config_diff[\"added_items\"][0] == (              (\"section_name\", None, None),              {\"section_1\": {\"attribute\": \"attribute_1\", \"prop\": \"prop_1\"}},          )          assert conflicted_config_diff.get(\"modified_items\") is None          assert conflicted_config_diff.get(\"removed_items\") is None            # A new \"section_name\" is added to the Config          _config_3 = _Config._default_config()          _config_3._sections[SectionForTest.name] = {\"section_1\": self.section_1, \"section_2\": self.section_2}          config_diff = Config._comparator._find_conflict_config(_config_2, _config_3)            conflicted_config_diff = config_diff[\"conflicted_sections\"]          assert len(conflicted_config_diff[\"added_items\"]) == 1          assert conflicted_config_diff[\"added_items\"][0] == (              (\"section_name\", \"section_2\", None),              {\"attribute\": \"2:int\", \"prop\": \"prop_2\"},          )          assert conflicted_config_diff.get(\"modified_items\") is None          assert conflicted_config_diff.get(\"removed_items\") is None        def test_comparator_with_removed_section(self):          _config_1 = _Config._default_config()            # All \"section_name\" sections are removed from the Config          _config_2 = _Config._default_config()          _config_2._sections[SectionForTest.name] = {\"section_1\": self.section_1}          config_diff = Config._comparator._find_conflict_config(_config_2, _config_1)            conflicted_config_diff = config_diff[\"conflicted_sections\"]          assert len(conflicted_config_diff[\"removed_items\"]) == 1          assert conflicted_config_diff[\"removed_items\"][0] == (              (\"section_name\", None, None),              {\"section_1\": {\"attribute\": \"attribute_1\", \"prop\": \"prop_1\"}},          )          assert conflicted_config_diff.get(\"modified_items\") is None          assert conflicted_config_diff.get(\"added_items\") is None            # Section \"section_1\" is removed from the Config          _config_3 = _Config._default_config()          _config_3._sections[SectionForTest.name] = {\"section_1\": self.section_1, \"section_2\": self.section_2}          config_diff = Config._comparator._find_conflict_config(_config_3, _config_2)            conflicted_config_diff = config_diff[\"conflicted_sections\"]          assert len(conflicted_config_diff[\"removed_items\"]) == 1          assert conflicted_config_diff[\"removed_items\"][0] == (              (\"section_name\", \"section_2\", None),              {\"attribute\": \"2:int\", \"prop\": \"prop_2\"},          )          assert conflicted_config_diff.get(\"modified_items\") is None          assert conflicted_config_diff.get(\"added_items\") is None        def test_comparator_with_modified_section(self):          _config_1 = _Config._default_config()          _config_1._sections[SectionForTest.name] = {\"section_2\": self.section_2}            # All \"section_name\" sections are removed from the Config          _config_2 = _Config._default_config()          _config_2._sections[SectionForTest.name] = {\"section_2\": self.section_2b}          config_diff = Config._comparator._find_conflict_config(_config_1, _config_2)            conflicted_config_diff = config_diff[\"conflicted_sections\"]          assert len(conflicted_config_diff[\"modified_items\"]) == 2          assert conflicted_config_diff[\"modified_items\"][0] == (              (\"section_name\", \"section_2\", \"attribute\"),              (\"2:int\", \"attribute_2\"),          )          assert conflicted_config_diff[\"modified_items\"][1] == (              (\"section_name\", \"section_2\", \"prop\"),              (\"prop_2\", \"prop_2b\"),          )          assert conflicted_config_diff.get(\"removed_items\") is None          assert conflicted_config_diff.get(\"added_items\") is None        def test_comparator_with_modified_list_attribute(self):          _config_1 = _Config._default_config()          _config_1._sections[SectionForTest.name] = {\"section_3\": self.section_3}            # All \"section_name\" sections are removed from the Config          _config_2 = _Config._default_config()          _config_2._sections[SectionForTest.name] = {\"section_3\": self.section_3b}          config_diff = Config._comparator._find_conflict_config(_config_1, _config_2)            conflicted_config_diff = config_diff[\"conflicted_sections\"]          assert len(conflicted_config_diff[\"modified_items\"]) == 2          assert conflicted_config_diff[\"modified_items\"][0] == (              (\"section_name\", \"section_3\", \"prop\"),              ([\"prop_1\"], [\"prop_1\", \"prop_2\", \"prop_3\"]),          )          assert conflicted_config_diff[\"modified_items\"][1] == (              (\"section_name\", \"section_3\", \"attribute\"),              ([\"1:int\", \"2:int\", \"3:int\", \"4:int\"], [\"1:int\", \"2:int\"]),          )          assert conflicted_config_diff.get(\"removed_items\") is None          assert conflicted_config_diff.get(\"added_items\") is None        def test_comparator_with_different_order_list_attributes(self):          _config_1 = _Config._default_config()          _config_1._unique_sections          _config_1._sections[SectionForTest.name] = {\"section_3\": self.section_3b}            # Create _config_2 with different order of list attributes          _config_2 = _Config._default_config()          _config_2._sections[SectionForTest.name] = {\"section_3\": self.section_3c}          config_diff = Config._comparator._find_conflict_config(_config_1, _config_2)            # There should be no difference since the order of list attributes is ignored          assert config_diff == {}        def test_comparator_with_new_unique_section(self):          _config_1 = _Config._default_config()            _config_2 = _Config._default_config()          _config_2._unique_sections[UniqueSectionForTest.name] = self.unique_section_1          config_diff = Config._comparator._find_conflict_config(_config_1, _config_2)            conflicted_config_diff = config_diff[\"conflicted_sections\"]          assert len(conflicted_config_diff[\"added_items\"]) == 1          assert conflicted_config_diff[\"added_items\"][0] == (              (\"unique_section_name\", None, None),              {\"attribute\": \"unique_attribute_1\", \"prop\": \"unique_prop_1\"},          )          assert conflicted_config_diff.get(\"modified_items\") is None          assert conflicted_config_diff.get(\"removed_items\") is None        def test_comparator_with_removed_unique_section(self):          _config_1 = _Config._default_config()            _config_2 = _Config._default_config()          _config_2._unique_sections[UniqueSectionForTest.name] = self.unique_section_1          config_diff = Config._comparator._find_conflict_config(_config_2, _config_1)            conflicted_config_diff = config_diff[\"conflicted_sections\"]          assert len(conflicted_config_diff[\"removed_items\"]) == 1          assert conflicted_config_diff[\"removed_items\"][0] == (              (\"unique_section_name\", None, None),              {\"attribute\": \"unique_attribute_1\", \"prop\": \"unique_prop_1\"},          )          assert conflicted_config_diff.get(\"modified_items\") is None          assert conflicted_config_diff.get(\"added_items\") is None        def test_comparator_with_modified_unique_section(self):          _config_1 = _Config._default_config()          _config_1._unique_sections[UniqueSectionForTest.name] = self.unique_section_1            # All \"section_name\" sections are removed from the Config          _config_2 = _Config._default_config()          _config_2._unique_sections[UniqueSectionForTest.name] = self.unique_section_1b          config_diff = Config._comparator._find_conflict_config(_config_1, _config_2)            conflicted_config_diff = config_diff[\"conflicted_sections\"]          assert len(conflicted_config_diff[\"modified_items\"]) == 1          assert conflicted_config_diff[\"modified_items\"][0] == (              (\"unique_section_name\", \"prop\", None),              (\"unique_prop_1\", \"unique_prop_1b\"),          )          assert conflicted_config_diff.get(\"removed_items\") is None          assert conflicted_config_diff.get(\"added_items\") is None        def test_unconflicted_section_name_store_statically(self):          Config._comparator._add_unconflicted_section(\"section_name_1\")          assert Config._comparator._unconflicted_sections == {\"section_name_1\"}            Config._comparator._add_unconflicted_section(\"section_name_2\")          assert Config._comparator._unconflicted_sections == {\"section_name_1\", \"section_name_2\"}            Config._comparator._add_unconflicted_section(\"section_name_1\")          assert Config._comparator._unconflicted_sections == {\"section_name_1\", \"section_name_2\"}        def test_unconflicted_diff_is_stored_separated_from_conflicted_ones(self):          _config_1 = _Config._default_config()          _config_1._unique_sections[UniqueSectionForTest.name] = self.unique_section_1          _config_1._sections[SectionForTest.name] = {\"section_2\": self.section_2}            _config_2 = _Config._default_config()          _config_2._unique_sections[UniqueSectionForTest.name] = self.unique_section_1b          _config_2._sections[SectionForTest.name] = {\"section_2\": self.section_2b}            # Compare 2 Configuration          config_diff = Config._comparator._find_conflict_config(_config_1, _config_2)            assert config_diff.get(\"unconflicted_sections\") is None          assert config_diff.get(\"conflicted_sections\") is not None          assert len(config_diff[\"conflicted_sections\"][\"modified_items\"]) == 3            # Ignore any diff of \"section_name\" and compare          Config._comparator._add_unconflicted_section(\"section_name\")          config_diff = Config._comparator._find_conflict_config(_config_1, _config_2)          assert config_diff.get(\"unconflicted_sections\") is not None          assert len(config_diff[\"unconflicted_sections\"][\"modified_items\"]) == 2          assert config_diff.get(\"conflicted_sections\") is not None          assert len(config_diff[\"conflicted_sections\"][\"modified_items\"]) == 1            # Ignore any diff of Global Config and compare          Config._comparator._add_unconflicted_section([\"unique_section_name\"])          config_diff = Config._comparator._find_conflict_config(_config_1, _config_2)          assert config_diff.get(\"unconflicted_sections\") is not None          assert len(config_diff[\"unconflicted_sections\"][\"modified_items\"]) == 3          assert config_diff.get(\"conflicted_sections\") is None        def test_comparator_log_message(self, caplog):          _config_1 = _Config._default_config()          _config_1._unique_sections[UniqueSectionForTest.name] = self.unique_section_1          _config_1._sections[SectionForTest.name] = {\"section_2\": self.section_2}            _config_2 = _Config._default_config()          _config_2._unique_sections[UniqueSectionForTest.name] = self.unique_section_1b          _config_2._sections[SectionForTest.name] = {\"section_2\": self.section_2b}            # Ignore any diff of \"section_name\" and compare          Config._comparator._add_unconflicted_section(\"section_name\")          Config._comparator._find_conflict_config(_config_1, _config_2)            error_messages = caplog.text.strip().split(\"\\n\")          assert len(error_messages) == 5          assert all(              t in error_messages[0]              for t in [                  \"INFO\",                  \"There are non-conflicting changes between the current configuration and the current configuration:\",              ]          )          assert 'section_name \"section_2\" has attribute \"attribute\" modified: 2:int -> attribute_2' in error_messages[1]          assert 'section_name \"section_2\" has attribute \"prop\" modified: prop_2 -> prop_2b' in error_messages[2]          assert all(              t in error_messages[3]              for t in [                  \"ERROR\",                  \"The current configuration conflicts with the current configuration:\",              ]          )          assert 'unique_section_name \"prop\" was modified: unique_prop_1 -> unique_prop_1b' in error_messages[4]            caplog.clear()            Config._comparator._find_conflict_config(_config_1, _config_2, old_version_number=\"1.0\")            error_messages = caplog.text.strip().split(\"\\n\")          assert len(error_messages) == 5          assert all(              t in error_messages[0]              for t in [                  \"INFO\",                  \"There are non-conflicting changes between the configuration for version 1.0 and the current \"                  \"configuration:\",              ]          )          assert all(              t in error_messages[3]              for t in [                  \"ERROR\",                  \"The configuration for version 1.0 conflicts with the current configuration:\",              ]          )            caplog.clear()            Config._comparator._compare(              _config_1,              _config_2,              version_number_1=\"1.0\",              version_number_2=\"2.0\",          )            error_messages = caplog.text.strip().split(\"\\n\")          assert len(error_messages) == 3          assert all(              t in error_messages[0]              for t in [\"INFO\", \"Differences between version 1.0 Configuration and version 2.0 Configuration:\"]          )            caplog.clear() "}
{"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": "import os  from unittest import mock    import pytest    from src.taipy.config.config import Config  from src.taipy.config.exceptions.exceptions import InconsistentEnvVariableError, MissingEnvVariableError  from tests.config.utils.named_temporary_file import NamedTemporaryFile      def test_override_default_configuration_with_code_configuration():      assert not Config.global_config.root_folder == \"foo\"        assert len(Config.unique_sections) == 1      assert Config.unique_sections[\"unique_section_name\"] is not None      assert Config.unique_sections[\"unique_section_name\"].attribute == \"default_attribute\"      assert Config.unique_sections[\"unique_section_name\"].prop is None        assert len(Config.sections) == 1      assert len(Config.sections[\"section_name\"]) == 1      assert Config.sections[\"section_name\"] is not None      assert Config.sections[\"section_name\"][\"default\"].attribute == \"default_attribute\"        Config.configure_global_app(root_folder=\"foo\")      assert Config.global_config.root_folder == \"foo\"        Config.configure_unique_section_for_tests(\"foo\", prop=\"bar\")      assert len(Config.unique_sections) == 1      assert Config.unique_sections[\"unique_section_name\"] is not None      assert Config.unique_sections[\"unique_section_name\"].attribute == \"foo\"      assert Config.unique_sections[\"unique_section_name\"].prop == \"bar\"        Config.configure_section_for_tests(\"my_id\", \"baz\", prop=\"qux\")      assert len(Config.unique_sections) == 1      assert Config.sections[\"section_name\"] is not None      assert Config.sections[\"section_name\"][\"my_id\"].attribute == \"baz\"      assert Config.sections[\"section_name\"][\"my_id\"].prop == \"qux\"      def test_override_default_config_with_code_config_including_env_variable_values():      Config.configure_global_app()      assert Config.global_config.foo is None      Config.configure_global_app(foo=\"bar\")      assert Config.global_config.foo == \"bar\"        with mock.patch.dict(os.environ, {\"FOO\": \"foo\"}):          Config.configure_global_app(foo=\"ENV[FOO]\")          assert Config.global_config.foo == \"foo\"      def test_override_default_configuration_with_file_configuration():      tf = NamedTemporaryFile(          \"\"\"  [TAIPY]  foo = \"bar\"    \"\"\"      )      assert Config.global_config.foo is None        Config.load(tf.filename)        assert Config.global_config.foo == \"bar\"      def test_override_default_config_with_file_config_including_env_variable_values():      tf = NamedTemporaryFile(          \"\"\"  [TAIPY]  foo_attribute = \"ENV[FOO]:int\"  bar_attribute = \"ENV[BAR]:bool\"  \"\"\"      )      assert Config.global_config.foo_attribute is None      assert Config.global_config.bar_attribute is None        with mock.patch.dict(os.environ, {\"FOO\": \"foo\", \"BAR\": \"true\"}):          with pytest.raises(InconsistentEnvVariableError):              Config.load(tf.filename)              Config.global_config.foo_attribute        with mock.patch.dict(os.environ, {\"FOO\": \"5\"}):          with pytest.raises(MissingEnvVariableError):              Config.load(tf.filename)              Config.global_config.bar_attribute        with mock.patch.dict(os.environ, {\"FOO\": \"6\", \"BAR\": \"TRUe\"}):          Config.load(tf.filename)          assert Config.global_config.foo_attribute == 6          assert Config.global_config.bar_attribute      def test_code_configuration_does_not_override_file_configuration():      config_from_filename = NamedTemporaryFile(          \"\"\"  [TAIPY]  foo = 2      \"\"\"      )      Config.override(config_from_filename.filename)        Config.configure_global_app(foo=21)        assert Config.global_config.foo == 2  # From file config      def test_code_configuration_does_not_override_file_configuration_including_env_variable_values():      config_from_filename = NamedTemporaryFile(          \"\"\"  [TAIPY]  foo = 2      \"\"\"      )      Config.override(config_from_filename.filename)        with mock.patch.dict(os.environ, {\"FOO\": \"21\"}):          Config.configure_global_app(foo=\"ENV[FOO]\")          assert Config.global_config.foo == 2  # From file config      def test_file_configuration_overrides_code_configuration():      config_from_filename = NamedTemporaryFile(          \"\"\"  [TAIPY]  foo = 2      \"\"\"      )      Config.configure_global_app(foo=21)      Config.load(config_from_filename.filename)        assert Config.global_config.foo == 2  # From file config      def test_file_configuration_overrides_code_configuration_including_env_variable_values():      config_from_filename = NamedTemporaryFile(          \"\"\"  [TAIPY]  foo = \"ENV[FOO]:int\"      \"\"\"      )      Config.configure_global_app(foo=21)        with mock.patch.dict(os.environ, {\"FOO\": \"2\"}):          Config.load(config_from_filename.filename)          assert Config.global_config.foo == 2  # From file config      def test_override_default_configuration_with_multiple_configurations():      file_config = NamedTemporaryFile(          \"\"\"  [TAIPY]  foo = 10  bar = \"baz\"      \"\"\"      )      # Default config is applied      assert Config.global_config.foo is None      assert Config.global_config.bar is None        # Code config is applied      Config.configure_global_app(foo=\"bar\")      assert Config.global_config.foo == \"bar\"      assert Config.global_config.bar is None        # File config is applied      Config.load(file_config.filename)      assert Config.global_config.foo == 10      assert Config.global_config.bar == \"baz\"      def test_override_default_configuration_with_multiple_configurations_including_environment_variable_values():      file_config = NamedTemporaryFile(          \"\"\"  [TAIPY]  att = \"ENV[BAZ]\"      \"\"\"      )        with mock.patch.dict(os.environ, {\"FOO\": \"bar\", \"BAZ\": \"qux\"}):          # Default config is applied          assert Config.global_config.att is None            # Code config is applied          Config.configure_global_app(att=\"ENV[FOO]\")          assert Config.global_config.att == \"bar\"            # File config is applied          Config.load(file_config.filename)          assert Config.global_config.att == \"qux\" "}
{"text": "import pytest    from src.taipy.config import Config  from src.taipy.config.exceptions.exceptions import ConfigurationUpdateBlocked  from tests.config.utils.section_for_tests import SectionForTest  from tests.config.utils.unique_section_for_tests import UniqueSectionForTest      def test_unique_section_registration_and_usage():      assert Config.unique_sections is not None      assert Config.unique_sections[UniqueSectionForTest.name] is not None      assert Config.unique_sections[UniqueSectionForTest.name].attribute == \"default_attribute\"      assert Config.unique_sections[UniqueSectionForTest.name].prop is None        mySection = Config.configure_unique_section_for_tests(attribute=\"my_attribute\", prop=\"my_prop\")        assert Config.unique_sections is not None      assert Config.unique_sections[UniqueSectionForTest.name] is not None      assert mySection is not None      assert Config.unique_sections[UniqueSectionForTest.name].attribute == \"my_attribute\"      assert mySection.attribute == \"my_attribute\"      assert Config.unique_sections[UniqueSectionForTest.name].prop == \"my_prop\"      assert mySection.prop == \"my_prop\"        myNewSection = Config.configure_unique_section_for_tests(attribute=\"my_new_attribute\", prop=\"my_new_prop\")        assert Config.unique_sections is not None      assert Config.unique_sections[UniqueSectionForTest.name] is not None      assert myNewSection is not None      assert mySection is not None      assert Config.unique_sections[UniqueSectionForTest.name].attribute == \"my_new_attribute\"      assert myNewSection.attribute == \"my_new_attribute\"      assert mySection.attribute == \"my_new_attribute\"      assert Config.unique_sections[UniqueSectionForTest.name].prop == \"my_new_prop\"      assert myNewSection.prop == \"my_new_prop\"      assert mySection.prop == \"my_new_prop\"      def test_sections_exposed_as_attribute():      assert Config.unique_section_name.attribute == \"default_attribute\"      Config.configure_unique_section_for_tests(\"my_attribute\")      assert Config.unique_section_name.attribute == \"my_attribute\"        assert Config.section_name[\"default\"].attribute == \"default_attribute\"      Config.configure_section_for_tests(id=\"my_id\", attribute=\"my_attribute\")      assert Config.section_name[\"my_id\"].attribute == \"my_attribute\"      def test_section_registration_and_usage():      assert Config.sections is not None      assert len(Config.sections) == 1      assert Config.sections[SectionForTest.name] is not None      assert len(Config.sections[SectionForTest.name]) == 1      assert Config.sections[SectionForTest.name][\"default\"] is not None      assert Config.sections[SectionForTest.name][\"default\"].attribute == \"default_attribute\"      assert Config.sections[SectionForTest.name][\"default\"].prop == \"default_prop\"      assert Config.sections[SectionForTest.name][\"default\"].foo is None        myFirstSection = Config.configure_section_for_tests(id=\"first\", attribute=\"my_attribute\", prop=\"my_prop\", foo=\"bar\")      assert Config.sections is not None      assert len(Config.sections) == 1      assert Config.sections[SectionForTest.name] is not None      assert len(Config.sections[SectionForTest.name]) == 2      assert Config.sections[SectionForTest.name][\"default\"] is not None      assert Config.sections[SectionForTest.name][\"default\"].attribute == \"default_attribute\"      assert Config.sections[SectionForTest.name][\"default\"].prop == \"default_prop\"      assert Config.sections[SectionForTest.name][\"default\"].foo is None      assert Config.sections[SectionForTest.name][\"first\"] is not None      assert Config.sections[SectionForTest.name][\"first\"].attribute == \"my_attribute\"      assert Config.sections[SectionForTest.name][\"first\"].prop == \"my_prop\"      assert Config.sections[SectionForTest.name][\"first\"].foo == \"bar\"      assert myFirstSection.attribute == \"my_attribute\"      assert myFirstSection.prop == \"my_prop\"      assert myFirstSection.foo == \"bar\"        myNewSection = Config.configure_section_for_tests(id=\"second\", attribute=\"my_new_attribute\", prop=\"my_new_prop\")      assert Config.sections is not None      assert len(Config.sections) == 1      assert Config.sections[SectionForTest.name] is not None      assert len(Config.sections[SectionForTest.name]) == 3      assert Config.sections[SectionForTest.name][\"default\"] is not None      assert Config.sections[SectionForTest.name][\"default\"].attribute == \"default_attribute\"      assert Config.sections[SectionForTest.name][\"default\"].prop == \"default_prop\"      assert Config.sections[SectionForTest.name][\"default\"].foo is None      assert Config.sections[SectionForTest.name][\"first\"] is not None      assert Config.sections[SectionForTest.name][\"first\"].attribute == \"my_attribute\"      assert Config.sections[SectionForTest.name][\"first\"].prop == \"my_prop\"      assert Config.sections[SectionForTest.name][\"first\"].foo == \"bar\"      assert Config.sections[SectionForTest.name][\"second\"] is not None      assert Config.sections[SectionForTest.name][\"second\"].attribute == \"my_new_attribute\"      assert Config.sections[SectionForTest.name][\"second\"].prop == \"my_new_prop\"      assert Config.sections[SectionForTest.name][\"second\"].foo is None      assert myFirstSection.attribute == \"my_attribute\"      assert myFirstSection.prop == \"my_prop\"      assert myFirstSection.foo == \"bar\"      assert myNewSection.attribute == \"my_new_attribute\"      assert myNewSection.prop == \"my_new_prop\"      assert myNewSection.foo is None        my2ndSection = Config.configure_section_for_tests(id=\"second\", attribute=\"my_2nd_attribute\", prop=\"my_2nd_prop\")      assert Config.sections is not None      assert len(Config.sections) == 1      assert Config.sections[SectionForTest.name] is not None      assert len(Config.sections[SectionForTest.name]) == 3      assert Config.sections[SectionForTest.name][\"default\"] is not None      assert Config.sections[SectionForTest.name][\"default\"].attribute == \"default_attribute\"      assert Config.sections[SectionForTest.name][\"default\"].prop == \"default_prop\"      assert Config.sections[SectionForTest.name][\"default\"].foo is None      assert Config.sections[SectionForTest.name][\"first\"] is not None      assert Config.sections[SectionForTest.name][\"first\"].attribute == \"my_attribute\"      assert Config.sections[SectionForTest.name][\"first\"].prop == \"my_prop\"      assert Config.sections[SectionForTest.name][\"first\"].foo == \"bar\"      assert Config.sections[SectionForTest.name][\"second\"] is not None      assert Config.sections[SectionForTest.name][\"second\"].attribute == \"my_2nd_attribute\"      assert Config.sections[SectionForTest.name][\"second\"].prop == \"my_2nd_prop\"      assert Config.sections[SectionForTest.name][\"second\"].foo is None      assert myFirstSection.attribute == \"my_attribute\"      assert myFirstSection.prop == \"my_prop\"      assert myFirstSection.foo == \"bar\"      assert myNewSection.attribute == \"my_2nd_attribute\"      assert myNewSection.prop == \"my_2nd_prop\"      assert myNewSection.foo is None      assert my2ndSection.attribute == \"my_2nd_attribute\"      assert my2ndSection.prop == \"my_2nd_prop\"      assert my2ndSection.foo is None      def test_block_registration():      myUniqueSection = Config.configure_unique_section_for_tests(attribute=\"my_unique_attribute\", prop=\"my_unique_prop\")      mySection = Config.configure_section_for_tests(id=\"section_id\", attribute=\"my_attribute\", prop=\"my_prop\", foo=\"bar\")        Config.block_update()        with pytest.raises(ConfigurationUpdateBlocked):          Config.configure_unique_section_for_tests(attribute=\"my_new_unique_attribute\", prop=\"my_new_unique_prop\")        with pytest.raises(ConfigurationUpdateBlocked):          Config.configure_section_for_tests(id=\"new\", attribute=\"my_attribute\", prop=\"my_prop\", foo=\"bar\")        with pytest.raises(ConfigurationUpdateBlocked):          myUniqueSection.attribute = \"foo\"        with pytest.raises(ConfigurationUpdateBlocked):          myUniqueSection.properties = {\"foo\": \"bar\"}        # myUniqueSection stay the same      assert myUniqueSection.attribute == \"my_unique_attribute\"      assert myUniqueSection.properties == {\"prop\": \"my_unique_prop\"}        with pytest.raises(ConfigurationUpdateBlocked):          mySection.attribute = \"foo\"        with pytest.raises(ConfigurationUpdateBlocked):          mySection.properties = {\"foo\": \"foo\"}        # mySection stay the same      assert mySection.attribute == \"my_attribute\"      assert mySection.properties == {\"prop\": \"my_prop\", \"foo\": \"bar\", \"prop_int\": 0} "}
{"text": "import pytest    from src.taipy.config.config import Config  from src.taipy.config.section import Section  from tests.config.utils.named_temporary_file import NamedTemporaryFile  from tests.config.utils.section_for_tests import SectionForTest  from tests.config.utils.section_of_sections_list_for_tests import SectionOfSectionsListForTest      @pytest.fixture  def _init_list_section_for_test():      Config._register_default(SectionOfSectionsListForTest(Section._DEFAULT_KEY, [], prop=\"default_prop\", prop_int=0))      Config.configure_list_section_for_tests = SectionOfSectionsListForTest._configure      Config.list_section_name = Config.sections[SectionOfSectionsListForTest.name]      def test_applied_config_compilation_does_not_change_other_configs():      assert len(Config._default_config._unique_sections) == 1      assert Config._default_config._unique_sections[\"unique_section_name\"] is not None      assert Config._default_config._unique_sections[\"unique_section_name\"].attribute == \"default_attribute\"      assert Config._default_config._unique_sections[\"unique_section_name\"].prop is None      assert len(Config._python_config._unique_sections) == 0      assert len(Config._file_config._unique_sections) == 0      assert len(Config._env_file_config._unique_sections) == 0      assert len(Config._applied_config._unique_sections) == 1      assert Config._applied_config._unique_sections[\"unique_section_name\"] is not None      assert Config._applied_config._unique_sections[\"unique_section_name\"].attribute == \"default_attribute\"      assert Config._applied_config._unique_sections[\"unique_section_name\"].prop is None      assert len(Config.unique_sections) == 1      assert Config.unique_sections[\"unique_section_name\"] is not None      assert Config.unique_sections[\"unique_section_name\"].attribute == \"default_attribute\"      assert Config.unique_sections[\"unique_section_name\"].prop is None      assert (          Config._applied_config._unique_sections[\"unique_section_name\"]          is not Config._default_config._unique_sections[\"unique_section_name\"]      )        Config.configure_unique_section_for_tests(\"qwe\", prop=\"rty\")        assert len(Config._default_config._unique_sections) == 1      assert Config._default_config._unique_sections[\"unique_section_name\"] is not None      assert Config._default_config._unique_sections[\"unique_section_name\"].attribute == \"default_attribute\"      assert Config._default_config._unique_sections[\"unique_section_name\"].prop is None      assert len(Config._python_config._unique_sections) == 1      assert Config._python_config._unique_sections[\"unique_section_name\"] is not None      assert Config._python_config._unique_sections[\"unique_section_name\"].attribute == \"qwe\"      assert Config._python_config._unique_sections[\"unique_section_name\"].prop == \"rty\"      assert (          Config._python_config._unique_sections[\"unique_section_name\"]          != Config._default_config._unique_sections[\"unique_section_name\"]      )      assert len(Config._file_config._unique_sections) == 0      assert len(Config._env_file_config._unique_sections) == 0      assert len(Config._applied_config._unique_sections) == 1      assert Config._applied_config._unique_sections[\"unique_section_name\"] is not None      assert Config._applied_config._unique_sections[\"unique_section_name\"].attribute == \"qwe\"      assert Config._applied_config._unique_sections[\"unique_section_name\"].prop == \"rty\"      assert (          Config._python_config._unique_sections[\"unique_section_name\"]          != Config._applied_config._unique_sections[\"unique_section_name\"]      )      assert (          Config._default_config._unique_sections[\"unique_section_name\"]          != Config._applied_config._unique_sections[\"unique_section_name\"]      )      assert len(Config.unique_sections) == 1      assert Config.unique_sections[\"unique_section_name\"] is not None      assert Config.unique_sections[\"unique_section_name\"].attribute == \"qwe\"      assert Config.unique_sections[\"unique_section_name\"].prop == \"rty\"      def test_nested_section_instance_in_python(_init_list_section_for_test):      s1_cfg = Config.configure_section_for_tests(\"s1\", attribute=\"foo\")      s2_cfg = Config.configure_section_for_tests(\"s2\", attribute=\"bar\")      ss_cfg = Config.configure_list_section_for_tests(\"ss\", attribute=\"foo\", sections_list=[s1_cfg, s2_cfg])        s1_config_applied_instance = Config.section_name[\"s1\"]      s1_config_python_instance = Config._python_config._sections[SectionForTest.name][\"s1\"]        s2_config_applied_instance = Config.section_name[\"s2\"]      s2_config_python_instance = Config._python_config._sections[SectionForTest.name][\"s2\"]        assert ss_cfg.sections_list[0] is s1_config_applied_instance      assert ss_cfg.sections_list[0] is not s1_config_python_instance      assert ss_cfg.sections_list[1] is s2_config_applied_instance      assert ss_cfg.sections_list[1] is not s2_config_python_instance      def _configure_in_toml():      return NamedTemporaryFile(          content=\"\"\"  [TAIPY]    [section_name.s1]  attribute = \"foo\"    [section_name.s2]  attribute = \"bar\"    [list_section_name.ss]  sections_list = [ \"foo\", \"s1:SECTION\", \"s2:SECTION\"]      \"\"\"      )      def test_nested_section_instance_load_toml(_init_list_section_for_test):      toml_config = _configure_in_toml()      Config.load(toml_config)        s1_config_applied_instance = Config.section_name[\"s1\"]      s1_config_python_instance = Config._python_config._sections[SectionForTest.name][\"s1\"]        s2_config_applied_instance = Config.section_name[\"s2\"]      s2_config_python_instance = Config._python_config._sections[SectionForTest.name][\"s2\"]        ss_cfg = Config.list_section_name[\"ss\"]        assert ss_cfg.sections_list[0] == \"foo\"      assert ss_cfg.sections_list[1] is s1_config_applied_instance      assert ss_cfg.sections_list[1] is not s1_config_python_instance      assert ss_cfg.sections_list[2] is s2_config_applied_instance      assert ss_cfg.sections_list[2] is not s2_config_python_instance      def test_nested_section_instance_override_toml(_init_list_section_for_test):      toml_config = _configure_in_toml()      Config.override(toml_config)        s1_config_applied_instance = Config.section_name[\"s1\"]      s1_config_python_instance = Config._file_config._sections[SectionForTest.name][\"s1\"]        s2_config_applied_instance = Config.section_name[\"s2\"]      s2_config_python_instance = Config._file_config._sections[SectionForTest.name][\"s2\"]        ss_cfg = Config.list_section_name[\"ss\"]        assert ss_cfg.sections_list[0] == \"foo\"      assert ss_cfg.sections_list[1] is s1_config_applied_instance      assert ss_cfg.sections_list[1] is not s1_config_python_instance      assert ss_cfg.sections_list[2] is s2_config_applied_instance      assert ss_cfg.sections_list[1] is not s2_config_python_instance "}
{"text": "import datetime  import json  import os  from unittest import mock    from src.taipy.config import Config  from src.taipy.config._serializer._json_serializer import _JsonSerializer  from src.taipy.config.common.frequency import Frequency  from src.taipy.config.common.scope import Scope  from tests.config.utils.named_temporary_file import NamedTemporaryFile  from tests.config.utils.section_for_tests import SectionForTest  from tests.config.utils.unique_section_for_tests import UniqueSectionForTest      def add(a, b):      return a + b      class CustomClass:      a = None      b = None      class CustomEncoder(json.JSONEncoder):      def default(self, o):          if isinstance(o, datetime):              result = {\"__type__\": \"Datetime\", \"__value__\": o.isoformat()}          else:              result = json.JSONEncoder.default(self, o)          return result      class CustomDecoder(json.JSONDecoder):      def __init__(self, *args, **kwargs):          json.JSONDecoder.__init__(self, object_hook=self.object_hook, *args, **kwargs)        def object_hook(self, source):          if source.get(\"__type__\") == \"Datetime\":              return datetime.fromisoformat(source.get(\"__value__\"))          else:              return source      def test_write_toml_configuration_file():      expected_toml_config = \"\"\"  [TAIPY]    [unique_section_name]  attribute = \"my_attribute\"  prop = \"my_prop\"  prop_int = \"1:int\"  prop_bool = \"False:bool\"  prop_list = [ \"p1\", \"1991-01-01T00:00:00:datetime\", \"1d0h0m0s:timedelta\",]  prop_scope = \"SCENARIO:SCOPE\"  prop_freq = \"QUARTERLY:FREQUENCY\"  baz = \"ENV[QUX]\"  quux = \"ENV[QUUZ]:bool\"  corge = [ \"grault\", \"ENV[GARPLY]\", \"ENV[WALDO]:int\", \"3.0:float\",]    [section_name.default]  attribute = \"default_attribute\"  prop = \"default_prop\"  prop_int = \"0:int\"    [section_name.my_id]  attribute = \"my_attribute\"  prop = \"default_prop\"  prop_int = \"1:int\"  prop_bool = \"False:bool\"  prop_list = [ \"unique_section_name:SECTION\",]  prop_scope = \"SCENARIO\"  baz = \"ENV[QUX]\"      \"\"\".strip()      tf = NamedTemporaryFile()      with mock.patch.dict(          os.environ, {\"FOO\": \"in_memory\", \"QUX\": \"qux\", \"QUUZ\": \"true\", \"GARPLY\": \"garply\", \"WALDO\": \"17\"}      ):          unique_section = Config.configure_unique_section_for_tests(              attribute=\"my_attribute\",              prop=\"my_prop\",              prop_int=1,              prop_bool=False,              prop_list=[\"p1\", datetime.datetime(1991, 1, 1), datetime.timedelta(days=1)],              prop_scope=Scope.SCENARIO,              prop_freq=Frequency.QUARTERLY,              baz=\"ENV[QUX]\",              quux=\"ENV[QUUZ]:bool\",              corge=(\"grault\", \"ENV[GARPLY]\", \"ENV[WALDO]:int\", 3.0),          )          Config.configure_section_for_tests(              \"my_id\",              \"my_attribute\",              prop_int=1,              prop_bool=False,              prop_list=[unique_section],              prop_scope=\"SCENARIO\",              baz=\"ENV[QUX]\",          )            Config.backup(tf.filename)          actual_config = tf.read().strip()          assert actual_config == expected_toml_config      def test_read_toml_configuration_file():      toml_config = \"\"\"  [TAIPY]  foo = \"bar\"    [unique_section_name]  attribute = \"my_attribute\"  prop = \"my_prop\"  prop_int = \"1:int\"  prop_bool = \"False:bool\"  prop_list = [ \"p1\", \"1991-01-01T00:00:00:datetime\", \"1d0h0m0s:timedelta\",]  prop_scope = \"SCENARIO:SCOPE\"  prop_freq = \"QUARTERLY:FREQUENCY\"  baz = \"ENV[QUX]\"  quux = \"ENV[QUUZ]:bool\"  corge = [ \"grault\", \"ENV[GARPLY]\", \"ENV[WALDO]:int\", \"3.0:float\",]    [TAIPY.custom_properties]  bar = \"baz\"    [section_name.default]  attribute = \"default_attribute\"  prop = \"default_prop\"  prop_int = \"0:int\"    [section_name.my_id]  attribute = \"my_attribute\"  prop = \"default_prop\"  prop_int = \"1:int\"  prop_bool = \"False:bool\"  prop_list = [ \"unique_section_name\", \"section_name.my_id\",]  prop_scope = \"SCENARIO:SCOPE\"  baz = \"ENV[QUX]\"      \"\"\".strip()      tf = NamedTemporaryFile(toml_config)      with mock.patch.dict(          os.environ, {\"FOO\": \"in_memory\", \"QUX\": \"qux\", \"QUUZ\": \"true\", \"GARPLY\": \"garply\", \"WALDO\": \"17\"}      ):          Config.override(tf.filename)            assert Config.global_config.foo == \"bar\"          assert Config.global_config.custom_properties.get(\"bar\") == \"baz\"            assert Config.unique_sections is not None          assert Config.unique_sections[UniqueSectionForTest.name] is not None          assert Config.unique_sections[UniqueSectionForTest.name].attribute == \"my_attribute\"          assert Config.unique_sections[UniqueSectionForTest.name].prop == \"my_prop\"          assert Config.unique_sections[UniqueSectionForTest.name].prop_int == 1          assert Config.unique_sections[UniqueSectionForTest.name].prop_bool is False          assert Config.unique_sections[UniqueSectionForTest.name].prop_list == [              \"p1\",              datetime.datetime(1991, 1, 1),              datetime.timedelta(days=1),          ]          assert Config.unique_sections[UniqueSectionForTest.name].prop_scope == Scope.SCENARIO          assert Config.unique_sections[UniqueSectionForTest.name].prop_freq == Frequency.QUARTERLY          assert Config.unique_sections[UniqueSectionForTest.name].baz == \"qux\"          assert Config.unique_sections[UniqueSectionForTest.name].quux is True          assert Config.unique_sections[UniqueSectionForTest.name].corge == [              \"grault\",              \"garply\",              17,              3.0,          ]            assert Config.sections is not None          assert len(Config.sections) == 1          assert Config.sections[SectionForTest.name] is not None          assert len(Config.sections[SectionForTest.name]) == 2          assert Config.sections[SectionForTest.name][\"default\"] is not None          assert Config.sections[SectionForTest.name][\"default\"].attribute == \"default_attribute\"          assert Config.sections[SectionForTest.name][\"default\"].prop == \"default_prop\"          assert Config.sections[SectionForTest.name][\"default\"].prop_int == 0          assert Config.sections[SectionForTest.name][\"my_id\"] is not None          assert Config.sections[SectionForTest.name][\"my_id\"].attribute == \"my_attribute\"          assert Config.sections[SectionForTest.name][\"my_id\"].prop == \"default_prop\"          assert Config.sections[SectionForTest.name][\"my_id\"].prop_int == 1          assert Config.sections[SectionForTest.name][\"my_id\"].prop_bool is False          assert Config.sections[SectionForTest.name][\"my_id\"].prop_list == [\"unique_section_name\", \"section_name.my_id\"]          assert Config.sections[SectionForTest.name][\"my_id\"].prop_scope == Scope.SCENARIO          assert Config.sections[SectionForTest.name][\"my_id\"].baz == \"qux\"            tf2 = NamedTemporaryFile()          Config.backup(tf2.filename)          actual_config_2 = tf2.read().strip()          assert actual_config_2 == toml_config      def test_read_write_toml_configuration_file_with_function_and_class():      expected_toml_config = \"\"\"  [TAIPY]    [unique_section_name]  attribute = \"my_attribute\"  prop = \"my_prop\"  prop_list = [ \"tests.config.test_section_serialization.CustomEncoder:class\", \\  \"tests.config.test_section_serialization.CustomDecoder:class\",]    [section_name.default]  attribute = \"default_attribute\"  prop = \"default_prop\"  prop_int = \"0:int\"    [section_name.my_id]  attribute = \"my_attribute\"  prop = \"default_prop\"  prop_int = \"0:int\"  prop_fct_list = [ \"tests.config.test_section_serialization.add:function\",]  prop_class_list = [ \"tests.config.test_section_serialization.CustomClass:class\",]    [section_name.my_id_2]  attribute = \"my_attribute_2\"  prop = \"default_prop\"  prop_int = \"0:int\"  prop_fct_list = [ \"builtins.print:function\", \"builtins.pow:function\",]      \"\"\".strip()        tf = NamedTemporaryFile()      Config.configure_unique_section_for_tests(          attribute=\"my_attribute\",          prop=\"my_prop\",          prop_list=[CustomEncoder, CustomDecoder],      )      Config.configure_section_for_tests(          \"my_id\",          \"my_attribute\",          prop_fct_list=[add],          prop_class_list=[CustomClass],      )        Config.configure_section_for_tests(          \"my_id_2\",          \"my_attribute_2\",          prop_fct_list=[print, pow],      )        Config.backup(tf.filename)      actual_exported_toml = tf.read().strip()      assert actual_exported_toml == expected_toml_config        Config.override(tf.filename)      tf2 = NamedTemporaryFile()      Config.backup(tf2.filename)        actual_exported_toml_2 = tf2.read().strip()      assert actual_exported_toml_2 == expected_toml_config      def test_write_json_configuration_file():      expected_json_config = \"\"\"  {  \"TAIPY\": {},  \"unique_section_name\": {  \"attribute\": \"my_attribute\",  \"prop\": \"my_prop\",  \"prop_int\": \"1:int\",  \"prop_bool\": \"False:bool\",  \"prop_list\": [  \"p1\",  \"1991-01-01T00:00:00:datetime\",  \"1d0h0m0s:timedelta\"  ],  \"prop_scope\": \"SCENARIO:SCOPE\",  \"prop_freq\": \"QUARTERLY:FREQUENCY\"  },  \"section_name\": {  \"default\": {  \"attribute\": \"default_attribute\",  \"prop\": \"default_prop\",  \"prop_int\": \"0:int\"  },  \"my_id\": {  \"attribute\": \"my_attribute\",  \"prop\": \"default_prop\",  \"prop_int\": \"1:int\",  \"prop_bool\": \"False:bool\",  \"prop_list\": [  \"unique_section_name:SECTION\"  ],  \"prop_scope\": \"SCENARIO\",  \"baz\": \"ENV[QUX]\"  }  }  }      \"\"\".strip()      tf = NamedTemporaryFile()      Config._serializer = _JsonSerializer()        unique_section = Config.configure_unique_section_for_tests(          attribute=\"my_attribute\",          prop=\"my_prop\",          prop_int=1,          prop_bool=False,          prop_list=[\"p1\", datetime.datetime(1991, 1, 1), datetime.timedelta(days=1)],          prop_scope=Scope.SCENARIO,          prop_freq=Frequency.QUARTERLY,      )      Config.configure_section_for_tests(          \"my_id\",          \"my_attribute\",          prop_int=1,          prop_bool=False,          prop_list=[unique_section],          prop_scope=\"SCENARIO\",          baz=\"ENV[QUX]\",      )      Config.backup(tf.filename)      actual_config = tf.read()      assert actual_config == expected_json_config      def test_read_json_configuration_file():      json_config = \"\"\"  {  \"TAIPY\": {  \"root_folder\": \"./taipy/\",  \"storage_folder\": \".data/\",  \"repository_type\": \"filesystem\"  },  \"unique_section_name\": {  \"attribute\": \"my_attribute\",  \"prop\": \"my_prop\",  \"prop_int\": \"1:int\",  \"prop_bool\": \"False:bool\",  \"prop_list\": [  \"p1\",  \"1991-01-01T00:00:00:datetime\",  \"1d0h0m0s:timedelta\"  ],  \"prop_scope\": \"SCENARIO:SCOPE\",  \"prop_freq\": \"QUARTERLY:FREQUENCY\"  },  \"section_name\": {  \"default\": {  \"attribute\": \"default_attribute\",  \"prop\": \"default_prop\",  \"prop_int\": \"0:int\"  },  \"my_id\": {  \"attribute\": \"my_attribute\",  \"prop\": \"default_prop\",  \"prop_int\": \"1:int\",  \"prop_bool\": \"False:bool\",  \"prop_list\": [  \"unique_section_name\"  ],  \"prop_scope\": \"SCENARIO\"  }  }  }      \"\"\".strip()      Config._serializer = _JsonSerializer()      tf = NamedTemporaryFile(json_config)        Config.override(tf.filename)        assert Config.unique_sections is not None      assert Config.unique_sections[UniqueSectionForTest.name] is not None      assert Config.unique_sections[UniqueSectionForTest.name].attribute == \"my_attribute\"      assert Config.unique_sections[UniqueSectionForTest.name].prop == \"my_prop\"      assert Config.unique_sections[UniqueSectionForTest.name].prop_int == 1      assert Config.unique_sections[UniqueSectionForTest.name].prop_bool is False      assert Config.unique_sections[UniqueSectionForTest.name].prop_list == [          \"p1\",          datetime.datetime(1991, 1, 1),          datetime.timedelta(days=1),      ]      assert Config.unique_sections[UniqueSectionForTest.name].prop_scope == Scope.SCENARIO      assert Config.unique_sections[UniqueSectionForTest.name].prop_freq == Frequency.QUARTERLY        assert Config.sections is not None      assert len(Config.sections) == 1      assert Config.sections[SectionForTest.name] is not None      assert len(Config.sections[SectionForTest.name]) == 2      assert Config.sections[SectionForTest.name][\"default\"] is not None      assert Config.sections[SectionForTest.name][\"default\"].attribute == \"default_attribute\"      assert Config.sections[SectionForTest.name][\"default\"].prop == \"default_prop\"      assert Config.sections[SectionForTest.name][\"default\"].prop_int == 0      assert Config.sections[SectionForTest.name][\"my_id\"] is not None      assert Config.sections[SectionForTest.name][\"my_id\"].attribute == \"my_attribute\"      assert Config.sections[SectionForTest.name][\"my_id\"].prop == \"default_prop\"      assert Config.sections[SectionForTest.name][\"my_id\"].prop_int == 1      assert Config.sections[SectionForTest.name][\"my_id\"].prop_bool is False      assert Config.sections[SectionForTest.name][\"my_id\"].prop_list == [\"unique_section_name\"]        tf2 = NamedTemporaryFile()      Config.backup(tf2.filename)      actual_config_2 = tf2.read().strip()      assert actual_config_2 == json_config      def test_read_write_json_configuration_file_with_function_and_class():      expected_json_config = \"\"\"  {  \"TAIPY\": {},  \"unique_section_name\": {  \"attribute\": \"my_attribute\",  \"prop\": \"my_prop\",  \"prop_list\": [  \"tests.config.test_section_serialization.CustomEncoder:class\",  \"tests.config.test_section_serialization.CustomDecoder:class\"  ]  },  \"section_name\": {  \"default\": {  \"attribute\": \"default_attribute\",  \"prop\": \"default_prop\",  \"prop_int\": \"0:int\"  },  \"my_id\": {  \"attribute\": \"my_attribute\",  \"prop\": \"default_prop\",  \"prop_int\": \"0:int\",  \"prop_fct_list\": [  \"tests.config.test_section_serialization.add:function\"  ],  \"prop_class_list\": [  \"tests.config.test_section_serialization.CustomClass:class\"  ]  },  \"my_id_2\": {  \"attribute\": \"my_attribute_2\",  \"prop\": \"default_prop\",  \"prop_int\": \"0:int\",  \"prop_fct_list\": [  \"builtins.print:function\",  \"builtins.pow:function\"  ]  }  }  }      \"\"\".strip()        Config._serializer = _JsonSerializer()      tf = NamedTemporaryFile()      Config.configure_unique_section_for_tests(          attribute=\"my_attribute\",          prop=\"my_prop\",          prop_list=[CustomEncoder, CustomDecoder],      )      Config.configure_section_for_tests(          \"my_id\",          \"my_attribute\",          prop_fct_list=[add],          prop_class_list=[CustomClass],      )      Config.configure_section_for_tests(          \"my_id_2\",          \"my_attribute_2\",          prop_fct_list=[print, pow],      )        Config.backup(tf.filename)      actual_exported_json = tf.read().strip()      assert actual_exported_json == expected_json_config        Config.override(tf.filename)      tf2 = NamedTemporaryFile()      Config.backup(tf2.filename)        actual_exported_json_2 = tf2.read().strip()      assert actual_exported_json_2 == expected_json_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 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 datetime  import os  from unittest import mock    import pytest    from src.taipy.config.common._template_handler import _TemplateHandler  from src.taipy.config.common.frequency import Frequency  from src.taipy.config.common.scope import Scope  from src.taipy.config.exceptions.exceptions import InconsistentEnvVariableError      def test_replace_if_template():      assert_does_not_change(\"123\")      assert_does_not_change(\"foo\")      assert_does_not_change(\"_foo\")      assert_does_not_change(\"_foo_\")      assert_does_not_change(\"foo_\")      assert_does_not_change(\"foo\")      assert_does_not_change(\"foo_1\")      assert_does_not_change(\"1foo_1\")      assert_does_not_change(\"env(foo)\")      assert_does_not_change(\"env<foo>\")      assert_does_not_change(\"env[foo]\")      assert_does_not_change(\"Env[foo]\")      assert_does_not_change(\"ENV[1foo]\")        assert_does_not_change(\"123:bool\")      assert_does_not_change(\"foo:bool\")      assert_does_not_change(\"_foo:bool\")      assert_does_not_change(\"_foo_:bool\")      assert_does_not_change(\"foo_:bool\")      assert_does_not_change(\"foo:bool\")      assert_does_not_change(\"foo_1:bool\")      assert_does_not_change(\"1foo_1:bool\")      assert_does_not_change(\"env(foo):bool\")      assert_does_not_change(\"env<foo>:bool\")      assert_does_not_change(\"env[foo]:bool\")      assert_does_not_change(\"Env[foo]:bool\")      assert_does_not_change(\"ENV[1foo]:bool\")        assert_does_not_change(\"ENV[foo]:\")      assert_does_not_change(\"ENV[_foo]:\")      assert_does_not_change(\"ENV[foo_]:\")      assert_does_not_change(\"ENV[foo0]:\")      assert_does_not_change(\"ENV[foo_0]:\")      assert_does_not_change(\"ENV[_foo_0]:\")        assert_does_not_change(\"ENV[foo]:foo\")      assert_does_not_change(\"ENV[_foo]:foo\")      assert_does_not_change(\"ENV[foo_]:foo\")      assert_does_not_change(\"ENV[foo0]:foo\")      assert_does_not_change(\"ENV[foo_0]:foo\")      assert_does_not_change(\"ENV[_foo_0]:foo\")        assert_does_replace(\"ENV[foo]\", \"foo\", \"VALUE\", str)      assert_does_replace(\"ENV[_foo]\", \"_foo\", \"VALUE\", str)      assert_does_replace(\"ENV[foo_]\", \"foo_\", \"VALUE\", str)      assert_does_replace(\"ENV[foo0]\", \"foo0\", \"VALUE\", str)      assert_does_replace(\"ENV[foo_0]\", \"foo_0\", \"VALUE\", str)      assert_does_replace(\"ENV[_foo_0]\", \"_foo_0\", \"VALUE\", str)        assert_does_replace(\"ENV[foo]:str\", \"foo\", \"VALUE\", str)      assert_does_replace(\"ENV[_foo]:str\", \"_foo\", \"VALUE\", str)      assert_does_replace(\"ENV[foo_]:str\", \"foo_\", \"VALUE\", str)      assert_does_replace(\"ENV[foo0]:str\", \"foo0\", \"VALUE\", str)      assert_does_replace(\"ENV[foo_0]:str\", \"foo_0\", \"VALUE\", str)      assert_does_replace(\"ENV[_foo_0]:str\", \"_foo_0\", \"VALUE\", str)        assert_does_replace(\"ENV[foo]:int\", \"foo\", \"1\", int)      assert_does_replace(\"ENV[_foo]:int\", \"_foo\", \"1\", int)      assert_does_replace(\"ENV[foo_]:int\", \"foo_\", \"1\", int)      assert_does_replace(\"ENV[foo0]:int\", \"foo0\", \"1\", int)      assert_does_replace(\"ENV[foo_0]:int\", \"foo_0\", \"1\", int)      assert_does_replace(\"ENV[_foo_0]:int\", \"_foo_0\", \"1\", int)        assert_does_replace(\"ENV[foo]:float\", \"foo\", \"1.\", float)      assert_does_replace(\"ENV[_foo]:float\", \"_foo\", \"1.\", float)      assert_does_replace(\"ENV[foo_]:float\", \"foo_\", \"1.\", float)      assert_does_replace(\"ENV[foo0]:float\", \"foo0\", \"1.\", float)      assert_does_replace(\"ENV[foo_0]:float\", \"foo_0\", \"1.\", float)      assert_does_replace(\"ENV[_foo_0]:float\", \"_foo_0\", \"1.\", float)        assert_does_replace(\"ENV[foo]:bool\", \"foo\", \"True\", bool)      assert_does_replace(\"ENV[_foo]:bool\", \"_foo\", \"True\", bool)      assert_does_replace(\"ENV[foo_]:bool\", \"foo_\", \"True\", bool)      assert_does_replace(\"ENV[foo0]:bool\", \"foo0\", \"True\", bool)      assert_does_replace(\"ENV[foo_0]:bool\", \"foo_0\", \"True\", bool)      assert_does_replace(\"ENV[_foo_0]:bool\", \"_foo_0\", \"True\", bool)      def assert_does_replace(template, env_variable_name, replaced_by, as_type):      with mock.patch.dict(os.environ, {env_variable_name: replaced_by}):          tpl = _TemplateHandler()          assert tpl._replace_templates(template) == as_type(replaced_by)      def assert_does_not_change(template):      tpl = _TemplateHandler()      assert tpl._replace_templates(template) == template      def test_replace_tuple_list_dict():      with mock.patch.dict(os.environ, {\"FOO\": \"true\", \"BAR\": \"3\", \"BAZ\": \"qux\"}):          tpl = _TemplateHandler()          now = datetime.datetime.now()          actual = tpl._replace_templates((\"ENV[FOO]:bool\", now, \"ENV[BAR]:int\", \"ENV[BAZ]\", \"quz\"))          assert actual == (True, now, 3, \"qux\", \"quz\")          actual = tpl._replace_templates((\"ENV[FOO]:bool\", now, \"ENV[BAR]:int\", \"ENV[BAZ]\", \"quz\"))          assert actual == (True, now, 3, \"qux\", \"quz\")      def test_to_bool():      with pytest.raises(InconsistentEnvVariableError):          _TemplateHandler._to_bool(\"okhds\")      with pytest.raises(InconsistentEnvVariableError):          _TemplateHandler._to_bool(\"no\")      with pytest.raises(InconsistentEnvVariableError):          _TemplateHandler._to_bool(\"tru\")      with pytest.raises(InconsistentEnvVariableError):          _TemplateHandler._to_bool(\"tru_e\")        assert _TemplateHandler._to_bool(\"true\")      assert _TemplateHandler._to_bool(\"True\")      assert _TemplateHandler._to_bool(\"TRUE\")      assert _TemplateHandler._to_bool(\"TruE\")      assert _TemplateHandler._to_bool(\"TrUE\")        assert not _TemplateHandler._to_bool(\"false\")      assert not _TemplateHandler._to_bool(\"False\")      assert not _TemplateHandler._to_bool(\"FALSE\")      assert not _TemplateHandler._to_bool(\"FalSE\")      assert not _TemplateHandler._to_bool(\"FalSe\")      def test_to_int():      with pytest.raises(InconsistentEnvVariableError):          _TemplateHandler._to_int(\"okhds\")      with pytest.raises(InconsistentEnvVariableError):          _TemplateHandler._to_int(\"_45\")      with pytest.raises(InconsistentEnvVariableError):          _TemplateHandler._to_int(\"12.5\")        assert 12 == _TemplateHandler._to_int(\"12\")      assert 0 == _TemplateHandler._to_int(\"0\")      assert -2 == _TemplateHandler._to_int(\"-2\")      assert 156165 == _TemplateHandler._to_int(\"156165\")      def test_to_float():      with pytest.raises(InconsistentEnvVariableError):          _TemplateHandler._to_float(\"okhds\")      with pytest.raises(InconsistentEnvVariableError):          _TemplateHandler._to_float(\"_45\")        assert 12.5 == _TemplateHandler._to_float(\"12.5\")      assert 2.0 == _TemplateHandler._to_float(\"2\")      assert 0.0 == _TemplateHandler._to_float(\"0\")      assert -2.1 == _TemplateHandler._to_float(\"-2.1\")      assert 156165.3 == _TemplateHandler._to_float(\"156165.3\")      def test_to_scope():      with pytest.raises(InconsistentEnvVariableError):          _TemplateHandler._to_scope(\"okhds\")      with pytest.raises(InconsistentEnvVariableError):          _TemplateHandler._to_scope(\"plop\")        assert Scope.GLOBAL == _TemplateHandler._to_scope(\"global\")      assert Scope.GLOBAL == _TemplateHandler._to_scope(\"GLOBAL\")      assert Scope.SCENARIO == _TemplateHandler._to_scope(\"SCENARIO\")      assert Scope.CYCLE == _TemplateHandler._to_scope(\"cycle\")      def test_to_frequency():      with pytest.raises(InconsistentEnvVariableError):          _TemplateHandler._to_frequency(\"okhds\")      with pytest.raises(InconsistentEnvVariableError):          _TemplateHandler._to_frequency(\"plop\")        assert Frequency.DAILY == _TemplateHandler._to_frequency(\"DAILY\")      assert Frequency.DAILY == _TemplateHandler._to_frequency(\"Daily\")      assert Frequency.WEEKLY == _TemplateHandler._to_frequency(\"weekly\")      assert Frequency.WEEKLY == _TemplateHandler._to_frequency(\"WEEKLY\")      assert Frequency.MONTHLY == _TemplateHandler._to_frequency(\"Monthly\")      assert Frequency.MONTHLY == _TemplateHandler._to_frequency(\"MONThLY\")      assert Frequency.QUARTERLY == _TemplateHandler._to_frequency(\"QuaRtERlY\")      assert Frequency.YEARLY == _TemplateHandler._to_frequency(\"Yearly\") "}
{"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  import json  import logging  import socket  import time  import typing as t  import warnings  from types import FrameType    from taipy.gui import Gui, Html, Markdown  from taipy.gui._renderers.builder import _Builder  from taipy.gui._warnings import TaipyGuiWarning  from taipy.gui.utils._variable_directory import _reset_name_map  from taipy.gui.utils.expr_var_name import _reset_expr_var_name      class Helpers:      @staticmethod      def test_cleanup():          _Builder._reset_key()          _reset_name_map()          _reset_expr_var_name()        @staticmethod      def test_control_md(gui: Gui, md_string: str, expected_values: t.Union[str, t.List]):          gui.add_page(\"test\", Markdown(md_string, frame=None))          Helpers._test_control(gui, expected_values)        @staticmethod      def test_control_html(gui: Gui, html_string: str, expected_values: t.Union[str, t.List]):          gui.add_page(\"test\", Html(html_string, frame=None))          Helpers._test_control(gui, expected_values)        @staticmethod      def test_control_builder(gui: Gui, builder_page, expected_values: t.Union[str, t.List]):          gui.add_page(\"test\", builder_page)          Helpers._test_control(gui, expected_values)        @staticmethod      def _test_control(gui: Gui, expected_values: t.Union[str, t.List]):          gui.run(run_server=False, single_client=True, stylekit=False)          client = gui._server.test_client()          response = client.get(\"/taipy-jsx/test\")          assert response.status_code == 200, f\"response.status_code {response.status_code} != 200\"          response_data = json.loads(response.get_data().decode(\"utf-8\", \"ignore\"))          assert isinstance(response_data, t.Dict), \"response_data is not Dict\"          assert \"jsx\" in response_data, \"jsx not in response_data\"          jsx = response_data[\"jsx\"]          logging.getLogger().debug(jsx)          if isinstance(expected_values, str):              assert jsx == expected_values, f\"{jsx} != {expected_values}\"          elif isinstance(expected_values, list):              for expected_value in expected_values:                  assert expected_value in jsx, f\"{expected_value} not in {jsx}\"        @staticmethod      def assert_outward_ws_message(received_message, type, varname, value):          assert isinstance(received_message, dict)          assert \"name\" in received_message and received_message[\"name\"] == \"message\"          assert \"args\" in received_message          args = received_message[\"args\"]          assert \"type\" in args and args[\"type\"] == type          assert \"payload\" in args          payload = args[\"payload\"][0]          assert \"name\" in payload and varname in payload[\"name\"]          assert \"payload\" in payload and \"value\" in payload[\"payload\"] and payload[\"payload\"][\"value\"] == value          logging.getLogger().debug(payload[\"payload\"][\"value\"])        @staticmethod      def assert_outward_simple_ws_message(received_message, type, varname, value):          assert isinstance(received_message, dict)          assert \"name\" in received_message and received_message[\"name\"] == \"message\"          assert \"args\" in received_message          args = received_message[\"args\"]          assert \"type\" in args and args[\"type\"] == type          assert \"name\" in args and args[\"name\"] == varname          assert \"payload\" in args          payload = args[\"payload\"]          assert \"value\" in payload and payload[\"value\"] == value          logging.getLogger().debug(payload[\"value\"])        @staticmethod      def assert_outward_ws_simple_message(received_message, aType, values):          assert isinstance(received_message, dict)          assert \"name\" in received_message and received_message[\"name\"] == \"message\"          assert \"args\" in received_message          args = received_message[\"args\"]          assert \"type\" in args and args[\"type\"] == aType          for k, v in values.items():              assert k in args and args[k] == v              logging.getLogger().debug(f\"{k}: {args[k]}\")        @staticmethod      def assert_outward_ws_multiple_message(received_message, type, array_len: int):          assert isinstance(received_message, dict)          assert \"name\" in received_message and received_message[\"name\"] == \"message\"          assert \"args\" in received_message          args = received_message[\"args\"]          assert \"type\" in args and args[\"type\"] == type          assert \"payload\" in args          payload = args[\"payload\"]          assert isinstance(payload, list)          assert len(payload) == array_len          logging.getLogger().debug(payload)        @staticmethod      def create_scope_and_get_sid(gui: Gui) -> str:          sid = \"test\"          gui._bindings()._get_or_create_scope(sid)          return sid        @staticmethod      def port_check():          s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)          s.settimeout(1)          if s.connect_ex((\"127.0.0.1\", 5000)) == 0:              s.close()              return True          else:              s.close()              return False        @staticmethod      def run_e2e(gui, **kwargs):          kwargs[\"run_in_thread\"] = True          kwargs[\"single_client\"] = True          kwargs[\"run_browser\"] = False          kwargs[\"stylekit\"] = kwargs.get(\"stylekit\", False)          with warnings.catch_warnings(record=True):              gui.run(**kwargs)          while not Helpers.port_check():              time.sleep(0.1)        @staticmethod      def run_e2e_multi_client(gui: Gui):          with warnings.catch_warnings(record=True):              gui.run(run_server=False, run_browser=False, single_client=False, stylekit=False)              gui._server.run(                  host=gui._get_config(\"host\", \"127.0.0.1\"),                  port=gui._get_config(\"port\", 5000),                  debug=False,                  use_reloader=False,                  flask_log=False,                  run_in_thread=True,                  allow_unsafe_werkzeug=False,                  notebook_proxy=False,              )          while not Helpers.port_check():              time.sleep(0.1)        @staticmethod      def get_taipy_warnings(warns: t.List[warnings.WarningMessage]) -> t.List[warnings.WarningMessage]:          return [w for w in warns if w.category is TaipyGuiWarning] "}
{"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.  import inspect  import typing as t  from pathlib import Path    import pytest    from taipy.gui import Gui  from taipy.gui.extension import Element, ElementLibrary, ElementProperty, PropertyType      def render_xhtml_4_my_library(properties: t.Dict[str, t.Any]) -> str:      return f\"<h1>{properties.get('value', '')}</h1>\"      def render_xhtml_4_my_library_fail(properties: t.Dict[str, t.Any]) -> str:      return f\"<h1>{properties.get('value', '')}</h1\"      class MyLibrary(ElementLibrary):      elts = {          \"testinput\": Element(              \"value\",              {                  \"value\": ElementProperty(PropertyType.dynamic_string, \"Fred\"),                  \"multiline\": ElementProperty(PropertyType.boolean, False),                  \"broadcast\": ElementProperty(PropertyType.broadcast, \"broadcast\"),              },              \"Input\",          ),          \"title\": Element(              \"value\",              {                  \"value\": ElementProperty(PropertyType.string, \"\"),              },              \"h1\",              render_xhtml=render_xhtml_4_my_library,          ),          \"title_fail\": Element(              \"value\",              {                  \"value\": ElementProperty(PropertyType.string, \"\"),              },              \"h1\",              render_xhtml=render_xhtml_4_my_library_fail,          ),          \"inner\": Element(              \"value\",              {\"value\": ElementProperty(PropertyType.string, \"\")},              inner_properties={                  \"with_property\": ElementProperty(                      PropertyType.react,                      \"{<tp:prop:value>}\",                  ),              },          ),      }        def get_name(self) -> str:          return \"test_lib\"        def get_elements(self) -> t.Dict[str, Element]:          return MyLibrary.elts        def get_resource(self, name: str) -> Path:          return Path(name)      class MyBadLibrary(ElementLibrary):      def get_name(self) -> str:          return \"bad name\"        def get_elements(self) -> t.Dict[str, Element]:          return {}      class MyGoodLibrary(ElementLibrary):      def get_name(self) -> str:          return \"test_lib\"        def get_elements(self) -> t.Dict[str, Element]:          return {}      Gui.add_library(MyLibrary())      def test_lib_input_md(gui: Gui, test_client, helpers):      val = \"\"  # noqa: F841      gui._set_frame(inspect.currentframe())      md_string = \"<|{val}|test_lib.testinput|multiline|>\"      expected_list = [          \"<TestLib_Input\",          'libClassName=\"test_lib-testinput\"',          \"multiline={true}\",          'defaultValue=\"\"',          \"broadcast={_bc_broadcast}\",          \"value={tpec_TpExPr_val_TPMDL_0}\",      ]      helpers.test_control_md(gui, md_string, expected_list)      def test_lib_xhtml_md(gui: Gui, test_client, helpers):      val = \"title\"  # noqa: F841      gui._set_frame(inspect.currentframe())      md_string = \"<|{val}|test_lib.title|>\"      expected = [f\"<h1>{val}</h1>\"]      helpers.test_control_md(gui, md_string, expected)      def test_lib_xhtml_fail_md(gui: Gui, test_client, helpers):      val = \"title\"  # noqa: F841      gui._set_frame(inspect.currentframe())      md_string = \"<|{val}|test_lib.title_fail|>\"      expected = [\"title_fail.render_xhtml() did not return a valid XHTML string. unclosed token: line 1, column 9\"]      helpers.test_control_md(gui, md_string, expected)      def test_lib_input_html_1(gui: Gui, test_client, helpers):      val = \"\"  # noqa: F841      gui._set_frame(inspect.currentframe())      html_string = '<test_lib:testinput value=\"{val}\" multiline=\"true\" />'      expected_list = [          \"<TestLib_Input\",          \"multiline={true}\",          'defaultValue=\"\"',          \"broadcast={_bc_broadcast}\",          \"value={tpec_TpExPr_val_TPMDL_0}\",          \"</TestLib_Input>\",      ]      helpers.test_control_html(gui, html_string, expected_list)      def test_lib_input_html_2(gui: Gui, test_client, helpers):      val = \"\"  # noqa: F841      gui._set_frame(inspect.currentframe())      html_string = '<test_lib:testinput multiline=\"true\">{val}</test_lib:testinput>'      expected_list = [          \"<TestLib_Input\",          \"multiline={true}\",          'defaultValue=\"\"',          \"broadcast={_bc_broadcast}\",          \"value={tpec_TpExPr_val_TPMDL_0}\",          \"</TestLib_Input>\",      ]      helpers.test_control_html(gui, html_string, expected_list)      def test_lib_inner_md(gui: Gui, test_client, helpers):      val = \"title\"  # noqa: F841      gui._set_frame(inspect.currentframe())      md_string = \"<|{val}|test_lib.inner|>\"      expected = [          \"<TestLib_Inner\",          \"value={tpec_TpExPr_val_TPMDL_0}\",          \"withProperty={tpec_TpExPr_tpec_TpExPr_val_TPMDL_0_TPMDL_0}\",      ]      helpers.test_control_md(gui, md_string, expected)      def test_lib_inner_no_value_md(gui: Gui, test_client, helpers):      gui._set_frame(inspect.currentframe())      md_string = \"<|test_lib.inner|>\"      expected = [\"<TestLib_Inner\", \"withProperty={tpec_TpExPr_None_TPMDL_0}\"]      helpers.test_control_md(gui, md_string, expected)      def test_lib_bad_name():      with pytest.raises(NameError):          Gui.add_library(MyBadLibrary())      def test_lib_good_name():      Gui.add_library(MyGoodLibrary())      def test_add_lib():      Gui(libraries=[MyGoodLibrary()]) "}
{"text": "#  # Licensed under the Apache License, Version 2.0 (the \"License\"); you may not use this file except in compliance with  # the License. You may obtain a copy of the License at  #  #        http://www.apache.org/licenses/LICENSE-2.0  #  # Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on  # an \"AS IS\" BASIS, WITHOUT 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": "import inspect  from datetime import datetime  from importlib import util    import pandas  # type: ignore  from flask import g    from taipy.gui import Gui  from taipy.gui.data.data_format import _DataFormat  from taipy.gui.data.decimator import ScatterDecimator  from taipy.gui.data.pandas_data_accessor import _PandasDataAccessor      def test_simple_data(gui: Gui, helpers, small_dataframe):      accessor = _PandasDataAccessor()      pd = pandas.DataFrame(data=small_dataframe)      ret_data = accessor.get_data(gui, \"x\", pd, {\"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, small_dataframe):      if util.find_spec(\"pyarrow\"):          accessor = _PandasDataAccessor()          pd = pandas.DataFrame(data=small_dataframe)          ret_data = accessor.get_data(gui, \"x\", pd, {\"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_get_all_simple_data(gui: Gui, helpers, small_dataframe):      accessor = _PandasDataAccessor()      pd = pandas.DataFrame(data=small_dataframe)      ret_data = accessor.get_data(gui, \"x\", pd, {\"alldata\": True}, _DataFormat.JSON)      assert ret_data      assert ret_data[\"alldata\"] is True      value = ret_data[\"value\"]      assert value      data = value[\"data\"]      assert data == small_dataframe      def test_slice(gui: Gui, helpers, small_dataframe):      accessor = _PandasDataAccessor()      pd = pandas.DataFrame(data=small_dataframe)      value = accessor.get_data(gui, \"x\", pd, {\"start\": 0, \"end\": 1}, _DataFormat.JSON)[\"value\"]      assert value[\"rowcount\"] == 3      data = value[\"data\"]      assert len(data) == 2      value = accessor.get_data(gui, \"x\", pd, {\"start\": \"0\", \"end\": \"1\"}, _DataFormat.JSON)[\"value\"]      data = value[\"data\"]      assert len(data) == 2      def test_sort(gui: Gui, helpers, small_dataframe):      accessor = _PandasDataAccessor()      pd = pandas.DataFrame(data=small_dataframe)      query = {\"columns\": [\"name\", \"value\"], \"start\": 0, \"end\": -1, \"orderby\": \"name\", \"sort\": \"desc\"}      data = accessor.get_data(gui, \"x\", pd, query, _DataFormat.JSON)[\"value\"][\"data\"]      assert data[0][\"name\"] == \"C\"      def test_aggregate(gui: Gui, helpers, small_dataframe):      accessor = _PandasDataAccessor()      pd = pandas.DataFrame(data=small_dataframe)      pd = pandas.concat(          [pd, pandas.DataFrame(data={\"name\": [\"A\"], \"value\": [4]})], axis=0, join=\"outer\", ignore_index=True      )      query = {\"columns\": [\"name\", \"value\"], \"start\": 0, \"end\": -1, \"aggregates\": [\"name\"], \"applies\": {\"value\": \"sum\"}}      value = accessor.get_data(gui, \"x\", pd, query, _DataFormat.JSON)[\"value\"]      assert value[\"rowcount\"] == 3      data = value[\"data\"]      assert next(v.get(\"value\") for v in data if v.get(\"name\") == \"A\") == 5      def test_filters(gui: Gui, helpers, small_dataframe):      accessor = _PandasDataAccessor()      pd = pandas.DataFrame(data=small_dataframe)      pd = pandas.concat(          [pd, pandas.DataFrame(data={\"name\": [\"A\"], \"value\": [4]})], axis=0, join=\"outer\", ignore_index=True      )      query = {          \"columns\": [\"name\", \"value\"],          \"start\": 0,          \"end\": -1,          \"filters\": [{\"col\": \"name\", \"action\": \"!=\", \"value\": \"\"}],      }      value = accessor.get_data(gui, \"x\", pd, query, _DataFormat.JSON)      assert len(value[\"value\"][\"data\"]) == 4        query = {          \"columns\": [\"name\", \"value\"],          \"start\": 0,          \"end\": -1,          \"filters\": [{\"col\": \"name\", \"action\": \"==\", \"value\": \"\"}],      }      value = accessor.get_data(gui, \"x\", pd, query, _DataFormat.JSON)      assert len(value[\"value\"][\"data\"]) == 0        query = {          \"columns\": [\"name\", \"value\"],          \"start\": 0,          \"end\": -1,          \"filters\": [{\"col\": \"name\", \"action\": \"==\", \"value\": \"A\"}],      }      value = accessor.get_data(gui, \"x\", pd, query, _DataFormat.JSON)      assert len(value[\"value\"][\"data\"]) == 2        query = {          \"columns\": [\"name\", \"value\"],          \"start\": 0,          \"end\": -1,          \"filters\": [{\"col\": \"name\", \"action\": \"==\", \"value\": \"A\"}, {\"col\": \"value\", \"action\": \"==\", \"value\": 2}],      }      value = accessor.get_data(gui, \"x\", pd, query, _DataFormat.JSON)      assert len(value[\"value\"][\"data\"]) == 0        query = {          \"columns\": [\"name\", \"value\"],          \"start\": 0,          \"end\": -1,          \"filters\": [{\"col\": \"name\", \"action\": \"!=\", \"value\": \"A\"}, {\"col\": \"value\", \"action\": \"==\", \"value\": 2}],      }      value = accessor.get_data(gui, \"x\", pd, query, _DataFormat.JSON)      assert len(value[\"value\"][\"data\"]) == 1      assert value[\"value\"][\"data\"][0][\"_tp_index\"] == 1      def test_filter_by_date(gui: Gui, helpers, small_dataframe):      accessor = _PandasDataAccessor()      pd = pandas.DataFrame(data=small_dataframe)      pd[\"a date\"] = [          datetime.fromisocalendar(2022, 28, 1),          datetime.fromisocalendar(2022, 28, 2),          datetime.fromisocalendar(2022, 28, 3),      ]      query = {          \"columns\": [\"name\", \"value\"],          \"start\": 0,          \"end\": -1,          \"filters\": [{\"col\": \"a date\", \"action\": \">\", \"value\": datetime.fromisocalendar(2022, 28, 3).isoformat() + \"Z\"}],      }      value = accessor.get_data(gui, \"x\", pd, query, _DataFormat.JSON)      assert len(value[\"value\"][\"data\"]) == 0      query = {          \"columns\": [\"name\", \"value\"],          \"start\": 0,          \"end\": -1,          \"filters\": [{\"col\": \"a date\", \"action\": \">\", \"value\": datetime.fromisocalendar(2022, 28, 2).isoformat() + \"Z\"}],      }      value = accessor.get_data(gui, \"x\", pd, query, _DataFormat.JSON)      assert len(value[\"value\"][\"data\"]) == 1      query = {          \"columns\": [\"name\", \"value\"],          \"start\": 0,          \"end\": -1,          \"filters\": [{\"col\": \"a date\", \"action\": \"<\", \"value\": datetime.fromisocalendar(2022, 28, 3).isoformat() + \"Z\"}],      }      value = accessor.get_data(gui, \"x\", pd, query, _DataFormat.JSON)      assert len(value[\"value\"][\"data\"]) == 2      query = {          \"columns\": [\"name\", \"value\"],          \"start\": 0,          \"end\": -1,          \"filters\": [              {\"col\": \"a date\", \"action\": \"<\", \"value\": datetime.fromisocalendar(2022, 28, 2).isoformat() + \"Z\"},              {\"col\": \"a date\", \"action\": \">\", \"value\": datetime.fromisocalendar(2022, 28, 2).isoformat() + \"Z\"},          ],      }      value = accessor.get_data(gui, \"x\", pd, query, _DataFormat.JSON)      assert len(value[\"value\"][\"data\"]) == 0      query = {          \"columns\": [\"name\", \"value\"],          \"start\": 0,          \"end\": -1,          \"filters\": [              {\"col\": \"a date\", \"action\": \"<\", \"value\": datetime.fromisocalendar(2022, 28, 3).isoformat() + \"Z\"},              {\"col\": \"a date\", \"action\": \">\", \"value\": datetime.fromisocalendar(2022, 28, 1).isoformat() + \"Z\"},          ],      }      value = accessor.get_data(gui, \"x\", pd, query, _DataFormat.JSON)      assert len(value[\"value\"][\"data\"]) == 1      def test_decimator(gui: Gui, helpers, small_dataframe):      a_decimator = ScatterDecimator()        accessor = _PandasDataAccessor()      pd = pandas.DataFrame(data=small_dataframe)        # set gui frame      gui._set_frame(inspect.currentframe())        gui.add_page(\"test\", \"<|Hello {a_decimator}|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().test_request_context(f\"/taipy-jsx/test/?client_id={cid}\", data={\"client_id\": cid}):          g.client_id = cid            ret_data = accessor.get_data(              gui,              \"x\",              pd,              {                  \"start\": 0,                  \"end\": -1,                  \"alldata\": True,                  \"decimatorPayload\": {                      \"decimators\": [{\"decimator\": \"a_decimator\", \"chartMode\": \"markers\"}],                      \"width\": 100,                  },              },              _DataFormat.JSON,          )          assert ret_data          value = ret_data[\"value\"]          assert value          data = value[\"data\"]          assert len(data) == 2 "}
{"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 datetime  import inspect  import random  import typing as t    import taipy.gui.builder as tgb  from taipy.gui import Gui      def test_chart_builder_1(gui: Gui, helpers, csvdata):      selected_indices = [14258]  # noqa: F841      subplot_layout = {  # noqa: F841          \"grid\": {\"rows\": 1, \"columns\": 2, \"subplots\": [[\"xy\", \"x2y\"]], \"roworder\": \"bottom to top\"}      }      y = [\"Daily hospital occupancy\", \"Daily hospital occupancy\"]  # noqa: F841      label = [\"Entity\", \"Code\"]  # noqa: F841      mode = [None, \"markers\"]  # noqa: F841      color = [None, \"red\"]  # noqa: F841      chart_type = [None, \"scatter\"]  # noqa: F841      xaxis = [None, \"x2\"]  # noqa: F841      with tgb.Page(frame=None) as page:          tgb.chart(              data=\"{csvdata}\",              x=\"Day\",              selected_color=\"green\",              y=\"{y}\",              label=\"{label}\",              mode=\"{mode}\",              color=\"{color}\",              type=\"{chart_type}\",              xaxis=\"{xaxis}\",              layout=\"{subplot_layout}\",              on_range_change=\"range_change\",              width=\"100%\",              height=\"100%\",              selected=\"{selected_indices}\",          )      expected_list = [          \"<Chart\",          \"selected0={tpec_TpExPr_selected_indices_TPMDL_0}\",          \"selected1={tpec_TpExPr_selected_indices_TPMDL_0}\",          'height=\"100%\"',          'defaultLayout=\"{&quot;grid&quot;: &#x7B;&quot;rows&quot;: 1, &quot;columns&quot;: 2, &quot;subplots&quot;: [[&quot;xy&quot;, &quot;x2y&quot;]], &quot;roworder&quot;: &quot;bottom to top&quot;&#x7D;}\"',          'onRangeChange=\"range_change\"',          'updateVars=\"layout=_TpDi_tpec_TpExPr_subplot_layout_TPMDL_0;selected0=tpec_TpExPr_selected_indices_TPMDL_0;selected1=tpec_TpExPr_selected_indices_TPMDL_0\"',          'updateVarName=\"_TpD_tpec_TpExPr_csvdata_TPMDL_0\"',          \"data={_TpD_tpec_TpExPr_csvdata_TPMDL_0}\",          'width=\"100%\"',      ]      gui._set_frame(inspect.currentframe())      helpers.test_control_builder(gui, page, expected_list)      def test_chart_builder_2(gui: Gui, helpers, csvdata):      selected_indices = [14258]  # noqa: F841      with tgb.Page(frame=None) as page:          tgb.chart(              data=\"{csvdata}\",              x=\"Day\",              selected_color=\"green\",              y=[\"Daily hospital occupancy\", \"Daily hospital occupancy\"],              label=[\"Entity\", \"Code\"],              mode=[None, \"markers\"],              color=[None, \"red\"],              type=(None, \"scatter\"),              xaxis=(None, \"x2\"),              layout={\"grid\": {\"rows\": 1, \"columns\": 2, \"subplots\": [[\"xy\", \"x2y\"]], \"roworder\": \"bottom to top\"}},              on_range_change=\"range_change\",              width=\"100%\",              height=\"100%\",              selected=\"{selected_indices}\",          )      expected_list = [          \"<Chart\",          \"selected0={tpec_TpExPr_selected_indices_TPMDL_0}\",          \"selected1={tpec_TpExPr_selected_indices_TPMDL_0}\",          'height=\"100%\"',          'defaultLayout=\"{&quot;grid&quot;: &#x7B;&quot;rows&quot;: 1, &quot;columns&quot;: 2, &quot;subplots&quot;: [[&quot;xy&quot;, &quot;x2y&quot;]], &quot;roworder&quot;: &quot;bottom to top&quot;&#x7D;}\"',          'onRangeChange=\"range_change\"',          'updateVars=\"selected0=tpec_TpExPr_selected_indices_TPMDL_0;selected1=tpec_TpExPr_selected_indices_TPMDL_0\"',          'updateVarName=\"_TpD_tpec_TpExPr_csvdata_TPMDL_0\"',          \"data={_TpD_tpec_TpExPr_csvdata_TPMDL_0}\",          'width=\"100%\"',      ]      gui._set_frame(inspect.currentframe())      helpers.test_control_builder(gui, page, expected_list)      def test_map_builder(gui: Gui, helpers):      mapData = {  # noqa: F841          \"Lat\": [              48.4113,              18.0057,              48.6163,              48.5379,              48.5843,              48.612,              48.6286,              48.6068,              48.4489,              48.6548,              18.5721,              48.3734,              17.6398,              48.5765,              48.4407,              48.2286,          ],          \"Lon\": [              -112.8352,              -65.804,              -113.4784,              -114.0702,              -111.0188,              -110.7939,              -109.4629,              -114.9123,              -112.9705,              -113.965,              -66.5401,              -111.5245,              -64.7246,              -112.1932,              -113.3159,              -104.5863,          ],          \"Globvalue\": [              0.0875,              0.0892,              0.0908,              0.0933,              0.0942,              0.095,              0.095,              0.095,              0.0958,              0.0958,              0.0958,              0.0958,              0.0958,              0.0975,              0.0983,              0.0992,          ],      }      marker = {\"color\": \"fuchsia\", \"size\": 4}  # noqa: F841      layout = {  # noqa: F841          \"dragmode\": \"zoom\",          \"mapbox\": {\"style\": \"open-street-map\", \"center\": {\"lat\": 38, \"lon\": -90}, \"zoom\": 3},          \"margin\": {\"r\": 0, \"t\": 0, \"b\": 0, \"l\": 0},      }      with tgb.Page(frame=None) as page:          tgb.chart(              data=\"{mapData}\",              type=\"scattermapbox\",              marker=\"{marker}\",              layout=\"{layout}\",              lat=\"Lat\",              lon=\"Lon\",              text=\"Globvalue\",              mode=\"markers\",          )      gui._set_frame(inspect.currentframe())      expected_list = [          \"<Chart\",          \"&quot;Lat&quot;: &#x7B;&quot;index&quot;:\",          \"&quot;Lon&quot;: &#x7B;&quot;index&quot;:\",          \"data={_TpD_tpec_TpExPr_mapData_TPMDL_0}\",          'defaultLayout=\"{&quot;dragmode&quot;: &quot;zoom&quot;, &quot;mapbox&quot;: &#x7B;&quot;style&quot;: &quot;open-street-map&quot;, &quot;center&quot;: &#x7B;&quot;lat&quot;: 38, &quot;lon&quot;: -90&#x7D;, &quot;zoom&quot;: 3&#x7D;, &quot;margin&quot;: &#x7B;&quot;r&quot;: 0, &quot;t&quot;: 0, &quot;b&quot;: 0, &quot;l&quot;: 0&#x7D;}\"',          'updateVarName=\"_TpD_tpec_TpExPr_mapData_TPMDL_0\"',      ]      helpers.test_control_builder(gui, page, expected_list)      def test_chart_indexed_properties_builder(gui: Gui, helpers):      data: t.Dict[str, t.Any] = {}      data[\"Date\"] = [datetime.datetime(2021, 12, i) for i in range(1, 31)]        data[\"La Rochelle\"] = [10 + 6 * random.random() for _ in range(1, 31)]      data[\"Montpellier\"] = [16 + 6 * random.random() for _ in range(1, 31)]      data[\"Paris\"] = [6 + 6 * random.random() for _ in range(1, 31)]        data[\"La Rochelle 1\"] = [x * (1 + (random.random() / 10)) for x in data[\"La Rochelle\"]]      data[\"La Rochelle 2\"] = [x * (1 - (random.random() / 10)) for x in data[\"La Rochelle\"]]        data[\"Montpellier 1\"] = [x * (1 + (random.random() / 10)) for x in data[\"Montpellier\"]]      data[\"Montpellier 2\"] = [x * (1 - (random.random() / 10)) for x in data[\"Montpellier\"]]        with tgb.Page(frame=None) as page:          tgb.chart(              data=\"{data}\",              x=\"Date\",              mode=\"lines\",              y=[\"La Rochelle\", \"La Rochelle 1\", \"La Rochelle 2\", \"Montpellier\", \"Montpellier 1\", \"Montpellier 2\"],              line=[None, \"dashdot\", \"dash\", None, \"dashdot\", \"dash\"],              color=[None, \"blue\", \"blue\", None, \"red\", \"red\"],          )        gui._set_frame(inspect.currentframe())      expected_list = [          \"<Chart\",          \"&quot;traces&quot;: [[&quot;Date_str&quot;, &quot;La Rochelle&quot;], [&quot;Date_str&quot;, &quot;La Rochelle 1&quot;], [&quot;Date_str&quot;, &quot;La Rochelle 2&quot;], [&quot;Date_str&quot;, &quot;Montpellier&quot;], [&quot;Date_str&quot;, &quot;Montpellier 1&quot;], [&quot;Date_str&quot;, &quot;Montpellier 2&quot;]]\",          \"&quot;lines&quot;: [null, &#x7B;&quot;dash&quot;: &quot;dashdot&quot;&#x7D;, &#x7B;&quot;dash&quot;: &quot;dash&quot;&#x7D;, null, &#x7B;&quot;dash&quot;: &quot;dashdot&quot;&#x7D;, &#x7B;&quot;dash&quot;: &quot;dash&quot;&#x7D;]\",      ]      helpers.test_control_builder(gui, page, expected_list)      def test_chart_indexed_properties_with_arrays_builder(gui: Gui, helpers):      data: t.Dict[str, t.Any] = {}      data[\"Date\"] = [datetime.datetime(2021, 12, i) for i in range(1, 31)]        data[\"La Rochelle\"] = [10 + 6 * random.random() for _ in range(1, 31)]      data[\"Montpellier\"] = [16 + 6 * random.random() for _ in range(1, 31)]      data[\"Paris\"] = [6 + 6 * random.random() for _ in range(1, 31)]        data[\"La Rochelle 1\"] = [x * (1 + (random.random() / 10)) for x in data[\"La Rochelle\"]]      data[\"La Rochelle 2\"] = [x * (1 - (random.random() / 10)) for x in data[\"La Rochelle\"]]        data[\"Montpellier 1\"] = [x * (1 + (random.random() / 10)) for x in data[\"Montpellier\"]]      data[\"Montpellier 2\"] = [x * (1 - (random.random() / 10)) for x in data[\"Montpellier\"]]        ys = [  # noqa: F841          \"La Rochelle\",          \"La Rochelle 1\",          \"La Rochelle 2\",          \"Montpellier\",          \"Montpellier 1\",          \"Montpellier 2\",      ]      lines = [None, \"dashdot\", \"dash\", None, \"dashdot\", \"dash\"]  # noqa: F841      colors = [None, \"blue\", \"blue\", None, \"red\", \"red\"]  # noqa: F841        with tgb.Page(frame=None) as page:          tgb.chart(              data=\"{data}\",              x=\"Date\",              mode=\"lines\",              y=\"{ys}\",              line=\"{lines}\",              color=\"{colors}\",          )        gui._set_frame(inspect.currentframe())      expected_list = [          \"<Chart\",          \"&quot;traces&quot;: [[&quot;Date_str&quot;, &quot;La Rochelle&quot;], [&quot;Date_str&quot;, &quot;La Rochelle 1&quot;], [&quot;Date_str&quot;, &quot;La Rochelle 2&quot;], [&quot;Date_str&quot;, &quot;Montpellier&quot;], [&quot;Date_str&quot;, &quot;Montpellier 1&quot;], [&quot;Date_str&quot;, &quot;Montpellier 2&quot;]]\",          \"&quot;lines&quot;: [null, &#x7B;&quot;dash&quot;: &quot;dashdot&quot;&#x7D;, &#x7B;&quot;dash&quot;: &quot;dash&quot;&#x7D;, null, &#x7B;&quot;dash&quot;: &quot;dashdot&quot;&#x7D;, &#x7B;&quot;dash&quot;: &quot;dash&quot;&#x7D;]\",      ]      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": "import inspect    from taipy.gui import Gui      def test_table_md_1(gui: Gui, helpers, csvdata):      md_string = \"<|{csvdata}|table|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_md(gui, md_string, expected_list)      def test_table_reset_md(gui: Gui, helpers, csvdata):      md_string = \"<|{csvdata}|table|rebuild|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_md(gui, md_string, expected_list)      def test_table_md_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\",      }      md_string = \"<|{csvdata}|table|properties=table_properties|auto_loading|not editable|>\"      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_md(gui, md_string, expected_list)      def test_table_html_1(gui: Gui, helpers, csvdata):      html_string = '<taipy: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_html(gui, html_string, expected_list)      def test_table_html_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\",      }      html_string = '<taipy:table data=\"{csvdata}\" properties=\"table_properties\" auto_loading=\"Yes\" show_all=\"Sure\" />'      expected_list = [          \"<Table\",          \"allowAllRows={true}\",          \"autoLoading={true}\",          \"showAll={true}\",          '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_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": "import datetime  import inspect  import random  import typing as t    from taipy.gui import Gui      def test_chart_md_1(gui: Gui, helpers, csvdata):      selected_indices = [14258]  # noqa: F841      subplot_layout = {  # noqa: F841          \"grid\": {\"rows\": 1, \"columns\": 2, \"subplots\": [[\"xy\", \"x2y\"]], \"roworder\": \"bottom to top\"}      }      md_string = \"<|{csvdata}|chart|x=Day|selected_color=green|y[1]=Daily hospital occupancy|label[1]=Entity|y[2]=Daily hospital occupancy|label[2]=Code|mode[2]=markers|color[2]=red|type[2]=scatter|xaxis[2]=x2|layout={subplot_layout}|on_range_change=range_change|width=100%|height=100%|selected={selected_indices}|>\"      expected_list = [          \"<Chart\",          \"selected0={tpec_TpExPr_selected_indices_TPMDL_0}\",          \"selected1={tpec_TpExPr_selected_indices_TPMDL_0}\",          'height=\"100%\"',          'defaultLayout=\"{&quot;grid&quot;: &#x7B;&quot;rows&quot;: 1, &quot;columns&quot;: 2, &quot;subplots&quot;: [[&quot;xy&quot;, &quot;x2y&quot;]], &quot;roworder&quot;: &quot;bottom to top&quot;&#x7D;}\"',          'onRangeChange=\"range_change\"',          'updateVars=\"layout=_TpDi_tpec_TpExPr_subplot_layout_TPMDL_0;selected0=tpec_TpExPr_selected_indices_TPMDL_0;selected1=tpec_TpExPr_selected_indices_TPMDL_0\"',          'updateVarName=\"_TpD_tpec_TpExPr_csvdata_TPMDL_0\"',          \"data={_TpD_tpec_TpExPr_csvdata_TPMDL_0}\",          'width=\"100%\"',      ]      gui._set_frame(inspect.currentframe())      helpers.test_control_md(gui, md_string, expected_list)      def test_chart_html_1(gui: Gui, helpers, csvdata):      selected_indices = [14258]  # noqa: F841      subplot_layout = {  # noqa: F841          \"grid\": {\"rows\": 1, \"columns\": 2, \"subplots\": [[\"xy\", \"x2y\"]], \"roworder\": \"bottom to top\"}      }      html_string = '<taipy:chart data=\"{csvdata}\" x=\"Day\" selected_color=\"green\" y[1]=\"Daily hospital occupancy\" label[1]=\"Entity\" y[2]=\"Daily hospital occupancy\" label[2]=\"Code\" mode[2]=\"markers\" color[2]=\"red\" type[2]=\"scatter\" xaxis[2]=\"x2\" layout=\"{subplot_layout}\" on_range_change=\"range_change\" width=\"100%\" height=\"100%\" selected=\"{selected_indices}\"  />'      expected_list = [          \"<Chart\",          \"selected0={tpec_TpExPr_selected_indices_TPMDL_0}\",          \"selected1={tpec_TpExPr_selected_indices_TPMDL_0}\",          'height=\"100%\"',          'defaultLayout=\"{&quot;grid&quot;: &#x7B;&quot;rows&quot;: 1, &quot;columns&quot;: 2, &quot;subplots&quot;: [[&quot;xy&quot;, &quot;x2y&quot;]], &quot;roworder&quot;: &quot;bottom to top&quot;&#x7D;}\"',          'onRangeChange=\"range_change\"',          'updateVars=\"layout=_TpDi_tpec_TpExPr_subplot_layout_TPMDL_0;selected0=tpec_TpExPr_selected_indices_TPMDL_0;selected1=tpec_TpExPr_selected_indices_TPMDL_0\"',          'updateVarName=\"_TpD_tpec_TpExPr_csvdata_TPMDL_0\"',          \"data={_TpD_tpec_TpExPr_csvdata_TPMDL_0}\",          'width=\"100%\"',      ]      gui._set_frame(inspect.currentframe())      helpers.test_control_html(gui, html_string, expected_list)      def test_chart_html_2(gui: Gui, helpers, csvdata):      selected_indices = [14258]  # noqa: F841      subplot_layout = {  # noqa: F841          \"grid\": {\"rows\": 1, \"columns\": 2, \"subplots\": [[\"xy\", \"x2y\"]], \"roworder\": \"bottom to top\"}      }      html_string = '<taipy:chart x=\"Day\" selected_color=\"green\" y[1]=\"Daily hospital occupancy\" label[1]=\"Entity\" y[2]=\"Daily hospital occupancy\" label[2]=\"Code\" mode[2]=\"markers\" color[2]=\"red\" type[2]=\"scatter\" xaxis[2]=\"x2\" layout=\"{subplot_layout}\" on_range_change=\"range_change\" width=\"100%\" height=\"100%\" selected=\"{selected_indices}\" >{csvdata}</taipy:chart>'      expected_list = [          \"<Chart\",          \"selected0={tpec_TpExPr_selected_indices_TPMDL_0}\",          \"selected1={tpec_TpExPr_selected_indices_TPMDL_0}\",          'height=\"100%\"',          'defaultLayout=\"{&quot;grid&quot;: &#x7B;&quot;rows&quot;: 1, &quot;columns&quot;: 2, &quot;subplots&quot;: [[&quot;xy&quot;, &quot;x2y&quot;]], &quot;roworder&quot;: &quot;bottom to top&quot;&#x7D;}\"',          'onRangeChange=\"range_change\"',          'updateVars=\"layout=_TpDi_tpec_TpExPr_subplot_layout_TPMDL_0;selected0=tpec_TpExPr_selected_indices_TPMDL_0;selected1=tpec_TpExPr_selected_indices_TPMDL_0\"',          'updateVarName=\"_TpD_tpec_TpExPr_csvdata_TPMDL_0\"',          \"data={_TpD_tpec_TpExPr_csvdata_TPMDL_0}\",          'width=\"100%\"',      ]      gui._set_frame(inspect.currentframe())      helpers.test_control_html(gui, html_string, expected_list)      def test_map_md(gui: Gui, helpers):      mapData = {  # noqa: F841          \"Lat\": [              48.4113,              18.0057,              48.6163,              48.5379,              48.5843,              48.612,              48.6286,              48.6068,              48.4489,              48.6548,              18.5721,              48.3734,              17.6398,              48.5765,              48.4407,              48.2286,          ],          \"Lon\": [              -112.8352,              -65.804,              -113.4784,              -114.0702,              -111.0188,              -110.7939,              -109.4629,              -114.9123,              -112.9705,              -113.965,              -66.5401,              -111.5245,              -64.7246,              -112.1932,              -113.3159,              -104.5863,          ],          \"Globvalue\": [              0.0875,              0.0892,              0.0908,              0.0933,              0.0942,              0.095,              0.095,              0.095,              0.0958,              0.0958,              0.0958,              0.0958,              0.0958,              0.0975,              0.0983,              0.0992,          ],      }      marker = {\"color\": \"fuchsia\", \"size\": 4}  # noqa: F841      layout = {  # noqa: F841          \"dragmode\": \"zoom\",          \"mapbox\": {\"style\": \"open-street-map\", \"center\": {\"lat\": 38, \"lon\": -90}, \"zoom\": 3},          \"margin\": {\"r\": 0, \"t\": 0, \"b\": 0, \"l\": 0},      }      md = \"<|{mapData}|chart|type=scattermapbox|marker={marker}|layout={layout}|lat=Lat|lon=Lon|text=Globvalue|mode=markers|>\"      gui._set_frame(inspect.currentframe())      expected_list = [          \"<Chart\",          \"&quot;Lat&quot;: &#x7B;&quot;index&quot;:\",          \"&quot;Lon&quot;: &#x7B;&quot;index&quot;:\",          \"data={_TpD_tpec_TpExPr_mapData_TPMDL_0}\",          'defaultLayout=\"{&quot;dragmode&quot;: &quot;zoom&quot;, &quot;mapbox&quot;: &#x7B;&quot;style&quot;: &quot;open-street-map&quot;, &quot;center&quot;: &#x7B;&quot;lat&quot;: 38, &quot;lon&quot;: -90&#x7D;, &quot;zoom&quot;: 3&#x7D;, &quot;margin&quot;: &#x7B;&quot;r&quot;: 0, &quot;t&quot;: 0, &quot;b&quot;: 0, &quot;l&quot;: 0&#x7D;}\"',          'updateVarName=\"_TpD_tpec_TpExPr_mapData_TPMDL_0\"',      ]      helpers.test_control_md(gui, md, expected_list)      def test_chart_indexed_properties(gui: Gui, helpers):      data: t.Dict[str, t.Any] = {}      data[\"Date\"] = [datetime.datetime(2021, 12, i) for i in range(1, 31)]        data[\"La Rochelle\"] = [10 + 6 * random.random() for _ in range(1, 31)]      data[\"Montpellier\"] = [16 + 6 * random.random() for _ in range(1, 31)]      data[\"Paris\"] = [6 + 6 * random.random() for _ in range(1, 31)]        data[\"La Rochelle 1\"] = [x * (1 + (random.random() / 10)) for x in data[\"La Rochelle\"]]      data[\"La Rochelle 2\"] = [x * (1 - (random.random() / 10)) for x in data[\"La Rochelle\"]]        data[\"Montpellier 1\"] = [x * (1 + (random.random() / 10)) for x in data[\"Montpellier\"]]      data[\"Montpellier 2\"] = [x * (1 - (random.random() / 10)) for x in data[\"Montpellier\"]]        md = \"<|{data}|chart|x=Date|mode=lines|y[1]=La Rochelle|y[2]=La Rochelle 1|y[3]=La Rochelle 2|y[4]=Montpellier|y[5]=Montpellier 1|y[6]=Montpellier 2|line[2]=dashdot|line[3]=dash|line[5]=dashdot|line[6]=dash|color[2]=blue|color[3]=blue|color[5]=red|color[6]=red|>\"        gui._set_frame(inspect.currentframe())      expected_list = [          \"<Chart\",          \"&quot;traces&quot;: [[&quot;Date_str&quot;, &quot;La Rochelle&quot;], [&quot;Date_str&quot;, &quot;La Rochelle 1&quot;], [&quot;Date_str&quot;, &quot;La Rochelle 2&quot;], [&quot;Date_str&quot;, &quot;Montpellier&quot;], [&quot;Date_str&quot;, &quot;Montpellier 1&quot;], [&quot;Date_str&quot;, &quot;Montpellier 2&quot;]]\",          \"&quot;lines&quot;: [null, &#x7B;&quot;dash&quot;: &quot;dashdot&quot;&#x7D;, &#x7B;&quot;dash&quot;: &quot;dash&quot;&#x7D;, null, &#x7B;&quot;dash&quot;: &quot;dashdot&quot;&#x7D;, &#x7B;&quot;dash&quot;: &quot;dash&quot;&#x7D;]\",      ]      helpers.test_control_md(gui, md, expected_list)      def test_chart_indexed_properties_with_arrays(gui: Gui, helpers):      data: t.Dict[str, t.Any] = {}      data[\"Date\"] = [datetime.datetime(2021, 12, i) for i in range(1, 31)]        data[\"La Rochelle\"] = [10 + 6 * random.random() for _ in range(1, 31)]      data[\"Montpellier\"] = [16 + 6 * random.random() for _ in range(1, 31)]      data[\"Paris\"] = [6 + 6 * random.random() for _ in range(1, 31)]        data[\"La Rochelle 1\"] = [x * (1 + (random.random() / 10)) for x in data[\"La Rochelle\"]]      data[\"La Rochelle 2\"] = [x * (1 - (random.random() / 10)) for x in data[\"La Rochelle\"]]        data[\"Montpellier 1\"] = [x * (1 + (random.random() / 10)) for x in data[\"Montpellier\"]]      data[\"Montpellier 2\"] = [x * (1 - (random.random() / 10)) for x in data[\"Montpellier\"]]        ys = [  # noqa: F841          \"La Rochelle\",          \"La Rochelle 1\",          \"La Rochelle 2\",          \"Montpellier\",          \"Montpellier 1\",          \"Montpellier 2\",      ]      lines = [None, \"dashdot\", \"dash\", None, \"dashdot\", \"dash\"]  # noqa: F841      colors = [None, \"blue\", \"blue\", None, \"red\", \"red\"]  # noqa: F841        md = \"<|{data}|chart|x=Date|mode=lines|y={ys}|line={lines}|color={colors}|>\"        gui._set_frame(inspect.currentframe())      expected_list = [          \"<Chart\",          \"&quot;traces&quot;: [[&quot;Date_str&quot;, &quot;La Rochelle&quot;], [&quot;Date_str&quot;, &quot;La Rochelle 1&quot;], [&quot;Date_str&quot;, &quot;La Rochelle 2&quot;], [&quot;Date_str&quot;, &quot;Montpellier&quot;], [&quot;Date_str&quot;, &quot;Montpellier 1&quot;], [&quot;Date_str&quot;, &quot;Montpellier 2&quot;]]\",          \"&quot;lines&quot;: [null, &#x7B;&quot;dash&quot;: &quot;dashdot&quot;&#x7D;, &#x7B;&quot;dash&quot;: &quot;dash&quot;&#x7D;, null, &#x7B;&quot;dash&quot;: &quot;dashdot&quot;&#x7D;, &#x7B;&quot;dash&quot;: &quot;dash&quot;&#x7D;]\",      ]      helpers.test_control_md(gui, md, 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": "from unittest.mock import Mock, patch    import pytest    from src.taipy.gui_core._context import _GuiCoreContext, _SubmissionStatus  from taipy.core import Status      class MockJob:      def __init__(self, id: str, status):          self.status = status          self.id = id        def is_failed(self):          return self.status == Status.FAILED        def is_canceled(self):          return self.status == Status.CANCELED        def is_blocked(self):          return self.status == Status.BLOCKED        def is_pending(self):          return self.status == Status.PENDING        def is_running(self):          return self.status == Status.RUNNING        def is_completed(self):          return self.status == Status.COMPLETED        def is_skipped(self):          return self.status == Status.SKIPPED        def is_abandoned(self):          return self.status == Status.ABANDONED        def is_submitted(self):          return self.status == Status.SUBMITTED      def mock_core_get(entity_id):      jobs = {          \"job0_submitted\": MockJob(\"job0_submitted\", Status.SUBMITTED),          \"job1_failed\": MockJob(\"job1_failed\", Status.FAILED),          \"job2_canceled\": MockJob(\"job2_canceled\", Status.CANCELED),          \"job3_blocked\": MockJob(\"job3_blocked\", Status.BLOCKED),          \"job4_pending\": MockJob(\"job4_pending\", Status.PENDING),          \"job5_running\": MockJob(\"job5_running\", Status.RUNNING),          \"job6_completed\": MockJob(\"job6_completed\", Status.COMPLETED),          \"job7_skipped\": MockJob(\"job7_skipped\", Status.SKIPPED),          \"job8_abandoned\": MockJob(\"job8_abandoned\", Status.ABANDONED),      }      return jobs[entity_id]      class TestGuiCoreContext_SubmissionStatus:      @pytest.mark.parametrize(          \"job_ids, expected_status\",          [              ([\"job1_failed\"], _SubmissionStatus.FAILED),              ([\"job2_canceled\"], _SubmissionStatus.CANCELED),              ([\"job3_blocked\"], _SubmissionStatus.BLOCKED),              ([\"job4_pending\"], _SubmissionStatus.WAITING),              ([\"job5_running\"], _SubmissionStatus.RUNNING),              ([\"job6_completed\"], _SubmissionStatus.COMPLETED),              ([\"job7_skipped\"], _SubmissionStatus.COMPLETED),              ([\"job8_abandoned\"], _SubmissionStatus.UNDEFINED),          ],      )      def test_single_job(self, job_ids, expected_status):          with patch(\"src.taipy.gui_core._context.core_get\", side_effect=mock_core_get):              gui_core_context = _GuiCoreContext(Mock())              status = gui_core_context._get_submittable_status(job_ids)              assert status == expected_status        @pytest.mark.parametrize(          \"job_ids, expected_status\",          [              ([\"job1_failed\", \"job1_failed\"], _SubmissionStatus.FAILED),              ([\"job1_failed\", \"job2_canceled\"], _SubmissionStatus.FAILED),              ([\"job1_failed\", \"job3_blocked\"], _SubmissionStatus.FAILED),              ([\"job1_failed\", \"job4_pending\"], _SubmissionStatus.FAILED),              ([\"job1_failed\", \"job5_running\"], _SubmissionStatus.FAILED),              ([\"job1_failed\", \"job6_completed\"], _SubmissionStatus.FAILED),              ([\"job1_failed\", \"job7_skipped\"], _SubmissionStatus.FAILED),              ([\"job1_failed\", \"job8_abandoned\"], _SubmissionStatus.FAILED),              ([\"job2_canceled\", \"job1_failed\"], _SubmissionStatus.FAILED),              ([\"job3_blocked\", \"job1_failed\"], _SubmissionStatus.FAILED),              ([\"job4_pending\", \"job1_failed\"], _SubmissionStatus.FAILED),              ([\"job5_running\", \"job1_failed\"], _SubmissionStatus.FAILED),              ([\"job6_completed\", \"job1_failed\"], _SubmissionStatus.FAILED),              ([\"job7_skipped\", \"job1_failed\"], _SubmissionStatus.FAILED),              ([\"job8_abandoned\", \"job1_failed\"], _SubmissionStatus.FAILED),          ],      )      def test_one_failed_job(self, job_ids, expected_status):          with patch(\"src.taipy.gui_core._context.core_get\", side_effect=mock_core_get):              gui_core_context = _GuiCoreContext(Mock())              status = gui_core_context._get_submittable_status(job_ids)              assert status == expected_status        @pytest.mark.parametrize(          \"job_ids, expected_status\",          [              ([\"job2_canceled\", \"job2_canceled\"], _SubmissionStatus.CANCELED),              ([\"job2_canceled\", \"job3_blocked\"], _SubmissionStatus.CANCELED),              ([\"job2_canceled\", \"job4_pending\"], _SubmissionStatus.CANCELED),              ([\"job2_canceled\", \"job5_running\"], _SubmissionStatus.CANCELED),              ([\"job2_canceled\", \"job6_completed\"], _SubmissionStatus.CANCELED),              ([\"job2_canceled\", \"job7_skipped\"], _SubmissionStatus.CANCELED),              ([\"job2_canceled\", \"job8_abandoned\"], _SubmissionStatus.CANCELED),              ([\"job3_blocked\", \"job2_canceled\"], _SubmissionStatus.CANCELED),              ([\"job4_pending\", \"job2_canceled\"], _SubmissionStatus.CANCELED),              ([\"job5_running\", \"job2_canceled\"], _SubmissionStatus.CANCELED),              ([\"job6_completed\", \"job2_canceled\"], _SubmissionStatus.CANCELED),              ([\"job7_skipped\", \"job2_canceled\"], _SubmissionStatus.CANCELED),              ([\"job8_abandoned\", \"job2_canceled\"], _SubmissionStatus.CANCELED),          ],      )      def test_no_failed_one_cancel(self, job_ids, expected_status):          with patch(\"src.taipy.gui_core._context.core_get\", side_effect=mock_core_get):              gui_core_context = _GuiCoreContext(Mock())              status = gui_core_context._get_submittable_status(job_ids)              assert status == expected_status        @pytest.mark.parametrize(          \"job_ids, expected_status\",          [              ([\"job4_pending\", \"job3_blocked\"], _SubmissionStatus.WAITING),              ([\"job4_pending\", \"job4_pending\"], _SubmissionStatus.WAITING),              ([\"job4_pending\", \"job6_completed\"], _SubmissionStatus.WAITING),              ([\"job4_pending\", \"job7_skipped\"], _SubmissionStatus.WAITING),              ([\"job3_blocked\", \"job4_pending\"], _SubmissionStatus.WAITING),              ([\"job6_completed\", \"job4_pending\"], _SubmissionStatus.WAITING),              ([\"job7_skipped\", \"job4_pending\"], _SubmissionStatus.WAITING),          ],      )      def test_no_failed_or_cancel_one_pending(self, job_ids, expected_status):          with patch(\"src.taipy.gui_core._context.core_get\", side_effect=mock_core_get):              gui_core_context = _GuiCoreContext(Mock())              status = gui_core_context._get_submittable_status(job_ids)              assert status == expected_status        @pytest.mark.parametrize(          \"job_ids, expected_status\",          [              ([\"job5_running\", \"job3_blocked\"], _SubmissionStatus.RUNNING),              ([\"job5_running\", \"job4_pending\"], _SubmissionStatus.RUNNING),              ([\"job5_running\", \"job5_running\"], _SubmissionStatus.RUNNING),              ([\"job5_running\", \"job6_completed\"], _SubmissionStatus.RUNNING),              ([\"job5_running\", \"job7_skipped\"], _SubmissionStatus.RUNNING),              ([\"job3_blocked\", \"job5_running\"], _SubmissionStatus.RUNNING),              ([\"job4_pending\", \"job5_running\"], _SubmissionStatus.RUNNING),              ([\"job6_completed\", \"job5_running\"], _SubmissionStatus.RUNNING),              ([\"job7_skipped\", \"job5_running\"], _SubmissionStatus.RUNNING),          ],      )      def test_no_failed_cancel_nor_pending_one_running(self, job_ids, expected_status):          with patch(\"src.taipy.gui_core._context.core_get\", side_effect=mock_core_get):              gui_core_context = _GuiCoreContext(Mock())              status = gui_core_context._get_submittable_status(job_ids)              assert status == expected_status        @pytest.mark.parametrize(          \"job_ids, expected_status\",          [              ([\"job3_blocked\", \"job3_blocked\"], _SubmissionStatus.BLOCKED),              ([\"job3_blocked\", \"job6_completed\"], _SubmissionStatus.BLOCKED),              ([\"job3_blocked\", \"job7_skipped\"], _SubmissionStatus.BLOCKED),              ([\"job6_completed\", \"job3_blocked\"], _SubmissionStatus.BLOCKED),              ([\"job7_skipped\", \"job3_blocked\"], _SubmissionStatus.BLOCKED),          ],      )      def test_no_failed_cancel_pending_nor_running_one_blocked(self, job_ids, expected_status):          with patch(\"src.taipy.gui_core._context.core_get\", side_effect=mock_core_get):              gui_core_context = _GuiCoreContext(Mock())              status = gui_core_context._get_submittable_status(job_ids)              assert status == expected_status        @pytest.mark.parametrize(          \"job_ids, expected_status\",          [              ([\"job6_completed\", \"job6_completed\"], _SubmissionStatus.COMPLETED),              ([\"job6_completed\", \"job7_skipped\"], _SubmissionStatus.COMPLETED),              ([\"job7_skipped\", \"job6_completed\"], _SubmissionStatus.COMPLETED),              ([\"job7_skipped\", \"job7_skipped\"], _SubmissionStatus.COMPLETED),          ],      )      def test_only_completed_or_skipped(self, job_ids, expected_status):          with patch(\"src.taipy.gui_core._context.core_get\", side_effect=mock_core_get):              gui_core_context = _GuiCoreContext(Mock())              status = gui_core_context._get_submittable_status(job_ids)              assert status == expected_status        @pytest.mark.parametrize(          \"job_ids, expected_status\",          [              ([\"job3_blocked\", \"job8_abandoned\"], _SubmissionStatus.UNDEFINED),              ([\"job4_pending\", \"job8_abandoned\"], _SubmissionStatus.UNDEFINED),              ([\"job5_running\", \"job8_abandoned\"], _SubmissionStatus.UNDEFINED),              ([\"job6_completed\", \"job8_abandoned\"], _SubmissionStatus.UNDEFINED),              ([\"job7_skipped\", \"job8_abandoned\"], _SubmissionStatus.UNDEFINED),              ([\"job8_abandoned\", \"job8_abandoned\"], _SubmissionStatus.UNDEFINED),              ([\"job8_abandoned\", \"job3_blocked\"], _SubmissionStatus.UNDEFINED),              ([\"job8_abandoned\", \"job4_pending\"], _SubmissionStatus.UNDEFINED),              ([\"job8_abandoned\", \"job5_running\"], _SubmissionStatus.UNDEFINED),              ([\"job8_abandoned\", \"job6_completed\"], _SubmissionStatus.UNDEFINED),              ([\"job8_abandoned\", \"job7_skipped\"], _SubmissionStatus.UNDEFINED),          ],      )      def test_WRONG_CASE_abandoned_without_cancel_or_failed(self, job_ids, expected_status):          with patch(\"src.taipy.gui_core._context.core_get\", side_effect=mock_core_get):              gui_core_context = _GuiCoreContext(Mock())              status = gui_core_context._get_submittable_status(job_ids)              assert status == expected_status        def test_no_job(self):          with patch(\"src.taipy.gui_core._context.core_get\", side_effect=mock_core_get):              gui_core_context = _GuiCoreContext(Mock())              status = gui_core_context._get_submittable_status([])              assert status == _SubmissionStatus.UNDEFINED "}
{"text": "#  # Licensed under the Apache License, Version 2.0 (the \"License\"); you may not use this file except in compliance with  # the License. You may obtain a copy of the License at  #  #        http://www.apache.org/licenses/LICENSE-2.0  #  # Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on  # an \"AS IS\" BASIS, WITHOUT 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  from taipy.gui import Gui    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_readable_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_readable:      def test_scenario_adapter(self):          with patch(\"src.taipy.gui_core._context.core_get\", side_effect=mock_core_get):              gui_core_context = _GuiCoreContext(Mock())              outcome = gui_core_context.scenario_adapter(a_scenario)              assert isinstance(outcome, tuple)              assert outcome[0] == a_scenario.id                with patch(\"src.taipy.gui_core._context.is_readable\", side_effect=mock_is_readable_false):                  outcome = gui_core_context.scenario_adapter(a_scenario)                  assert outcome is None        def test_get_scenario_by_id(self):          with patch(\"src.taipy.gui_core._context.core_get\", side_effect=mock_core_get):              gui_core_context = _GuiCoreContext(Mock())              outcome = gui_core_context.get_scenario_by_id(a_scenario.id)              assert outcome is not None                with patch(\"src.taipy.gui_core._context.is_readable\", side_effect=mock_is_readable_false):                  outcome = gui_core_context.get_scenario_by_id(a_scenario.id)                  assert outcome is None        def test_crud_scenario(self):          with patch(\"src.taipy.gui_core._context.core_get\", side_effect=mock_core_get):              gui_core_context = _GuiCoreContext(Mock())              assign = Mock()              gui_core_context.crud_scenario(                  MockState(assign=assign),                  \"\",                  {                      \"args\": [                          True,                          False,                          {\"name\": \"name\", \"id\": a_scenario.id},                      ]                  },              )              assign.assert_not_called()                with patch(\"src.taipy.gui_core._context.is_readable\", side_effect=mock_is_readable_false):                  assign.reset_mock()                  gui_core_context.crud_scenario(                      MockState(assign=assign),                      \"\",                      {                          \"args\": [                              True,                              False,                              {\"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 readable.\")        def test_edit_entity(self):          with patch(\"src.taipy.gui_core._context.core_get\", side_effect=mock_core_get):              gui_core_context = _GuiCoreContext(Mock())              assign = Mock()              gui_core_context.edit_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 assign.call_args.args[1] == \"\"                with patch(\"src.taipy.gui_core._context.is_readable\", side_effect=mock_is_readable_false):                  assign.reset_mock()                  gui_core_context.edit_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 readable.\")        def test_scenario_status_callback(self):          with patch(\"src.taipy.gui_core._context.core_get\", side_effect=mock_core_get) as mockget:              mockget.reset_mock()              gui_core_context = _GuiCoreContext(Mock())              gui_core_context.scenario_status_callback(a_job.id)              mockget.assert_called()              found = False              for call in mockget.call_args_list:                  if call.args[0] == a_job.id:                      found = True                      break              assert found is True              mockget.reset_mock()                with patch(\"src.taipy.gui_core._context.is_readable\", side_effect=mock_is_readable_false):                  gui_core_context.scenario_status_callback(a_job.id)                  mockget.assert_not_called()        def test_data_node_adapter(self):          with patch(\"src.taipy.gui_core._context.core_get\", side_effect=mock_core_get):              gui_core_context = _GuiCoreContext(Mock())              outcome = gui_core_context.data_node_adapter(a_datanode)              assert isinstance(outcome, tuple)              assert outcome[0] == a_datanode.id                with patch(\"src.taipy.gui_core._context.is_readable\", side_effect=mock_is_readable_false):                  outcome = gui_core_context.data_node_adapter(a_datanode)                  assert outcome is None        def test_job_adapter(self):          with patch(\"src.taipy.gui_core._context.core_get\", side_effect=mock_core_get):              gui_core_context = _GuiCoreContext(Mock())              outcome = gui_core_context.job_adapter(a_job)              assert isinstance(outcome, tuple)              assert outcome[0] == a_job.id                with patch(\"src.taipy.gui_core._context.is_readable\", side_effect=mock_is_readable_false):                  outcome = gui_core_context.job_adapter(a_job)                  assert outcome is None        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 readable.\") == -1              assign.reset_mock()                gui_core_context.act_on_jobs(                  MockState(assign=assign),                  \"\",                  {                      \"args\": [                          {\"id\": [a_job.id], \"action\": \"cancel\"},                      ]                  },              )              assign.assert_called_once()              assert assign.call_args.args[0] == \"gui_core_js_error\"              assert str(assign.call_args.args[1]).find(\"is not readable.\") == -1              assign.reset_mock()                with patch(\"src.taipy.gui_core._context.is_readable\", side_effect=mock_is_readable_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.\")                  assign.reset_mock()                    gui_core_context.act_on_jobs(                      MockState(assign=assign),                      \"\",                      {                          \"args\": [                              {\"id\": [a_job.id], \"action\": \"cancel\"},                          ]                      },                  )                  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.\")        def test_edit_data_node(self):          with patch(\"src.taipy.gui_core._context.core_get\", side_effect=mock_core_get):              gui_core_context = _GuiCoreContext(Mock())              assign = Mock()              gui_core_context.edit_data_node(                  MockState(assign=assign),                  \"\",                  {                      \"args\": [                          {\"id\": a_datanode.id},                      ]                  },              )              assign.assert_called_once()              assert assign.call_args.args[0] == \"gui_core_dv_error\"              assert assign.call_args.args[1] == \"\"                with patch(\"src.taipy.gui_core._context.is_readable\", side_effect=mock_is_readable_false):                  assign.reset_mock()                  gui_core_context.edit_data_node(                      MockState(assign=assign),                      \"\",                      {                          \"args\": [                              {\"id\": a_datanode.id},                          ]                      },                  )                  assign.assert_called_once()                  assert assign.call_args.args[0] == \"gui_core_dv_error\"                  assert str(assign.call_args.args[1]).endswith(\"is not readable.\")        def test_lock_datanode_for_edit(self):          with patch(\"src.taipy.gui_core._context.core_get\", side_effect=mock_core_get):              mockGui = Mock(Gui)              mockGui._get_client_id = lambda: \"a_client_id\"              gui_core_context = _GuiCoreContext(mockGui)              assign = Mock()              gui_core_context.lock_datanode_for_edit(                  MockState(assign=assign),                  \"\",                  {                      \"args\": [                          {\"id\": a_datanode.id},                      ]                  },              )              assign.assert_called_once()              assert assign.call_args.args[0] == \"gui_core_dv_error\"              assert assign.call_args.args[1] == \"\"                with patch(\"src.taipy.gui_core._context.is_readable\", side_effect=mock_is_readable_false):                  assign.reset_mock()                  gui_core_context.lock_datanode_for_edit(                      MockState(assign=assign),                      \"\",                      {                          \"args\": [                              {\"id\": a_datanode.id},                          ]                      },                  )                  assign.assert_called_once()                  assert assign.call_args.args[0] == \"gui_core_dv_error\"                  assert str(assign.call_args.args[1]).endswith(\"is not readable.\")        def test_get_scenarios_for_owner(self):          with patch(\"src.taipy.gui_core._context.core_get\", side_effect=mock_core_get) as mockget:              gui_core_context = _GuiCoreContext(Mock())              gui_core_context.get_scenarios_for_owner(a_scenario.id)              mockget.assert_called_once()              mockget.reset_mock()                with patch(\"src.taipy.gui_core._context.is_readable\", side_effect=mock_is_readable_false):                  gui_core_context.scenario_status_callback(a_scenario.id)                  mockget.assert_not_called()        def test_update_data(self):          with patch(\"src.taipy.gui_core._context.core_get\", side_effect=mock_core_get):              mockGui = Mock(Gui)              mockGui._get_client_id = lambda: \"a_client_id\"              gui_core_context = _GuiCoreContext(mockGui)              assign = Mock()              gui_core_context.update_data(                  MockState(assign=assign),                  \"\",                  {                      \"args\": [                          {\"id\": a_datanode.id},                      ]                  },              )              assign.assert_called()              assert assign.call_args_list[0].args[0] == \"gui_core_dv_error\"              assert assign.call_args_list[0].args[1] == \"\"              assign.reset_mock()                with patch(\"src.taipy.gui_core._context.is_readable\", side_effect=mock_is_readable_false):                  gui_core_context.update_data(                      MockState(assign=assign),                      \"\",                      {                          \"args\": [                              {\"id\": a_datanode.id},                          ]                      },                  )                  assign.assert_called_once()                  assert assign.call_args.args[0] == \"gui_core_dv_error\"                  assert str(assign.call_args.args[1]).endswith(\"is not readable.\")        def test_tabular_data_edit(self):          with patch(\"src.taipy.gui_core._context.core_get\", side_effect=mock_core_get):              mockGui = Mock(Gui)              mockGui._get_client_id = lambda: \"a_client_id\"              gui_core_context = _GuiCoreContext(mockGui)              assign = Mock()              gui_core_context.tabular_data_edit(                  MockState(assign=assign),                  \"\",                  {                      \"user_data\": {\"dn_id\": a_datanode.id},                  },              )              assign.assert_called_once()              assert assign.call_args_list[0].args[0] == \"gui_core_dv_error\"              assert (                  assign.call_args_list[0].args[1]                  == \"Error updating Datanode tabular value: type does not support at[] indexer.\"              )              assign.reset_mock()                with patch(\"src.taipy.gui_core._context.is_readable\", side_effect=mock_is_readable_false):                  gui_core_context.tabular_data_edit(                      MockState(assign=assign),                      \"\",                      {                          \"user_data\": {\"dn_id\": a_datanode.id},                      },                  )                  assign.assert_called_once()                  assert assign.call_args.args[0] == \"gui_core_dv_error\"                  assert str(assign.call_args.args[1]).endswith(\"is not readable.\")        def test_get_data_node_tabular_data(self):          with patch(\"src.taipy.gui_core._context.core_get\", side_effect=mock_core_get) as mockget:              gui_core_context = _GuiCoreContext(Mock())              gui_core_context.get_data_node_tabular_data(a_datanode, a_datanode.id)              mockget.assert_called_once()              mockget.reset_mock()                with patch(\"src.taipy.gui_core._context.is_readable\", side_effect=mock_is_readable_false):                  gui_core_context.get_data_node_tabular_data(a_datanode, a_datanode.id)                  mockget.assert_not_called()        def test_get_data_node_tabular_columns(self):          with patch(\"src.taipy.gui_core._context.core_get\", side_effect=mock_core_get) as mockget:              gui_core_context = _GuiCoreContext(Mock())              gui_core_context.get_data_node_tabular_columns(a_datanode, a_datanode.id)              mockget.assert_called_once()              mockget.reset_mock()                with patch(\"src.taipy.gui_core._context.is_readable\", side_effect=mock_is_readable_false):                  gui_core_context.get_data_node_tabular_columns(a_datanode, a_datanode.id)                  mockget.assert_not_called()        def test_get_data_node_chart_config(self):          with patch(\"src.taipy.gui_core._context.core_get\", side_effect=mock_core_get) as mockget:              gui_core_context = _GuiCoreContext(Mock())              gui_core_context.get_data_node_chart_config(a_datanode, a_datanode.id)              mockget.assert_called_once()              mockget.reset_mock()                with patch(\"src.taipy.gui_core._context.is_readable\", side_effect=mock_is_readable_false):                  gui_core_context.get_data_node_chart_config(a_datanode, a_datanode.id)                  mockget.assert_not_called() "}
{"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.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  from taipy.gui import Gui    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_editable_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_editable:      def test_crud_scenario(self):          with patch(\"src.taipy.gui_core._context.core_get\", side_effect=mock_core_get):              gui_core_context = _GuiCoreContext(Mock())              assign = Mock()              gui_core_context.crud_scenario(                  MockState(assign=assign),                  \"\",                  {                      \"args\": [                          True,                          False,                          {\"name\": \"name\", \"id\": a_scenario.id},                      ]                  },              )              assign.assert_not_called()                with patch(\"src.taipy.gui_core._context.is_editable\", side_effect=mock_is_editable_false):                  assign.reset_mock()                  gui_core_context.crud_scenario(                      MockState(assign=assign),                      \"\",                      {                          \"args\": [                              True,                              False,                              {\"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 editable.\")        def test_edit_entity(self):          with patch(\"src.taipy.gui_core._context.core_get\", side_effect=mock_core_get):              gui_core_context = _GuiCoreContext(Mock())              assign = Mock()              gui_core_context.edit_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 assign.call_args.args[1] == \"\"                with patch(\"src.taipy.gui_core._context.is_editable\", side_effect=mock_is_editable_false):                  assign.reset_mock()                  gui_core_context.edit_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 editable.\")        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\": \"cancel\"},                      ]                  },              )              assign.assert_called_once()              assert assign.call_args.args[0] == \"gui_core_js_error\"              assert str(assign.call_args.args[1]).find(\"is not editable.\") == -1              assign.reset_mock()                with patch(\"src.taipy.gui_core._context.is_readable\", side_effect=mock_is_editable_false):                  gui_core_context.act_on_jobs(                      MockState(assign=assign),                      \"\",                      {                          \"args\": [                              {\"id\": [a_job.id], \"action\": \"cancel\"},                          ]                      },                  )                  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.\")        def test_edit_data_node(self):          with patch(\"src.taipy.gui_core._context.core_get\", side_effect=mock_core_get):              gui_core_context = _GuiCoreContext(Mock())              assign = Mock()              gui_core_context.edit_data_node(                  MockState(assign=assign),                  \"\",                  {                      \"args\": [                          {\"id\": a_datanode.id},                      ]                  },              )              assign.assert_called_once()              assert assign.call_args.args[0] == \"gui_core_dv_error\"              assert assign.call_args.args[1] == \"\"                with patch(\"src.taipy.gui_core._context.is_editable\", side_effect=mock_is_editable_false):                  assign.reset_mock()                  gui_core_context.edit_data_node(                      MockState(assign=assign),                      \"\",                      {                          \"args\": [                              {\"id\": a_datanode.id},                          ]                      },                  )                  assign.assert_called_once()                  assert assign.call_args.args[0] == \"gui_core_dv_error\"                  assert str(assign.call_args.args[1]).endswith(\"is not editable.\")        def test_lock_datanode_for_edit(self):          with patch(\"src.taipy.gui_core._context.core_get\", side_effect=mock_core_get):              mockGui = Mock(Gui)              mockGui._get_client_id = lambda: \"a_client_id\"              gui_core_context = _GuiCoreContext(mockGui)              assign = Mock()              gui_core_context.lock_datanode_for_edit(                  MockState(assign=assign),                  \"\",                  {                      \"args\": [                          {\"id\": a_datanode.id},                      ]                  },              )              assign.assert_called_once()              assert assign.call_args.args[0] == \"gui_core_dv_error\"              assert assign.call_args.args[1] == \"\"                with patch(\"src.taipy.gui_core._context.is_editable\", side_effect=mock_is_editable_false):                  assign.reset_mock()                  gui_core_context.lock_datanode_for_edit(                      MockState(assign=assign),                      \"\",                      {                          \"args\": [                              {\"id\": a_datanode.id},                          ]                      },                  )                  assign.assert_called_once()                  assert assign.call_args.args[0] == \"gui_core_dv_error\"                  assert str(assign.call_args.args[1]).endswith(\"is not editable.\")        def test_update_data(self):          with patch(\"src.taipy.gui_core._context.core_get\", side_effect=mock_core_get):              mockGui = Mock(Gui)              mockGui._get_client_id = lambda: \"a_client_id\"              gui_core_context = _GuiCoreContext(mockGui)              assign = Mock()              gui_core_context.update_data(                  MockState(assign=assign),                  \"\",                  {                      \"args\": [                          {\"id\": a_datanode.id},                      ]                  },              )              assign.assert_called()              assert assign.call_args_list[0].args[0] == \"gui_core_dv_error\"              assert assign.call_args_list[0].args[1] == \"\"              assign.reset_mock()                with patch(\"src.taipy.gui_core._context.is_editable\", side_effect=mock_is_editable_false):                  gui_core_context.update_data(                      MockState(assign=assign),                      \"\",                      {                          \"args\": [                              {\"id\": a_datanode.id},                          ]                      },                  )                  assign.assert_called_once()                  assert assign.call_args.args[0] == \"gui_core_dv_error\"                  assert str(assign.call_args.args[1]).endswith(\"is not editable.\")        def test_tabular_data_edit(self):          with patch(\"src.taipy.gui_core._context.core_get\", side_effect=mock_core_get):              mockGui = Mock(Gui)              mockGui._get_client_id = lambda: \"a_client_id\"              gui_core_context = _GuiCoreContext(mockGui)              assign = Mock()              gui_core_context.tabular_data_edit(                  MockState(assign=assign),                  \"\",                  {                      \"user_data\": {\"dn_id\": a_datanode.id},                  },              )              assign.assert_called_once()              assert assign.call_args_list[0].args[0] == \"gui_core_dv_error\"              assert (                  assign.call_args_list[0].args[1]                  == \"Error updating Datanode tabular value: type does not support at[] indexer.\"              )              assign.reset_mock()                with patch(\"src.taipy.gui_core._context.is_editable\", side_effect=mock_is_editable_false):                  gui_core_context.tabular_data_edit(                      MockState(assign=assign),                      \"\",                      {                          \"user_data\": {\"dn_id\": a_datanode.id},                      },                  )                  assign.assert_called_once()                  assert assign.call_args.args[0] == \"gui_core_dv_error\"                  assert str(assign.call_args.args[1]).endswith(\"is not editable.\") "}
{"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": "import os  import shutil  import uuid  from datetime import datetime, timedelta    import pandas as pd  import pytest  from dotenv import load_dotenv    from src.taipy.rest.app import create_app  from taipy.config import Config  from taipy.config.common.frequency import Frequency  from taipy.config.common.scope import Scope  from taipy.core import Cycle, DataNodeId, Job, JobId, Scenario, Sequence, Task  from taipy.core.cycle._cycle_manager import _CycleManager  from taipy.core.data.in_memory import InMemoryDataNode  from taipy.core.job._job_manager import _JobManager  from taipy.core.task._task_manager import _TaskManager    from .setup.shared.algorithms import evaluate, forecast      @pytest.fixture  def setup_end_to_end():      model_cfg = Config.configure_data_node(\"model\", path=\"setup/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=\"setup/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_config = Config.configure_scenario(          \"scenario\", [forecast_task_cfg, evaluate_task_cfg], frequency=Frequency.DAILY      )      scenario_config.add_sequences({\"sequence\": [forecast_task_cfg, evaluate_task_cfg]})      @pytest.fixture()  def app():      load_dotenv(\".testenv\")      app = create_app(testing=True)      app.config.update(          {              \"TESTING\": True,          }      )      with app.app_context(), app.test_request_context():          yield app      @pytest.fixture()  def client(app):      return app.test_client()      @pytest.fixture  def datanode_data():      return {          \"name\": \"foo\",          \"storage_type\": \"in_memory\",          \"scope\": \"scenario\",          \"default_data\": [\"1991-01-01T00:00:00\"],      }      @pytest.fixture  def task_data():      return {          \"config_id\": \"foo\",          \"input_ids\": [\"DATASOURCE_foo_3b888e17-1974-4a56-a42c-c7c96bc9cd54\"],          \"function_name\": \"print\",          \"function_module\": \"builtins\",          \"output_ids\": [\"DATASOURCE_foo_4d9923b8-eb9f-4f3c-8055-3a1ce8bee309\"],      }      @pytest.fixture  def sequence_data():      return {          \"name\": \"foo\",          \"task_ids\": [\"TASK_foo_3b888e17-1974-4a56-a42c-c7c96bc9cd54\"],      }      @pytest.fixture  def scenario_data():      return {          \"name\": \"foo\",          \"sequence_ids\": [\"SEQUENCE_foo_3b888e17-1974-4a56-a42c-c7c96bc9cd54\"],          \"properties\": {},      }      @pytest.fixture  def default_datanode():      return InMemoryDataNode(          \"input_ds\",          Scope.SCENARIO,          DataNodeId(\"f\"),          \"my name\",          \"owner_id\",          properties={\"default_data\": [1, 2, 3, 4, 5, 6]},      )      @pytest.fixture  def default_df_datanode():      return InMemoryDataNode(          \"input_ds\",          Scope.SCENARIO,          DataNodeId(\"id_uio2\"),          \"my name\",          \"owner_id\",          properties={\"default_data\": pd.DataFrame([{\"a\": 1, \"b\": 2}, {\"a\": 3, \"b\": 4}, {\"a\": 5, \"b\": 6}])},      )      @pytest.fixture  def default_datanode_config():      return Config.configure_data_node(f\"taipy_{uuid.uuid4().hex}\", \"in_memory\", Scope.SCENARIO)      @pytest.fixture  def default_datanode_config_list():      configs = []      for i in range(10):          configs.append(Config.configure_data_node(id=f\"ds_{i}\", storage_type=\"in_memory\", scope=Scope.SCENARIO))      return configs      def __default_task():      input_ds = InMemoryDataNode(          \"input_ds\",          Scope.SCENARIO,          DataNodeId(\"id_uio\"),          \"my name\",          \"owner_id\",          properties={\"default_data\": \"In memory Data Source\"},      )        output_ds = InMemoryDataNode(          \"output_ds\",          Scope.SCENARIO,          DataNodeId(\"id_uio\"),          \"my name\",          \"owner_id\",          properties={\"default_data\": \"In memory Data Source\"},      )      return Task(          config_id=\"foo\",          properties={},          function=print,          input=[input_ds],          output=[output_ds],          id=None,      )      @pytest.fixture  def default_task():      return __default_task()      @pytest.fixture  def default_task_config():      return Config.configure_task(\"task1\", print, [], [])      @pytest.fixture  def default_task_config_list():      configs = []      for i in range(10):          configs.append(Config.configure_task(f\"task_{i}\", print, [], []))      return configs      def __default_sequence():      return Sequence(properties={\"name\": \"foo\"}, tasks=[__default_task()], sequence_id=\"SEQUENCE_foo_SCENARIO_acb\")      def __task_config():      return Config.configure_task(\"task1\", print, [], [])      @pytest.fixture  def default_sequence():      return __default_sequence()      @pytest.fixture  def default_scenario_config():      task_config = __task_config()      scenario_config = Config.configure_scenario(          f\"taipy_{uuid.uuid4().hex}\",          [task_config],      )      scenario_config.add_sequences({\"sequence\": [task_config]})      return scenario_config      @pytest.fixture  def default_scenario_config_list():      configs = []      for _ in range(10):          task_config = Config.configure_task(f\"taipy_{uuid.uuid4().hex}\", print)          scenario_config = Config.configure_scenario(              f\"taipy_{uuid.uuid4().hex}\",              [task_config],          )          scenario_config.add_sequences({\"sequence\": [task_config]})          configs.append(scenario_config)      return configs      @pytest.fixture  def default_scenario():      return Scenario(config_id=\"foo\", properties={}, tasks=[__default_task()], scenario_id=\"SCENARIO_scenario_id\")      def __create_cycle(name=\"foo\"):      now = datetime.now()      return Cycle(          name=name,          frequency=Frequency.DAILY,          properties={},          creation_date=now,          start_date=now,          end_date=now + timedelta(days=5),      )      @pytest.fixture  def create_cycle_list():      cycles = []      manager = _CycleManager      for i in range(10):          c = __create_cycle(f\"cycle_{1}\")      return cycles      @pytest.fixture  def cycle_data():      return {          \"name\": \"foo\",          \"frequency\": \"daily\",          \"properties\": {},          \"creation_date\": \"2022-02-03T22:17:27.317114\",          \"start_date\": \"2022-02-03T22:17:27.317114\",          \"end_date\": \"2022-02-08T22:17:27.317114\",      }      @pytest.fixture  def default_cycle():      return __create_cycle()      def __create_job():      task_manager = _TaskManager      task = __default_task()      task_manager._set(task)      submit_id = f\"SUBMISSION_{str(uuid.uuid4())}\"      return Job(id=JobId(f\"JOB_{uuid.uuid4()}\"), task=task, submit_id=submit_id, submit_entity_id=task.id)      @pytest.fixture  def default_job():      return __create_job()      @pytest.fixture  def create_job_list():      jobs = []      manager = _JobManager      for i in range(10):          c = __create_job()      return jobs      @pytest.fixture(scope=\"function\", autouse=True)  def cleanup_files():      Config.unblock_update()      Config.configure_core(repository_type=\"filesystem\")        if os.path.exists(\".data\"):          shutil.rmtree(\".data\", ignore_errors=True)      if os.path.exists(\".my_data\"):          shutil.rmtree(\".my_data\", ignore_errors=True) "}
{"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    # Busiest US airports  # Source: https://en.wikipedia.org/wiki/List_of_busiest_airports_by_passenger_traffic  airports = {      \"AMS\": {\"lat\": 52.31047296675518, \"lon\": 4.76819929439927},      \"ATL\": {\"lat\": 33.64086185344307, \"lon\": -84.43600501711686},      \"AYT\": {\"lat\": 36.90419539293911, \"lon\": 30.801855337974292},      \"BOS\": {\"lat\": 42.36556559649881, \"lon\": -71.00960311751096},      \"CAN\": {\"lat\": 23.38848323741897, \"lon\": 113.30277713668413},      \"CDG\": {\"lat\": 49.008029034119915, \"lon\": 2.550879924581871},      \"CJU\": {\"lat\": 33.51035978854847, \"lon\": 126.4913319405336},      \"CKG\": {\"lat\": 29.71931573810283, \"lon\": 106.64211731662628},      \"CLT\": {\"lat\": 35.214730980190616, \"lon\": -80.9474735034797},      \"CSX\": {\"lat\": 28.196638298182446, \"lon\": 113.22083329905352},      \"CTU\": {\"lat\": 30.567492917634063, \"lon\": 103.94912193845805},      \"CUN\": {\"lat\": 21.04160313837335, \"lon\": -86.87407057500725},      \"DEL\": {\"lat\": 28.556426221725868, \"lon\": 77.10031185913002},      \"DEN\": {\"lat\": 39.85589532386815, \"lon\": -104.67329901305273},      \"DFW\": {\"lat\": 32.89998507111719, \"lon\": -97.04044513206443},      \"DME\": {\"lat\": 55.41032513421412, \"lon\": 37.902386927376234},      \"DTW\": {\"lat\": 42.216145762248594, \"lon\": -83.35541784824225},      \"DXB\": {\"lat\": 25.253155060720765, \"lon\": 55.365672799304534},      \"EWR\": {\"lat\": 40.68951508829295, \"lon\": -74.17446240095387},      \"FLL\": {\"lat\": 26.072469069499288, \"lon\": -80.1502073285754},      \"FRA\": {\"lat\": 50.037870541116, \"lon\": 8.562119610188235},      \"GMP\": {\"lat\": 37.558628944763534, \"lon\": 126.79445244110332},      \"GRU\": {\"lat\": -23.430691200492866, \"lon\": -46.473107371367846},      \"HGH\": {\"lat\": 30.2359856421667, \"lon\": 120.43880486944619},      \"HND\": {\"lat\": 35.54938443207139, \"lon\": 139.77979568388005},      \"IAH\": {\"lat\": 29.98997826322153, \"lon\": -95.33684707873988},      \"IST\": {\"lat\": 41.27696594578831, \"lon\": 28.73004303446375},      \"JFK\": {\"lat\": 40.64129497654287, \"lon\": -73.77813830094803},      \"KMG\": {\"lat\": 24.99723271310971, \"lon\": 102.74030761670535},      \"LAS\": {\"lat\": 36.08256046166282, \"lon\": -115.15700045025673},      \"LAX\": {\"lat\": 33.94157995977848, \"lon\": -118.40848708486908},      \"MAD\": {\"lat\": 40.49832400063489, \"lon\": -3.5676196584173754},      \"MCO\": {\"lat\": 28.419119921670067, \"lon\": -81.30451008534465},      \"MEX\": {\"lat\": 19.436096410278736, \"lon\": -99.07204777544095},      \"MIA\": {\"lat\": 25.795823878101675, \"lon\": -80.28701871639629},      \"MSP\": {\"lat\": 44.88471735079015, \"lon\": -93.22233824616785},      \"ORD\": {\"lat\": 41.98024003208415, \"lon\": -87.9089657513565},      \"PEK\": {\"lat\": 40.079816213451416, \"lon\": 116.60309064055198},      \"PHX\": {\"lat\": 33.43614430802288, \"lon\": -112.01128270596944},      \"PKX\": {\"lat\": 39.50978840400886, \"lon\": 116.41050689906415},      \"PVG\": {\"lat\": 31.144398958515847, \"lon\": 121.80823008537978},      \"SAW\": {\"lat\": 40.9053709590178, \"lon\": 29.316838841845318},      \"SEA\": {\"lat\": 47.448024349661814, \"lon\": -122.30897973141963},      \"SFO\": {\"lat\": 37.62122788155908, \"lon\": -122.37901977603573},      \"SHA\": {\"lat\": 31.192227319334787, \"lon\": 121.33425408454256},      \"SLC\": {\"lat\": 40.78985913031307, \"lon\": -111.97911351851535},      \"SVO\": {\"lat\": 55.97381026156798, \"lon\": 37.412288430689664},      \"SZX\": {\"lat\": 22.636827890877626, \"lon\": 113.81454162446936},      \"WUH\": {\"lat\": 30.776589409566686, \"lon\": 114.21244949898504},      \"XIY\": {\"lat\": 34.437119809208546, \"lon\": 108.7573508575816},  }    # Inter US airports flights  # Source: https://www.faa.gov/air_traffic/by_the_numbers  flights = [      {\"from\": \"ATL\", \"to\": \"DFW\", \"traffic\": 580},      {\"from\": \"ATL\", \"to\": \"MIA\", \"traffic\": 224},      {\"from\": \"BOS\", \"to\": \"LAX\", \"traffic\": 168},      {\"from\": \"DEN\", \"to\": \"DFW\", \"traffic\": 558},      {\"from\": \"DFW\", \"to\": \"BOS\", \"traffic\": 422},      {\"from\": \"DFW\", \"to\": \"CLT\", \"traffic\": 360},      {\"from\": \"DFW\", \"to\": \"JFK\", \"traffic\": 56},      {\"from\": \"DFW\", \"to\": \"LAS\", \"traffic\": 569},      {\"from\": \"DFW\", \"to\": \"SEA\", \"traffic\": 392},      {\"from\": \"DTW\", \"to\": \"DFW\", \"traffic\": 260},      {\"from\": \"EWR\", \"to\": \"DFW\", \"traffic\": 310},      {\"from\": \"EWR\", \"to\": \"ORD\", \"traffic\": 168},      {\"from\": \"FLL\", \"to\": \"DFW\", \"traffic\": 336},      {\"from\": \"FLL\", \"to\": \"ORD\", \"traffic\": 168},      {\"from\": \"IAH\", \"to\": \"DFW\", \"traffic\": 324},      {\"from\": \"JFK\", \"to\": \"FLL\", \"traffic\": 112},      {\"from\": \"JFK\", \"to\": \"LAS\", \"traffic\": 112},      {\"from\": \"JFK\", \"to\": \"LAX\", \"traffic\": 548},      {\"from\": \"JFK\", \"to\": \"ORD\", \"traffic\": 56},      {\"from\": \"LAS\", \"to\": \"MIA\", \"traffic\": 168},      {\"from\": \"LAX\", \"to\": \"DFW\", \"traffic\": 914},      {\"from\": \"LAX\", \"to\": \"EWR\", \"traffic\": 54},      {\"from\": \"LAX\", \"to\": \"LAS\", \"traffic\": 222},      {\"from\": \"LAX\", \"to\": \"MCO\", \"traffic\": 56},      {\"from\": \"LAX\", \"to\": \"MIA\", \"traffic\": 392},      {\"from\": \"LAX\", \"to\": \"SFO\", \"traffic\": 336},      {\"from\": \"MCO\", \"to\": \"DFW\", \"traffic\": 500},      {\"from\": \"MCO\", \"to\": \"JFK\", \"traffic\": 224},      {\"from\": \"MCO\", \"to\": \"ORD\", \"traffic\": 224},      {\"from\": \"MIA\", \"to\": \"BOS\", \"traffic\": 392},      {\"from\": \"MIA\", \"to\": \"DEN\", \"traffic\": 112},      {\"from\": \"MIA\", \"to\": \"DFW\", \"traffic\": 560},      {\"from\": \"MIA\", \"to\": \"DTW\", \"traffic\": 112},      {\"from\": \"MIA\", \"to\": \"EWR\", \"traffic\": 168},      {\"from\": \"MIA\", \"to\": \"IAH\", \"traffic\": 168},      {\"from\": \"MIA\", \"to\": \"JFK\", \"traffic\": 392},      {\"from\": \"MIA\", \"to\": \"MCO\", \"traffic\": 448},      {\"from\": \"MSP\", \"to\": \"DFW\", \"traffic\": 326},      {\"from\": \"MSP\", \"to\": \"MIA\", \"traffic\": 56},      {\"from\": \"ORD\", \"to\": \"BOS\", \"traffic\": 430},      {\"from\": \"ORD\", \"to\": \"DEN\", \"traffic\": 112},      {\"from\": \"ORD\", \"to\": \"DFW\", \"traffic\": 825},      {\"from\": \"ORD\", \"to\": \"LAS\", \"traffic\": 280},      {\"from\": \"ORD\", \"to\": \"LAX\", \"traffic\": 496},      {\"from\": \"ORD\", \"to\": \"MIA\", \"traffic\": 505},      {\"from\": \"ORD\", \"to\": \"MSP\", \"traffic\": 160},      {\"from\": \"ORD\", \"to\": \"PHX\", \"traffic\": 280},      {\"from\": \"ORD\", \"to\": \"SEA\", \"traffic\": 214},      {\"from\": \"ORD\", \"to\": \"SFO\", \"traffic\": 326},      {\"from\": \"PHX\", \"to\": \"DFW\", \"traffic\": 550},      {\"from\": \"PHX\", \"to\": \"MIA\", \"traffic\": 56},      {\"from\": \"SEA\", \"to\": \"JFK\", \"traffic\": 56},      {\"from\": \"SFO\", \"to\": \"DFW\", \"traffic\": 526},      {\"from\": \"SFO\", \"to\": \"JFK\", \"traffic\": 278},      {\"from\": \"SFO\", \"to\": \"MIA\", \"traffic\": 168},      {\"from\": \"SLC\", \"to\": \"DFW\", \"traffic\": 280},  ]    data = []  max_traffic = 0  for flight in flights:      airport_from = airports[flight[\"from\"]]      airport_to = airports[flight[\"to\"]]      # Define data source to plot this flight      data.append({\"lat\": [airport_from[\"lat\"], airport_to[\"lat\"]], \"lon\": [airport_from[\"lon\"], airport_to[\"lon\"]]})      # Store the maximum traffic      if flight[\"traffic\"] > max_traffic:          max_traffic = flight[\"traffic\"]    properties = {      # Chart data      \"data\": data,      # Chart type      \"type\": \"scattergeo\",      # Keep lines only      \"mode\": \"lines\",      # Flights display as redish lines      \"line\": {\"width\": 2, \"color\": \"E22\"},      \"layout\": {          # Focus on the USA region          \"geo\": {\"scope\": \"usa\"}      },  }    # Set the proper data source and opacity for each trace  for i, flight in enumerate(flights):      # lat[trace_index] = \"[index_in_data]/lat\"      properties[f\"lat[{i+1}]\"] = f\"{i}/lat\"      # lon[trace_index] = \"[index_in_data]/lon\"      properties[f\"lon[{i+1}]\"] = f\"{i}/lon\"      # Set flight opacity (max traffic -> max opacity)      # Hide legend for all flights      properties[f\"options[{i+1}]\"] = {\"opacity\": flight[\"traffic\"] / max_traffic, \"showlegend\": False}    page = \"\"\"  # Maps - Multiple Lines    <|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    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>  # -----------------------------------------------------------------------------------------  import pandas  from taipy.gui import Gui    dates = pandas.date_range(\"2023-01-01\", periods=365, freq=\"D\")  temp = [      -11.33333333,      -6,      -0.111111111,      1.444444444,      2.388888889,      4.555555556,      4.333333333,      0.666666667,      9,      9.611111111,      -0.555555556,      1.833333333,      -0.444444444,      2.166666667,      -4,      -12.05555556,      -2.722222222,      5,      9.888888889,      6.611111111,      -2.833333333,      -3.277777778,      -1.611111111,      -1.388888889,      5.777777778,      2.166666667,      -1.055555556,      1.777777778,      1.5,      8.444444444,      6.222222222,      -2.5,      -0.388888889,      6.111111111,      -1.5,      2.666666667,      -2.5,      0.611111111,      8.222222222,      2.333333333,      -9.333333333,      -7.666666667,      -6.277777778,      -0.611111111,      7.722222222,      6.111111111,      -4,      3.388888889,      9.333333333,      -6.333333333,      -15,      -12.94444444,      -8.722222222,      -6.222222222,      -2.833333333,      -2.5,      1.5,      3.444444444,      2.666666667,      0.888888889,      7.555555556,      12.66666667,      12.83333333,      1.777777778,      -0.111111111,      -1.055555556,      4.611111111,      11.16666667,      8.5,      0.5,      2.111111111,      4.722222222,      8.277777778,      10.66666667,      5.833333333,      5.555555556,      6.944444444,      1.722222222,      2.444444444,      6.111111111,      12.11111111,      15.55555556,      9.944444444,      10.27777778,      5.888888889,      1.388888889,      3.555555556,      1.222222222,      4.055555556,      7.833333333,      0.666666667,      10.05555556,      6.444444444,      4.555555556,      11,      3.555555556,      -0.555555556,      11.83333333,      7.222222222,      10.16666667,      17.5,      14.55555556,      6.777777778,      3.611111111,      5.888888889,      10.05555556,      16.61111111,      5.5,      7.055555556,      10.5,      1.555555556,      6.166666667,      11.05555556,      5.111111111,      6.055555556,      11,      11.05555556,      14.72222222,      19.16666667,      16.5,      12.61111111,      8.277777778,      6.611111111,      10.38888889,      15.38888889,      17.22222222,      18.27777778,      18.72222222,      17.05555556,      19.72222222,      16.83333333,      12.66666667,      11.66666667,      12.88888889,      14.77777778,      18,      19.44444444,      16.5,      9.722222222,      7.888888889,      13.72222222,      17.55555556,      18.27777778,      20.11111111,      21.66666667,      23.38888889,      23.5,      16.94444444,      16.27777778,      18.61111111,      20.83333333,      24.61111111,      18.27777778,      17.88888889,      22.27777778,      25.94444444,      25.27777778,      24.72222222,      25.61111111,      23.94444444,      26.33333333,      22.05555556,      20.83333333,      24.5,      27.83333333,      25.61111111,      23.11111111,      19.27777778,      16.44444444,      19.44444444,      17.22222222,      19.44444444,      22.16666667,      21.77777778,      17.38888889,      17.22222222,      23.88888889,      28.44444444,      29.44444444,      29.61111111,      21.05555556,      18.55555556,      25.27777778,      26.55555556,      24.55555556,      23.38888889,      22.55555556,      27.05555556,      27.66666667,      26.66666667,      27.61111111,      26.66666667,      24.77777778,      23,      26.5,      23.11111111,      19.83333333,      22.27777778,      24.61111111,      27.05555556,      27.05555556,      27.94444444,      27.33333333,      22.05555556,      21.5,      22,      19.72222222,      20.27777778,      17.88888889,      18.55555556,      18.94444444,      20,      22.05555556,      23.22222222,      24.38888889,      24.5,      24.5,      21.22222222,      20.83333333,      20.61111111,      22.05555556,      23.77777778,      24.16666667,      24.22222222,      21.83333333,      21.33333333,      21.88888889,      22.44444444,      23.11111111,      20.44444444,      16.88888889,      15.77777778,      17.44444444,      17.72222222,      23.11111111,      24.55555556,      24.88888889,      25.11111111,      25.27777778,      19.5,      19.55555556,      24.05555556,      24.27777778,      21.05555556,      19.88888889,      20.66666667,      20.27777778,      17.66666667,      16.44444444,      15.88888889,      18.44444444,      22.44444444,      23,      24.72222222,      24.16666667,      25.94444444,      24.44444444,      23.33333333,      25.22222222,      25,      23.88888889,      23.72222222,      18.94444444,      16.22222222,      19.5,      21.22222222,      19.72222222,      13.22222222,      11.88888889,      16.55555556,      10.05555556,      12.16666667,      11.5,      10.22222222,      17.27777778,      21.72222222,      13.83333333,      13,      6.944444444,      6.388888889,      4.222222222,      2.5,      1.111111111,      3.055555556,      6.388888889,      10.44444444,      -2,      -2.222222222,      4.388888889,      8.333333333,      11.11111111,      12.66666667,      10.88888889,      12.83333333,      14.16666667,      12.55555556,      12.05555556,      11.22222222,      12.44444444,      14.38888889,      12,      15.83333333,      6.722222222,      2.5,      4.833333333,      7.5,      8.888888889,      4,      7.388888889,      3.888888889,      1.611111111,      -0.333333333,      -2,      4.833333333,      -1.055555556,      -5.611111111,      -2.388888889,      5.722222222,      8.444444444,      5.277777778,      0.5,      -2.5,      1.111111111,      2.111111111,      5.777777778,      7.555555556,      7.555555556,      4.111111111,      -0.388888889,      -1,      4.944444444,      9.444444444,      4.722222222,      -0.166666667,      0.5,      -2.444444444,      -2.722222222,      -2.888888889,      -1.111111111,      -4.944444444,      -3.111111111,      -1.444444444,      -0.833333333,      2.333333333,      6.833333333,      4.722222222,      0.888888889,      0.666666667,      4.611111111,      4.666666667,      4.444444444,      6.777777778,      5.833333333,      0.5,      4.888888889,      1.444444444,      -2.111111111,      2.444444444,      -0.111111111,      -2.555555556,      -4.611111111,      -8.666666667,      -8.055555556,      1.555555556,      -4.777777778,  ]  min = [      -14.33333333,      -12.9,      -3.311111111,      -4.955555556,      -3.611111111,      0.555555556,      1.133333333,      -5.133333333,      2.3,      3.911111111,      -7.055555556,      -1.366666667,      -4.844444444,      -3.333333333,      -6.1,      -17.15555556,      -4.822222222,      0.4,      3.488888889,      4.211111111,      -6.433333333,      -7.577777778,      -7.111111111,      -7.088888889,      1.577777778,      -3.433333333,      -4.355555556,      -0.722222222,      -2.1,      2.044444444,      2.222222222,      -4.7,      -2.388888889,      4.111111111,      -5,      -0.133333333,      -5.3,      -2.288888889,      6.022222222,      -1.766666667,      -15.53333333,      -13.46666667,      -9.277777778,      -3.211111111,      3.122222222,      1.411111111,      -6.8,      1.388888889,      5.333333333,      -9.833333333,      -22,      -19.74444444,      -14.62222222,      -9.622222222,      -8.433333333,      -8.5,      -2.8,      0.144444444,      -3.233333333,      -3.411111111,      5.355555556,      8.366666667,      7.333333333,      -0.322222222,      -6.911111111,      -4.955555556,      -1.588888889,      4.966666667,      2.5,      -4.3,      -1.888888889,      -1.777777778,      2.477777778,      3.766666667,      0.533333333,      1.755555556,      2.944444444,      -4.977777778,      -4.055555556,      1.711111111,      6.011111111,      13.15555556,      5.044444444,      6.577777778,      3.388888889,      -1.011111111,      -0.244444444,      -2.477777778,      -1.444444444,      2.533333333,      -6.333333333,      4.255555556,      1.944444444,      0.855555556,      5.4,      -1.244444444,      -2.855555556,      4.833333333,      2.722222222,      6.466666667,      14.5,      9.855555556,      2.277777778,      -3.188888889,      0.788888889,      4.155555556,      13.41111111,      2.3,      0.855555556,      8.4,      -0.444444444,      1.166666667,      7.755555556,      -0.288888889,      -0.244444444,      8.7,      5.555555556,      8.222222222,      16.26666667,      14.4,      5.711111111,      5.177777778,      4.511111111,      5.988888889,      10.08888889,      10.52222222,      15.37777778,      12.42222222,      14.95555556,      15.22222222,      11.93333333,      6.866666667,      6.866666667,      9.688888889,      11.57777778,      12,      13.34444444,      11.3,      6.222222222,      2.088888889,      8.322222222,      14.05555556,      13.77777778,      16.91111111,      16.86666667,      16.68888889,      18.5,      12.54444444,      12.27777778,      15.91111111,      15.03333333,      22.11111111,      15.77777778,      13.68888889,      17.87777778,      19.94444444,      18.57777778,      18.62222222,      20.11111111,      17.14444444,      20.43333333,      15.75555556,      17.33333333,      20,      23.03333333,      19.61111111,      18.51111111,      15.27777778,      11.44444444,      13.64444444,      11.42222222,      16.14444444,      19.76666667,      18.77777778,      11.88888889,      12.32222222,      20.78888889,      25.04444444,      25.34444444,      23.81111111,      18.35555556,      11.85555556,      18.37777778,      23.15555556,      21.55555556,      17.48888889,      19.05555556,      20.25555556,      23.86666667,      23.86666667,      21.41111111,      21.16666667,      18.67777778,      18.1,      24.4,      19.01111111,      17.13333333,      18.27777778,      21.71111111,      22.85555556,      22.65555556,      25.14444444,      24.13333333,      17.95555556,      14.7,      15.1,      16.02222222,      14.27777778,      11.18888889,      13.65555556,      16.74444444,      16.7,      17.65555556,      16.62222222,      21.68888889,      19.6,      18.6,      15.52222222,      18.53333333,      17.01111111,      17.75555556,      20.47777778,      17.76666667,      22.22222222,      18.23333333,      17.83333333,      15.38888889,      19.64444444,      17.81111111,      15.44444444,      14.88888889,      13.07777778,      15.24444444,      11.82222222,      20.81111111,      21.45555556,      18.98888889,      19.71111111,      19.27777778,      12.7,      15.05555556,      19.15555556,      20.77777778,      15.35555556,      17.68888889,      18.26666667,      15.47777778,      12.76666667,      10.54444444,      13.38888889,      12.54444444,      19.84444444,      19.5,      21.92222222,      17.86666667,      22.44444444,      19.64444444,      20.73333333,      22.02222222,      19,      20.48888889,      19.02222222,      16.44444444,      14.22222222,      16.3,      16.42222222,      17.22222222,      8.322222222,      8.288888889,      13.95555556,      5.555555556,      5.666666667,      7.7,      4.022222222,      11.77777778,      16.42222222,      11.83333333,      9.7,      0.044444444,      3.688888889,      -2.077777778,      0.1,      -5.388888889,      -3.244444444,      0.688888889,      5.744444444,      -7.7,      -7.022222222,      -0.211111111,      4.833333333,      8.111111111,      5.766666667,      7.888888889,      10.43333333,      11.56666667,      10.15555556,      7.155555556,      4.522222222,      7.144444444,      10.88888889,      9.5,      12.13333333,      4.022222222,      -3.9,      1.433333333,      0.7,      3.188888889,      -1.7,      3.588888889,      -0.111111111,      -2.788888889,      -7.133333333,      -5,      0.733333333,      -7.555555556,      -12.51111111,      -8.188888889,      3.122222222,      2.944444444,      0.477777778,      -3.2,      -9.2,      -4.788888889,      -0.288888889,      1.077777778,      4.755555556,      5.455555556,      0.511111111,      -3.888888889,      -7.4,      -1.355555556,      5.144444444,      0.122222222,      -5.166666667,      -5,      -5.144444444,      -8.822222222,      -6.388888889,      -6.811111111,      -8.944444444,      -10.11111111,      -7.144444444,      -5.133333333,      -1.166666667,      1.833333333,      -1.477777778,      -1.811111111,      -2.433333333,      -1.188888889,      -2.333333333,      0.744444444,      1.877777778,      1.333333333,      -1.7,      0.888888889,      -3.855555556,      -8.211111111,      -1.055555556,      -4.211111111,      -7.355555556,      -8.111111111,      -10.96666667,      -13.05555556,      -4.644444444,      -7.577777778,  ]  max = [      -7.233333333,      -1.6,      5.488888889,      7.744444444,      6.188888889,      6.555555556,      10.53333333,      6.766666667,      14.1,      14.11111111,      2.044444444,      4.633333333,      2.055555556,      8.666666667,      -1.4,      -5.555555556,      4.177777778,      11.8,      15.58888889,      12.31111111,      3.666666667,      -0.977777778,      1.288888889,      4.211111111,      9.377777778,      5.266666667,      2.144444444,      3.977777778,      7.2,      11.94444444,      11.32222222,      4,      6.611111111,      8.211111111,      3.5,      8.866666667,      3.6,      3.711111111,      13.12222222,      7.833333333,      -3.333333333,      -2.166666667,      -2.877777778,      5.188888889,      13.12222222,      12.11111111,      -0.7,      6.688888889,      14.03333333,      -2.433333333,      -8.6,      -8.244444444,      -2.122222222,      -2.722222222,      1.266666667,      2.8,      5.7,      6.944444444,      5.066666667,      5.688888889,      13.35555556,      16.66666667,      17.33333333,      7.277777778,      6.388888889,      1.344444444,      9.111111111,      17.96666667,      12.8,      5.8,      6.911111111,      6.822222222,      11.87777778,      13.16666667,      9.233333333,      8.655555556,      10.04444444,      7.022222222,      7.644444444,      8.311111111,      16.71111111,      18.85555556,      12.14444444,      13.27777778,      11.18888889,      7.088888889,      8.255555556,      7.522222222,      9.955555556,      9.933333333,      4.866666667,      15.25555556,      9.244444444,      9.755555556,      14,      8.955555556,      2.344444444,      17.43333333,      12.12222222,      13.46666667,      23,      18.45555556,      12.77777778,      7.211111111,      8.588888889,      14.35555556,      19.01111111,      12.4,      9.155555556,      15.6,      4.955555556,      8.966666667,      16.95555556,      9.511111111,      10.15555556,      16,      14.45555556,      21.02222222,      25.76666667,      20.5,      15.71111111,      11.67777778,      12.81111111,      12.88888889,      17.58888889,      23.12222222,      21.77777778,      24.42222222,      20.05555556,      24.32222222,      18.83333333,      19.56666667,      14.96666667,      19.68888889,      18.57777778,      23,      23.34444444,      20.7,      11.82222222,      11.48888889,      17.52222222,      22.55555556,      20.47777778,      23.01111111,      27.86666667,      30.28888889,      30.3,      22.94444444,      18.57777778,      25.51111111,      24.13333333,      30.01111111,      24.77777778,      20.28888889,      28.67777778,      32.74444444,      31.37777778,      28.52222222,      31.81111111,      27.24444444,      32.53333333,      26.15555556,      24.63333333,      28.3,      31.23333333,      32.21111111,      28.21111111,      23.07777778,      21.64444444,      24.34444444,      19.62222222,      25.14444444,      24.46666667,      23.87777778,      21.28888889,      20.22222222,      29.98888889,      32.04444444,      36.44444444,      36.01111111,      24.85555556,      23.45555556,      29.17777778,      32.25555556,      28.75555556,      30.28888889,      28.85555556,      30.45555556,      31.26666667,      28.86666667,      33.31111111,      30.66666667,      28.67777778,      27.4,      32.2,      25.41111111,      22.23333333,      26.67777778,      30.21111111,      29.15555556,      29.65555556,      31.94444444,      31.43333333,      28.35555556,      24.8,      25.5,      25.42222222,      24.17777778,      20.88888889,      24.35555556,      25.54444444,      22,      27.95555556,      29.42222222,      28.88888889,      26.8,      28.2,      26.92222222,      24.13333333,      22.61111111,      26.15555556,      30.57777778,      30.86666667,      29.92222222,      27.33333333,      23.43333333,      24.68888889,      26.94444444,      28.81111111,      25.54444444,      22.48888889,      21.67777778,      19.74444444,      23.82222222,      25.91111111,      30.85555556,      28.48888889,      29.21111111,      28.37777778,      22.4,      25.55555556,      27.35555556,      30.67777778,      27.95555556,      25.98888889,      23.46666667,      25.37777778,      20.46666667,      22.54444444,      20.18888889,      22.24444444,      26.84444444,      25.8,      29.62222222,      26.36666667,      32.24444444,      29.84444444,      28.33333333,      31.22222222,      29.9,      29.98888889,      27.42222222,      25.54444444,      20.22222222,      24,      24.52222222,      25.02222222,      16.12222222,      17.58888889,      23.25555556,      15.75555556,      18.66666667,      18.4,      12.52222222,      20.07777778,      28.62222222,      17.23333333,      16.6,      13.34444444,      10.98888889,      9.522222222,      5.8,      6.811111111,      6.555555556,      12.18888889,      12.64444444,      4.2,      3.577777778,      8.888888889,      15.23333333,      16.11111111,      18.36666667,      16.98888889,      15.63333333,      16.46666667,      15.55555556,      15.65555556,      17.42222222,      18.74444444,      19.48888889,      15.9,      19.73333333,      13.02222222,      8.1,      8.933333333,      11.3,      12.38888889,      8.3,      12.38888889,      6.388888889,      4.211111111,      4.666666667,      0.7,      7.133333333,      2.344444444,      1.088888889,      0.111111111,      11.62222222,      10.84444444,      8.777777778,      3.5,      3.4,      7.211111111,      5.711111111,      9.677777778,      12.25555556,      10.15555556,      6.511111111,      4.911111111,      1.5,      11.44444444,      15.54444444,      8.122222222,      6.233333333,      7,      4.355555556,      0.277777778,      3.711111111,      2.888888889,      1.555555556,      3.888888889,      4.555555556,      5.666666667,      7.833333333,      9.833333333,      10.02222222,      6.288888889,      5.366666667,      11.41111111,      9.566666667,      9.744444444,      13.57777778,      9.433333333,      3.1,      11.08888889,      3.844444444,      2.488888889,      7.544444444,      4.488888889,      -0.455555556,      -2.111111111,      -3.566666667,      -1.955555556,      3.955555556,      1.222222222,  ]    start = 50  size = 100  data = {\"Date\": dates[start:size], \"Temp\u00b0C\": temp[start:size], \"Min\": min[start:size], \"Max\": max[start:size]}    page = \"\"\"  # Line - Style    <|{data}|chart|mode=lines|x=Date|y[1]=Temp\u00b0C|y[2]=Min|y[3]=Max|line[1]=dash|color[2]=blue|color[3]=red|>  \"\"\"    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>  # -----------------------------------------------------------------------------------------  import numpy  import pandas  from taipy.gui import Gui    # Largest cities: name, location and population  # Source: https://simplemaps.com/data/world-cities  cities = [      {\"name\": \"Tokyo\", \"lat\": 35.6839, \"lon\": 139.7744, \"population\": 39105000},      {\"name\": \"Jakarta\", \"lat\": -6.2146, \"lon\": 106.8451, \"population\": 35362000},      {\"name\": \"Delhi\", \"lat\": 28.6667, \"lon\": 77.2167, \"population\": 31870000},      {\"name\": \"Manila\", \"lat\": 14.6, \"lon\": 120.9833, \"population\": 23971000},      {\"name\": \"S\u00e3o Paulo\", \"lat\": -23.5504, \"lon\": -46.6339, \"population\": 22495000},      {\"name\": \"Seoul\", \"lat\": 37.56, \"lon\": 126.99, \"population\": 22394000},      {\"name\": \"Mumbai\", \"lat\": 19.0758, \"lon\": 72.8775, \"population\": 22186000},      {\"name\": \"Shanghai\", \"lat\": 31.1667, \"lon\": 121.4667, \"population\": 22118000},      {\"name\": \"Mexico City\", \"lat\": 19.4333, \"lon\": -99.1333, \"population\": 21505000},      {\"name\": \"Guangzhou\", \"lat\": 23.1288, \"lon\": 113.259, \"population\": 21489000},      {\"name\": \"Cairo\", \"lat\": 30.0444, \"lon\": 31.2358, \"population\": 19787000},      {\"name\": \"Beijing\", \"lat\": 39.904, \"lon\": 116.4075, \"population\": 19437000},      {\"name\": \"New York\", \"lat\": 40.6943, \"lon\": -73.9249, \"population\": 18713220},      {\"name\": \"Kolk\u0101ta\", \"lat\": 22.5727, \"lon\": 88.3639, \"population\": 18698000},      {\"name\": \"Moscow\", \"lat\": 55.7558, \"lon\": 37.6178, \"population\": 17693000},      {\"name\": \"Bangkok\", \"lat\": 13.75, \"lon\": 100.5167, \"population\": 17573000},      {\"name\": \"Dhaka\", \"lat\": 23.7289, \"lon\": 90.3944, \"population\": 16839000},      {\"name\": \"Buenos Aires\", \"lat\": -34.5997, \"lon\": -58.3819, \"population\": 16216000},      {\"name\": \"\u014csaka\", \"lat\": 34.752, \"lon\": 135.4582, \"population\": 15490000},      {\"name\": \"Lagos\", \"lat\": 6.45, \"lon\": 3.4, \"population\": 15487000},      {\"name\": \"Istanbul\", \"lat\": 41.01, \"lon\": 28.9603, \"population\": 15311000},      {\"name\": \"Karachi\", \"lat\": 24.86, \"lon\": 67.01, \"population\": 15292000},      {\"name\": \"Kinshasa\", \"lat\": -4.3317, \"lon\": 15.3139, \"population\": 15056000},      {\"name\": \"Shenzhen\", \"lat\": 22.535, \"lon\": 114.054, \"population\": 14678000},      {\"name\": \"Bangalore\", \"lat\": 12.9791, \"lon\": 77.5913, \"population\": 13999000},      {\"name\": \"Ho Chi Minh City\", \"lat\": 10.8167, \"lon\": 106.6333, \"population\": 13954000},      {\"name\": \"Tehran\", \"lat\": 35.7, \"lon\": 51.4167, \"population\": 13819000},      {\"name\": \"Los Angeles\", \"lat\": 34.1139, \"lon\": -118.4068, \"population\": 12750807},      {\"name\": \"Rio de Janeiro\", \"lat\": -22.9083, \"lon\": -43.1964, \"population\": 12486000},      {\"name\": \"Chengdu\", \"lat\": 30.66, \"lon\": 104.0633, \"population\": 11920000},      {\"name\": \"Baoding\", \"lat\": 38.8671, \"lon\": 115.4845, \"population\": 11860000},      {\"name\": \"Chennai\", \"lat\": 13.0825, \"lon\": 80.275, \"population\": 11564000},      {\"name\": \"Lahore\", \"lat\": 31.5497, \"lon\": 74.3436, \"population\": 11148000},      {\"name\": \"London\", \"lat\": 51.5072, \"lon\": -0.1275, \"population\": 11120000},      {\"name\": \"Paris\", \"lat\": 48.8566, \"lon\": 2.3522, \"population\": 11027000},      {\"name\": \"Tianjin\", \"lat\": 39.1467, \"lon\": 117.2056, \"population\": 10932000},      {\"name\": \"Linyi\", \"lat\": 35.0606, \"lon\": 118.3425, \"population\": 10820000},      {\"name\": \"Shijiazhuang\", \"lat\": 38.0422, \"lon\": 114.5086, \"population\": 10784600},      {\"name\": \"Zhengzhou\", \"lat\": 34.7492, \"lon\": 113.6605, \"population\": 10136000},      {\"name\": \"Nanyang\", \"lat\": 32.9987, \"lon\": 112.5292, \"population\": 10013600},      {\"name\": \"Hyder\u0101b\u0101d\", \"lat\": 17.3617, \"lon\": 78.4747, \"population\": 9840000},      {\"name\": \"Wuhan\", \"lat\": 30.5872, \"lon\": 114.2881, \"population\": 9729000},      {\"name\": \"Handan\", \"lat\": 36.6116, \"lon\": 114.4894, \"population\": 9549700},      {\"name\": \"Nagoya\", \"lat\": 35.1167, \"lon\": 136.9333, \"population\": 9522000},      {\"name\": \"Weifang\", \"lat\": 36.7167, \"lon\": 119.1, \"population\": 9373000},      {\"name\": \"Lima\", \"lat\": -12.06, \"lon\": -77.0375, \"population\": 8992000},      {\"name\": \"Zhoukou\", \"lat\": 33.625, \"lon\": 114.6418, \"population\": 8953172},      {\"name\": \"Luanda\", \"lat\": -8.8383, \"lon\": 13.2344, \"population\": 8883000},      {\"name\": \"Ganzhou\", \"lat\": 25.8292, \"lon\": 114.9336, \"population\": 8677600},      {\"name\": \"Tongshan\", \"lat\": 34.261, \"lon\": 117.1859, \"population\": 8669000},      {\"name\": \"Kuala Lumpur\", \"lat\": 3.1478, \"lon\": 101.6953, \"population\": 8639000},      {\"name\": \"Chicago\", \"lat\": 41.8373, \"lon\": -87.6862, \"population\": 8604203},      {\"name\": \"Heze\", \"lat\": 35.2333, \"lon\": 115.4333, \"population\": 8287693},      {\"name\": \"Chongqing\", \"lat\": 29.55, \"lon\": 106.5069, \"population\": 8261000},      {\"name\": \"Hanoi\", \"lat\": 21.0245, \"lon\": 105.8412, \"population\": 8246600},      {\"name\": \"Fuyang\", \"lat\": 32.8986, \"lon\": 115.8045, \"population\": 8200264},      {\"name\": \"Changsha\", \"lat\": 28.1987, \"lon\": 112.9709, \"population\": 8154700},      {\"name\": \"Dongguan\", \"lat\": 23.0475, \"lon\": 113.7493, \"population\": 8142000},      {\"name\": \"Jining\", \"lat\": 35.4, \"lon\": 116.5667, \"population\": 8081905},      {\"name\": \"Jinan\", \"lat\": 36.6667, \"lon\": 116.9833, \"population\": 7967400},      {\"name\": \"Pune\", \"lat\": 18.5196, \"lon\": 73.8553, \"population\": 7948000},      {\"name\": \"Foshan\", \"lat\": 23.0292, \"lon\": 113.1056, \"population\": 7905700},      {\"name\": \"Bogot\u00e1\", \"lat\": 4.6126, \"lon\": -74.0705, \"population\": 7743955},      {\"name\": \"Ahmedabad\", \"lat\": 23.03, \"lon\": 72.58, \"population\": 7717000},      {\"name\": \"Nanjing\", \"lat\": 32.05, \"lon\": 118.7667, \"population\": 7729000},      {\"name\": \"Changchun\", \"lat\": 43.9, \"lon\": 125.2, \"population\": 7674439},      {\"name\": \"Tangshan\", \"lat\": 39.6292, \"lon\": 118.1742, \"population\": 7577289},      {\"name\": \"Cangzhou\", \"lat\": 38.3037, \"lon\": 116.8452, \"population\": 7544300},      {\"name\": \"Dar es Salaam\", \"lat\": -6.8, \"lon\": 39.2833, \"population\": 7461000},      {\"name\": \"Hefei\", \"lat\": 31.8639, \"lon\": 117.2808, \"population\": 7457027},      {\"name\": \"Hong Kong\", \"lat\": 22.3069, \"lon\": 114.1831, \"population\": 7398000},      {\"name\": \"Shaoyang\", \"lat\": 27.2418, \"lon\": 111.4725, \"population\": 7370500},      {\"name\": \"Zhanjiang\", \"lat\": 21.1967, \"lon\": 110.4031, \"population\": 7332000},      {\"name\": \"Shangqiu\", \"lat\": 34.4259, \"lon\": 115.6467, \"population\": 7325300},      {\"name\": \"Nantong\", \"lat\": 31.9829, \"lon\": 120.8873, \"population\": 7283622},      {\"name\": \"Yancheng\", \"lat\": 33.3936, \"lon\": 120.1339, \"population\": 7260240},      {\"name\": \"Nanning\", \"lat\": 22.8192, \"lon\": 108.315, \"population\": 7254100},      {\"name\": \"Hengyang\", \"lat\": 26.8968, \"lon\": 112.5857, \"population\": 7243400},      {\"name\": \"Zhumadian\", \"lat\": 32.9773, \"lon\": 114.0253, \"population\": 7231234},      {\"name\": \"Shenyang\", \"lat\": 41.8039, \"lon\": 123.4258, \"population\": 7208000},      {\"name\": \"Xingtai\", \"lat\": 37.0659, \"lon\": 114.4753, \"population\": 7104103},      {\"name\": \"Xi\u2019an\", \"lat\": 34.2667, \"lon\": 108.9, \"population\": 7090000},      {\"name\": \"Santiago\", \"lat\": -33.45, \"lon\": -70.6667, \"population\": 7026000},      {\"name\": \"Yantai\", \"lat\": 37.3997, \"lon\": 121.2664, \"population\": 6968202},      {\"name\": \"Riyadh\", \"lat\": 24.65, \"lon\": 46.71, \"population\": 6889000},      {\"name\": \"Luoyang\", \"lat\": 34.6587, \"lon\": 112.4245, \"population\": 6888500},      {\"name\": \"Kunming\", \"lat\": 25.0433, \"lon\": 102.7061, \"population\": 6850000},      {\"name\": \"Shangrao\", \"lat\": 28.4419, \"lon\": 117.9633, \"population\": 6810700},      {\"name\": \"Hangzhou\", \"lat\": 30.25, \"lon\": 120.1675, \"population\": 6713000},      {\"name\": \"Bijie\", \"lat\": 27.3019, \"lon\": 105.2863, \"population\": 6686100},      {\"name\": \"Quanzhou\", \"lat\": 24.9139, \"lon\": 118.5858, \"population\": 6480000},      {\"name\": \"Miami\", \"lat\": 25.7839, \"lon\": -80.2102, \"population\": 6445545},      {\"name\": \"Wuxi\", \"lat\": 31.5667, \"lon\": 120.2833, \"population\": 6372624},      {\"name\": \"Huanggang\", \"lat\": 30.45, \"lon\": 114.875, \"population\": 6333000},      {\"name\": \"Maoming\", \"lat\": 21.6618, \"lon\": 110.9178, \"population\": 6313200},      {\"name\": \"Nanchong\", \"lat\": 30.7991, \"lon\": 106.0784, \"population\": 6278614},      {\"name\": \"Zunyi\", \"lat\": 27.705, \"lon\": 106.9336, \"population\": 6270700},      {\"name\": \"Qujing\", \"lat\": 25.5102, \"lon\": 103.8029, \"population\": 6155400},      {\"name\": \"Baghdad\", \"lat\": 33.35, \"lon\": 44.4167, \"population\": 6107000},      {\"name\": \"Xinyang\", \"lat\": 32.1264, \"lon\": 114.0672, \"population\": 6109106},  ]    # Convert to Pandas DataFrame  data = pandas.DataFrame(cities)    # Add a column holding the bubble size:  #   Min(population) -> size =  5  #   Max(population) -> size = 60  solve = numpy.linalg.solve([[data[\"population\"].min(), 1], [data[\"population\"].max(), 1]], [5, 60])  data[\"size\"] = data[\"population\"].apply(lambda p: p * solve[0] + solve[1])    # Add a column holding the bubble hover texts  # Format is \"<city name> [<population>]\"  data[\"text\"] = data.apply(lambda row: f\"{row['name']} [{row['population']}]\", axis=1)    marker = {      # Use the \"size\" column to set the bubble size      \"size\": \"size\"  }    layout = {\"geo\": {\"showland\": True, \"landcolor\": \"4A4\"}}    page = \"\"\"  # Maps - Bubbles    <|{data}|chart|type=scattergeo|lat=lat|lon=lon|mode=markers|marker={marker}|text=text|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>  # -----------------------------------------------------------------------------------------  # 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>  # -----------------------------------------------------------------------------------------  import numpy  import pandas  from taipy.gui import Gui    dates = pandas.date_range(\"2023-01-01\", periods=365, freq=\"D\")  temp = [      -11.33333333,      -6,      -0.111111111,      1.444444444,      2.388888889,      4.555555556,      4.333333333,      0.666666667,      9,      9.611111111,      -0.555555556,      1.833333333,      -0.444444444,      2.166666667,      -4,      -12.05555556,      -2.722222222,      5,      9.888888889,      6.611111111,      -2.833333333,      -3.277777778,      -1.611111111,      -1.388888889,      5.777777778,      2.166666667,      -1.055555556,      1.777777778,      1.5,      8.444444444,      6.222222222,      -2.5,      -0.388888889,      6.111111111,      -1.5,      2.666666667,      -2.5,      0.611111111,      8.222222222,      2.333333333,      -9.333333333,      -7.666666667,      -6.277777778,      -0.611111111,      7.722222222,      6.111111111,      -4,      3.388888889,      9.333333333,      -6.333333333,      -15,      -12.94444444,      -8.722222222,      -6.222222222,      -2.833333333,      -2.5,      1.5,      3.444444444,      2.666666667,      0.888888889,      7.555555556,      12.66666667,      12.83333333,      1.777777778,      -0.111111111,      -1.055555556,      4.611111111,      11.16666667,      8.5,      0.5,      2.111111111,      4.722222222,      8.277777778,      10.66666667,      5.833333333,      5.555555556,      6.944444444,      1.722222222,      2.444444444,      6.111111111,      12.11111111,      15.55555556,      9.944444444,      10.27777778,      5.888888889,      1.388888889,      3.555555556,      1.222222222,      4.055555556,      7.833333333,      0.666666667,      10.05555556,      6.444444444,      4.555555556,      11,      3.555555556,      -0.555555556,      11.83333333,      7.222222222,      10.16666667,      17.5,      14.55555556,      6.777777778,      3.611111111,      5.888888889,      10.05555556,      16.61111111,      5.5,      7.055555556,      10.5,      1.555555556,      6.166666667,      11.05555556,      5.111111111,      6.055555556,      11,      11.05555556,      14.72222222,      19.16666667,      16.5,      12.61111111,      8.277777778,      6.611111111,      10.38888889,      15.38888889,      17.22222222,      18.27777778,      18.72222222,      17.05555556,      19.72222222,      16.83333333,      12.66666667,      11.66666667,      12.88888889,      14.77777778,      18,      19.44444444,      16.5,      9.722222222,      7.888888889,      13.72222222,      17.55555556,      18.27777778,      20.11111111,      21.66666667,      23.38888889,      23.5,      16.94444444,      16.27777778,      18.61111111,      20.83333333,      24.61111111,      18.27777778,      17.88888889,      22.27777778,      25.94444444,      25.27777778,      24.72222222,      25.61111111,      23.94444444,      26.33333333,      22.05555556,      20.83333333,      24.5,      27.83333333,      25.61111111,      23.11111111,      19.27777778,      16.44444444,      19.44444444,      17.22222222,      19.44444444,      22.16666667,      21.77777778,      17.38888889,      17.22222222,      23.88888889,      28.44444444,      29.44444444,      29.61111111,      21.05555556,      18.55555556,      25.27777778,      26.55555556,      24.55555556,      23.38888889,      22.55555556,      27.05555556,      27.66666667,      26.66666667,      27.61111111,      26.66666667,      24.77777778,      23,      26.5,      23.11111111,      19.83333333,      22.27777778,      24.61111111,      27.05555556,      27.05555556,      27.94444444,      27.33333333,      22.05555556,      21.5,      22,      19.72222222,      20.27777778,      17.88888889,      18.55555556,      18.94444444,      20,      22.05555556,      23.22222222,      24.38888889,      24.5,      24.5,      21.22222222,      20.83333333,      20.61111111,      22.05555556,      23.77777778,      24.16666667,      24.22222222,      21.83333333,      21.33333333,      21.88888889,      22.44444444,      23.11111111,      20.44444444,      16.88888889,      15.77777778,      17.44444444,      17.72222222,      23.11111111,      24.55555556,      24.88888889,      25.11111111,      25.27777778,      19.5,      19.55555556,      24.05555556,      24.27777778,      21.05555556,      19.88888889,      20.66666667,      20.27777778,      17.66666667,      16.44444444,      15.88888889,      18.44444444,      22.44444444,      23,      24.72222222,      24.16666667,      25.94444444,      24.44444444,      23.33333333,      25.22222222,      25,      23.88888889,      23.72222222,      18.94444444,      16.22222222,      19.5,      21.22222222,      19.72222222,      13.22222222,      11.88888889,      16.55555556,      10.05555556,      12.16666667,      11.5,      10.22222222,      17.27777778,      21.72222222,      13.83333333,      13,      6.944444444,      6.388888889,      4.222222222,      2.5,      1.111111111,      3.055555556,      6.388888889,      10.44444444,      -2,      -2.222222222,      4.388888889,      8.333333333,      11.11111111,      12.66666667,      10.88888889,      12.83333333,      14.16666667,      12.55555556,      12.05555556,      11.22222222,      12.44444444,      14.38888889,      12,      15.83333333,      6.722222222,      2.5,      4.833333333,      7.5,      8.888888889,      4,      7.388888889,      3.888888889,      1.611111111,      -0.333333333,      -2,      4.833333333,      -1.055555556,      -5.611111111,      -2.388888889,      5.722222222,      8.444444444,      5.277777778,      0.5,      -2.5,      1.111111111,      2.111111111,      5.777777778,      7.555555556,      7.555555556,      4.111111111,      -0.388888889,      -1,      4.944444444,      9.444444444,      4.722222222,      -0.166666667,      0.5,      -2.444444444,      -2.722222222,      -2.888888889,      -1.111111111,      -4.944444444,      -3.111111111,      -1.444444444,      -0.833333333,      2.333333333,      6.833333333,      4.722222222,      0.888888889,      0.666666667,      4.611111111,      4.666666667,      4.444444444,      6.777777778,      5.833333333,      0.5,      4.888888889,      1.444444444,      -2.111111111,      2.444444444,      -0.111111111,      -2.555555556,      -4.611111111,      -8.666666667,      -8.055555556,      1.555555556,      -4.777777778,  ]  min = [      -14.33333333,      -12.9,      -3.311111111,      -4.955555556,      -3.611111111,      0.555555556,      1.133333333,      -5.133333333,      2.3,      3.911111111,      -7.055555556,      -1.366666667,      -4.844444444,      -3.333333333,      -6.1,      -17.15555556,      -4.822222222,      0.4,      3.488888889,      4.211111111,      -6.433333333,      -7.577777778,      -7.111111111,      -7.088888889,      1.577777778,      -3.433333333,      -4.355555556,      -0.722222222,      -2.1,      2.044444444,      2.222222222,      -4.7,      -2.388888889,      4.111111111,      -5,      -0.133333333,      -5.3,      -2.288888889,      6.022222222,      -1.766666667,      -15.53333333,      -13.46666667,      -9.277777778,      -3.211111111,      3.122222222,      1.411111111,      -6.8,      1.388888889,      5.333333333,      -9.833333333,      -22,      -19.74444444,      -14.62222222,      -9.622222222,      -8.433333333,      -8.5,      -2.8,      0.144444444,      -3.233333333,      -3.411111111,      5.355555556,      8.366666667,      7.333333333,      -0.322222222,      -6.911111111,      -4.955555556,      -1.588888889,      4.966666667,      2.5,      -4.3,      -1.888888889,      -1.777777778,      2.477777778,      3.766666667,      0.533333333,      1.755555556,      2.944444444,      -4.977777778,      -4.055555556,      1.711111111,      6.011111111,      13.15555556,      5.044444444,      6.577777778,      3.388888889,      -1.011111111,      -0.244444444,      -2.477777778,      -1.444444444,      2.533333333,      -6.333333333,      4.255555556,      1.944444444,      0.855555556,      5.4,      -1.244444444,      -2.855555556,      4.833333333,      2.722222222,      6.466666667,      14.5,      9.855555556,      2.277777778,      -3.188888889,      0.788888889,      4.155555556,      13.41111111,      2.3,      0.855555556,      8.4,      -0.444444444,      1.166666667,      7.755555556,      -0.288888889,      -0.244444444,      8.7,      5.555555556,      8.222222222,      16.26666667,      14.4,      5.711111111,      5.177777778,      4.511111111,      5.988888889,      10.08888889,      10.52222222,      15.37777778,      12.42222222,      14.95555556,      15.22222222,      11.93333333,      6.866666667,      6.866666667,      9.688888889,      11.57777778,      12,      13.34444444,      11.3,      6.222222222,      2.088888889,      8.322222222,      14.05555556,      13.77777778,      16.91111111,      16.86666667,      16.68888889,      18.5,      12.54444444,      12.27777778,      15.91111111,      15.03333333,      22.11111111,      15.77777778,      13.68888889,      17.87777778,      19.94444444,      18.57777778,      18.62222222,      20.11111111,      17.14444444,      20.43333333,      15.75555556,      17.33333333,      20,      23.03333333,      19.61111111,      18.51111111,      15.27777778,      11.44444444,      13.64444444,      11.42222222,      16.14444444,      19.76666667,      18.77777778,      11.88888889,      12.32222222,      20.78888889,      25.04444444,      25.34444444,      23.81111111,      18.35555556,      11.85555556,      18.37777778,      23.15555556,      21.55555556,      17.48888889,      19.05555556,      20.25555556,      23.86666667,      23.86666667,      21.41111111,      21.16666667,      18.67777778,      18.1,      24.4,      19.01111111,      17.13333333,      18.27777778,      21.71111111,      22.85555556,      22.65555556,      25.14444444,      24.13333333,      17.95555556,      14.7,      15.1,      16.02222222,      14.27777778,      11.18888889,      13.65555556,      16.74444444,      16.7,      17.65555556,      16.62222222,      21.68888889,      19.6,      18.6,      15.52222222,      18.53333333,      17.01111111,      17.75555556,      20.47777778,      17.76666667,      22.22222222,      18.23333333,      17.83333333,      15.38888889,      19.64444444,      17.81111111,      15.44444444,      14.88888889,      13.07777778,      15.24444444,      11.82222222,      20.81111111,      21.45555556,      18.98888889,      19.71111111,      19.27777778,      12.7,      15.05555556,      19.15555556,      20.77777778,      15.35555556,      17.68888889,      18.26666667,      15.47777778,      12.76666667,      10.54444444,      13.38888889,      12.54444444,      19.84444444,      19.5,      21.92222222,      17.86666667,      22.44444444,      19.64444444,      20.73333333,      22.02222222,      19,      20.48888889,      19.02222222,      16.44444444,      14.22222222,      16.3,      16.42222222,      17.22222222,      8.322222222,      8.288888889,      13.95555556,      5.555555556,      5.666666667,      7.7,      4.022222222,      11.77777778,      16.42222222,      11.83333333,      9.7,      0.044444444,      3.688888889,      -2.077777778,      0.1,      -5.388888889,      -3.244444444,      0.688888889,      5.744444444,      -7.7,      -7.022222222,      -0.211111111,      4.833333333,      8.111111111,      5.766666667,      7.888888889,      10.43333333,      11.56666667,      10.15555556,      7.155555556,      4.522222222,      7.144444444,      10.88888889,      9.5,      12.13333333,      4.022222222,      -3.9,      1.433333333,      0.7,      3.188888889,      -1.7,      3.588888889,      -0.111111111,      -2.788888889,      -7.133333333,      -5,      0.733333333,      -7.555555556,      -12.51111111,      -8.188888889,      3.122222222,      2.944444444,      0.477777778,      -3.2,      -9.2,      -4.788888889,      -0.288888889,      1.077777778,      4.755555556,      5.455555556,      0.511111111,      -3.888888889,      -7.4,      -1.355555556,      5.144444444,      0.122222222,      -5.166666667,      -5,      -5.144444444,      -8.822222222,      -6.388888889,      -6.811111111,      -8.944444444,      -10.11111111,      -7.144444444,      -5.133333333,      -1.166666667,      1.833333333,      -1.477777778,      -1.811111111,      -2.433333333,      -1.188888889,      -2.333333333,      0.744444444,      1.877777778,      1.333333333,      -1.7,      0.888888889,      -3.855555556,      -8.211111111,      -1.055555556,      -4.211111111,      -7.355555556,      -8.111111111,      -10.96666667,      -13.05555556,      -4.644444444,      -7.577777778,  ]  max = [      -7.233333333,      -1.6,      5.488888889,      7.744444444,      6.188888889,      6.555555556,      10.53333333,      6.766666667,      14.1,      14.11111111,      2.044444444,      4.633333333,      2.055555556,      8.666666667,      -1.4,      -5.555555556,      4.177777778,      11.8,      15.58888889,      12.31111111,      3.666666667,      -0.977777778,      1.288888889,      4.211111111,      9.377777778,      5.266666667,      2.144444444,      3.977777778,      7.2,      11.94444444,      11.32222222,      4,      6.611111111,      8.211111111,      3.5,      8.866666667,      3.6,      3.711111111,      13.12222222,      7.833333333,      -3.333333333,      -2.166666667,      -2.877777778,      5.188888889,      13.12222222,      12.11111111,      -0.7,      6.688888889,      14.03333333,      -2.433333333,      -8.6,      -8.244444444,      -2.122222222,      -2.722222222,      1.266666667,      2.8,      5.7,      6.944444444,      5.066666667,      5.688888889,      13.35555556,      16.66666667,      17.33333333,      7.277777778,      6.388888889,      1.344444444,      9.111111111,      17.96666667,      12.8,      5.8,      6.911111111,      6.822222222,      11.87777778,      13.16666667,      9.233333333,      8.655555556,      10.04444444,      7.022222222,      7.644444444,      8.311111111,      16.71111111,      18.85555556,      12.14444444,      13.27777778,      11.18888889,      7.088888889,      8.255555556,      7.522222222,      9.955555556,      9.933333333,      4.866666667,      15.25555556,      9.244444444,      9.755555556,      14,      8.955555556,      2.344444444,      17.43333333,      12.12222222,      13.46666667,      23,      18.45555556,      12.77777778,      7.211111111,      8.588888889,      14.35555556,      19.01111111,      12.4,      9.155555556,      15.6,      4.955555556,      8.966666667,      16.95555556,      9.511111111,      10.15555556,      16,      14.45555556,      21.02222222,      25.76666667,      20.5,      15.71111111,      11.67777778,      12.81111111,      12.88888889,      17.58888889,      23.12222222,      21.77777778,      24.42222222,      20.05555556,      24.32222222,      18.83333333,      19.56666667,      14.96666667,      19.68888889,      18.57777778,      23,      23.34444444,      20.7,      11.82222222,      11.48888889,      17.52222222,      22.55555556,      20.47777778,      23.01111111,      27.86666667,      30.28888889,      30.3,      22.94444444,      18.57777778,      25.51111111,      24.13333333,      30.01111111,      24.77777778,      20.28888889,      28.67777778,      32.74444444,      31.37777778,      28.52222222,      31.81111111,      27.24444444,      32.53333333,      26.15555556,      24.63333333,      28.3,      31.23333333,      32.21111111,      28.21111111,      23.07777778,      21.64444444,      24.34444444,      19.62222222,      25.14444444,      24.46666667,      23.87777778,      21.28888889,      20.22222222,      29.98888889,      32.04444444,      36.44444444,      36.01111111,      24.85555556,      23.45555556,      29.17777778,      32.25555556,      28.75555556,      30.28888889,      28.85555556,      30.45555556,      31.26666667,      28.86666667,      33.31111111,      30.66666667,      28.67777778,      27.4,      32.2,      25.41111111,      22.23333333,      26.67777778,      30.21111111,      29.15555556,      29.65555556,      31.94444444,      31.43333333,      28.35555556,      24.8,      25.5,      25.42222222,      24.17777778,      20.88888889,      24.35555556,      25.54444444,      22,      27.95555556,      29.42222222,      28.88888889,      26.8,      28.2,      26.92222222,      24.13333333,      22.61111111,      26.15555556,      30.57777778,      30.86666667,      29.92222222,      27.33333333,      23.43333333,      24.68888889,      26.94444444,      28.81111111,      25.54444444,      22.48888889,      21.67777778,      19.74444444,      23.82222222,      25.91111111,      30.85555556,      28.48888889,      29.21111111,      28.37777778,      22.4,      25.55555556,      27.35555556,      30.67777778,      27.95555556,      25.98888889,      23.46666667,      25.37777778,      20.46666667,      22.54444444,      20.18888889,      22.24444444,      26.84444444,      25.8,      29.62222222,      26.36666667,      32.24444444,      29.84444444,      28.33333333,      31.22222222,      29.9,      29.98888889,      27.42222222,      25.54444444,      20.22222222,      24,      24.52222222,      25.02222222,      16.12222222,      17.58888889,      23.25555556,      15.75555556,      18.66666667,      18.4,      12.52222222,      20.07777778,      28.62222222,      17.23333333,      16.6,      13.34444444,      10.98888889,      9.522222222,      5.8,      6.811111111,      6.555555556,      12.18888889,      12.64444444,      4.2,      3.577777778,      8.888888889,      15.23333333,      16.11111111,      18.36666667,      16.98888889,      15.63333333,      16.46666667,      15.55555556,      15.65555556,      17.42222222,      18.74444444,      19.48888889,      15.9,      19.73333333,      13.02222222,      8.1,      8.933333333,      11.3,      12.38888889,      8.3,      12.38888889,      6.388888889,      4.211111111,      4.666666667,      0.7,      7.133333333,      2.344444444,      1.088888889,      0.111111111,      11.62222222,      10.84444444,      8.777777778,      3.5,      3.4,      7.211111111,      5.711111111,      9.677777778,      12.25555556,      10.15555556,      6.511111111,      4.911111111,      1.5,      11.44444444,      15.54444444,      8.122222222,      6.233333333,      7,      4.355555556,      0.277777778,      3.711111111,      2.888888889,      1.555555556,      3.888888889,      4.555555556,      5.666666667,      7.833333333,      9.833333333,      10.02222222,      6.288888889,      5.366666667,      11.41111111,      9.566666667,      9.744444444,      13.57777778,      9.433333333,      3.1,      11.08888889,      3.844444444,      2.488888889,      7.544444444,      4.488888889,      -0.455555556,      -2.111111111,      -3.566666667,      -1.955555556,      3.955555556,      1.222222222,  ]  week_number = [f\"W{i//7}\" if i % 7 == 0 else None for i in range(0, 365)]    start = 50  size = 100  data = {      \"Date\": dates[start:size],      \"Temp\u00b0C\": temp[start:size],      \"Week\": numpy.array(max[start:size]) + 5,      \"WeekN\": week_number[start:size],  }    page = \"\"\"  # Line - Texts    <|{data}|chart|x=Date|y[1]=Temp\u00b0C|y[2]=Week|mode[2]=text|text[2]=WeekN|>  \"\"\"    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": "import pathlib  import shutil  from datetime import datetime  from typing import Any, Callable, Dict, List, Optional, Set, Union, overload    from taipy.config.common.scope import Scope  from taipy.logger._taipy_logger import _TaipyLogger    from ._entity._entity import _Entity  from ._version._version_manager_factory import _VersionManagerFactory  from .common._warnings import _warn_no_core_service  from .config.data_node_config import DataNodeConfig  from .config.scenario_config import ScenarioConfig  from .cycle._cycle_manager_factory import _CycleManagerFactory  from .cycle.cycle import Cycle  from .cycle.cycle_id import CycleId  from .data._data_manager_factory import _DataManagerFactory  from .data.data_node import DataNode  from .data.data_node_id import DataNodeId  from .exceptions.exceptions import (      DataNodeConfigIsNotGlobal,      ModelNotFound,      NonExistingVersion,      VersionIsNotProductionVersion,  )  from .job._job_manager_factory import _JobManagerFactory  from .job.job import Job  from .job.job_id import JobId  from .scenario._scenario_manager_factory import _ScenarioManagerFactory  from .scenario.scenario import Scenario  from .scenario.scenario_id import ScenarioId  from .sequence._sequence_manager_factory import _SequenceManagerFactory  from .sequence.sequence import Sequence  from .sequence.sequence_id import SequenceId  from .submission._submission_manager_factory import _SubmissionManagerFactory  from .submission.submission import Submission  from .task._task_manager_factory import _TaskManagerFactory  from .task.task import Task  from .task.task_id import TaskId    __logger = _TaipyLogger._get_logger()      def set(entity: Union[DataNode, Task, Sequence, Scenario, Cycle]):      \"\"\"Save or update an entity.        This function allows you to save or update an entity in Taipy.        Parameters:          entity (Union[DataNode^, Task^, Sequence^, Scenario^, Cycle^]): The              entity to save or update.      \"\"\"      if isinstance(entity, Cycle):          return _CycleManagerFactory._build_manager()._set(entity)      if isinstance(entity, Scenario):          return _ScenarioManagerFactory._build_manager()._set(entity)      if isinstance(entity, Sequence):          return _SequenceManagerFactory._build_manager()._set(entity)      if isinstance(entity, Task):          return _TaskManagerFactory._build_manager()._set(entity)      if isinstance(entity, DataNode):          return _DataManagerFactory._build_manager()._set(entity)      def is_submittable(entity: Union[Scenario, ScenarioId, Sequence, SequenceId, Task, TaskId]) -> bool:      \"\"\"Indicate if an entity can be submitted.        This function checks if the given entity can be submitted for execution.        Returns:          True if the given entity can be submitted. False otherwise.      \"\"\"      if isinstance(entity, Scenario) or (isinstance(entity, str) and entity.startswith(Scenario._ID_PREFIX)):          return _ScenarioManagerFactory._build_manager()._is_submittable(entity)  # type: ignore      if isinstance(entity, Sequence) or (isinstance(entity, str) and entity.startswith(Sequence._ID_PREFIX)):          return _SequenceManagerFactory._build_manager()._is_submittable(entity)  # type: ignore      if isinstance(entity, Task) or (isinstance(entity, str) and entity.startswith(Task._ID_PREFIX)):          return _TaskManagerFactory._build_manager()._is_submittable(entity)  # type: ignore      return False      def is_editable(      entity: Union[          DataNode, Task, Job, Sequence, Scenario, Cycle, DataNodeId, TaskId, JobId, SequenceId, ScenarioId, CycleId      ]  ) -> bool:      \"\"\"Indicate if an entity can be edited.        This function checks if the given entity can be edited.        Returns:          True if the given entity can be edited. False otherwise.      \"\"\"      if isinstance(entity, Cycle) or (isinstance(entity, str) and entity.startswith(Cycle._ID_PREFIX)):          return _CycleManagerFactory._build_manager()._is_editable(entity)  # type: ignore      if isinstance(entity, Scenario) or (isinstance(entity, str) and entity.startswith(Scenario._ID_PREFIX)):          return _ScenarioManagerFactory._build_manager()._is_editable(entity)  # type: ignore      if isinstance(entity, Sequence) or (isinstance(entity, str) and entity.startswith(Sequence._ID_PREFIX)):          return _SequenceManagerFactory._build_manager()._is_editable(entity)  # type: ignore      if isinstance(entity, Task) or (isinstance(entity, str) and entity.startswith(Task._ID_PREFIX)):          return _TaskManagerFactory._build_manager()._is_editable(entity)  # type: ignore      if isinstance(entity, Job) or (isinstance(entity, str) and entity.startswith(Job._ID_PREFIX)):          return _JobManagerFactory._build_manager()._is_editable(entity)  # type: ignore      if isinstance(entity, DataNode) or (isinstance(entity, str) and entity.startswith(DataNode._ID_PREFIX)):          return _DataManagerFactory._build_manager()._is_editable(entity)  # type: ignore      return False      def is_readable(      entity: Union[          DataNode, Task, Job, Sequence, Scenario, Cycle, DataNodeId, TaskId, JobId, SequenceId, ScenarioId, CycleId      ]  ) -> bool:      \"\"\"Indicate if an entity can be read.        This function checks if the given entity can be read.        Returns:          True if the given entity can be read. False otherwise.      \"\"\"      if isinstance(entity, Cycle) or (isinstance(entity, str) and entity.startswith(Cycle._ID_PREFIX)):          return _CycleManagerFactory._build_manager()._is_readable(entity)  # type: ignore      if isinstance(entity, Scenario) or (isinstance(entity, str) and entity.startswith(Scenario._ID_PREFIX)):          return _ScenarioManagerFactory._build_manager()._is_readable(entity)  # type: ignore      if isinstance(entity, Sequence) or (isinstance(entity, str) and entity.startswith(Sequence._ID_PREFIX)):          return _SequenceManagerFactory._build_manager()._is_readable(entity)  # type: ignore      if isinstance(entity, Task) or (isinstance(entity, str) and entity.startswith(Task._ID_PREFIX)):          return _TaskManagerFactory._build_manager()._is_readable(entity)  # type: ignore      if isinstance(entity, Job) or (isinstance(entity, str) and entity.startswith(Job._ID_PREFIX)):          return _JobManagerFactory._build_manager()._is_readable(entity)  # type: ignore      if isinstance(entity, DataNode) or (isinstance(entity, str) and entity.startswith(DataNode._ID_PREFIX)):          return _DataManagerFactory._build_manager()._is_readable(entity)  # type: ignore      return False      @_warn_no_core_service()  def submit(      entity: Union[Scenario, Sequence, Task],      force: bool = False,      wait: bool = False,      timeout: Optional[Union[float, int]] = None,  ) -> Union[Job, List[Job]]:      \"\"\"Submit a scenario, sequence or task entity for execution.        This function submits the given entity for execution and returns the created job(s).        If the entity is a sequence or a scenario, all the tasks of the entity are      submitted for execution.        Parameters:          entity (Union[Scenario^, Sequence^, Task^]): The scenario, sequence or task to submit.          force (bool): If True, the execution is forced even if for skippable tasks.          wait (bool): Wait for the orchestrated jobs created from the submission to be finished              in asynchronous mode.          timeout (Union[float, int]): The optional maximum number of seconds to wait              for the jobs to be finished before returning.        Returns:          The created `Job^` or a collection of the created `Job^` depends on the submitted entity.                - If a `Scenario^` or a `Sequence^` is provided, it will return a list of `Job^`.              - If a `Task^` is provided, it will return the created `Job^`.      \"\"\"      if isinstance(entity, Scenario):          return _ScenarioManagerFactory._build_manager()._submit(entity, force=force, wait=wait, timeout=timeout)      if isinstance(entity, Sequence):          return _SequenceManagerFactory._build_manager()._submit(entity, force=force, wait=wait, timeout=timeout)      if isinstance(entity, Task):          return _TaskManagerFactory._build_manager()._submit(entity, force=force, wait=wait, timeout=timeout)      @overload  def exists(entity_id: TaskId) -> bool:      ...      @overload  def exists(entity_id: DataNodeId) -> bool:      ...      @overload  def exists(entity_id: SequenceId) -> bool:      ...      @overload  def exists(entity_id: ScenarioId) -> bool:      ...      @overload  def exists(entity_id: CycleId) -> bool:      ...      @overload  def exists(entity_id: JobId) -> bool:      ...      @overload  def exists(entity_id: str) -> bool:      ...      def exists(entity_id: Union[TaskId, DataNodeId, SequenceId, ScenarioId, JobId, CycleId, str]) -> bool:      \"\"\"Check if an entity with the specified identifier exists.        This function checks if an entity with the given identifier exists.      It supports various types of entity identifiers, including `TaskId^`,      `DataNodeId^`, `SequenceId^`, `ScenarioId^`, `JobId^`, `CycleId^`, and string      representations.        Parameters:          entity_id (Union[DataNodeId^, TaskId^, SequenceId^, ScenarioId^, JobId^, CycleId^]): The              identifier of the entity to check for existence.        Returns:          True if the given entity exists. False otherwise.        Raises:          ModelNotFound: If the entity's type cannot be determined.        Note:          The function performs checks for various entity types          (`Job^`, `Cycle^`, `Scenario^`, `Sequence^`, `Task^`, `DataNode^`)          based on their respective identifier prefixes.      \"\"\"      if entity_id.startswith(Job._ID_PREFIX):          return _JobManagerFactory._build_manager()._exists(JobId(entity_id))      if entity_id.startswith(Cycle._ID_PREFIX):          return _CycleManagerFactory._build_manager()._exists(CycleId(entity_id))      if entity_id.startswith(Scenario._ID_PREFIX):          return _ScenarioManagerFactory._build_manager()._exists(ScenarioId(entity_id))      if entity_id.startswith(Sequence._ID_PREFIX):          return _SequenceManagerFactory._build_manager()._exists(SequenceId(entity_id))      if entity_id.startswith(Task._ID_PREFIX):          return _TaskManagerFactory._build_manager()._exists(TaskId(entity_id))      if entity_id.startswith(DataNode._ID_PREFIX):          return _DataManagerFactory._build_manager()._exists(DataNodeId(entity_id))      raise ModelNotFound(\"NOT_DETERMINED\", entity_id)      @overload  def get(entity_id: TaskId) -> Task:      ...      @overload  def get(entity_id: DataNodeId) -> DataNode:      ...      @overload  def get(entity_id: SequenceId) -> Sequence:      ...      @overload  def get(entity_id: ScenarioId) -> Scenario:      ...      @overload  def get(entity_id: CycleId) -> Cycle:      ...      @overload  def get(entity_id: JobId) -> Job:      ...      @overload  def get(entity_id: str) -> Union[Task, DataNode, Sequence, Scenario, Job, Cycle]:      ...      def get(      entity_id: Union[TaskId, DataNodeId, SequenceId, ScenarioId, JobId, CycleId, str]  ) -> Union[Task, DataNode, Sequence, Scenario, Job, Cycle]:      \"\"\"Retrieve an entity by its unique identifier.        This function allows you to retrieve an entity by specifying its identifier.      The identifier must match the pattern of one of the supported entity types:      Task^, DataNode^, Sequence^, Job^, Cycle^, or Scenario^.          Parameters:          entity_id (Union[TaskId, DataNodeId, SequenceId, ScenarioId, JobId, CycleId, str]):              The identifier of the entity to retrieve.<br/>              It should conform to the identifier pattern of one of the entities (`Task^`, `DataNode^`,              `Sequence^`, `Job^`, `Cycle^` or `Scenario^`).        Returns:          The entity that corresponds to the provided identifier. Returns None if no matching entity is found.        Raises:          ModelNotFound^: If the provided *entity_id* does not match any known entity pattern.      \"\"\"      if entity_id.startswith(Job._ID_PREFIX):          return _JobManagerFactory._build_manager()._get(JobId(entity_id))      if entity_id.startswith(Cycle._ID_PREFIX):          return _CycleManagerFactory._build_manager()._get(CycleId(entity_id))      if entity_id.startswith(Scenario._ID_PREFIX):          return _ScenarioManagerFactory._build_manager()._get(ScenarioId(entity_id))      if entity_id.startswith(Sequence._ID_PREFIX):          return _SequenceManagerFactory._build_manager()._get(SequenceId(entity_id))      if entity_id.startswith(Task._ID_PREFIX):          return _TaskManagerFactory._build_manager()._get(TaskId(entity_id))      if entity_id.startswith(DataNode._ID_PREFIX):          return _DataManagerFactory._build_manager()._get(DataNodeId(entity_id))      raise ModelNotFound(\"NOT_DETERMINED\", entity_id)      def get_tasks() -> List[Task]:      \"\"\"Retrieve a list of all existing tasks.        This function returns a list of all tasks that currently exist.        Returns:          A list containing all the tasks.      \"\"\"      return _TaskManagerFactory._build_manager()._get_all()      def is_deletable(entity: Union[Scenario, Job, ScenarioId, JobId]) -> bool:      \"\"\"Check if a `Scenario^` or a `Job^` can be deleted.        This function determines whether a scenario or a job can be safely      deleted without causing conflicts or issues.        Parameters:          entity (Union[Scenario, Job, ScenarioId, JobId]): The scenario or job to check.        Returns:          True if the given scenario or job can be deleted. False otherwise.      \"\"\"      if isinstance(entity, str) and entity.startswith(Job._ID_PREFIX) or isinstance(entity, Job):          return _JobManagerFactory._build_manager()._is_deletable(entity)  # type: ignore      if isinstance(entity, str) and entity.startswith(Scenario._ID_PREFIX) or isinstance(entity, Scenario):          return _ScenarioManagerFactory._build_manager()._is_deletable(entity)  # type: ignore      return True      def delete(entity_id: Union[TaskId, DataNodeId, SequenceId, ScenarioId, JobId, CycleId]):      \"\"\"Delete an entity and its nested entities.        This function deletes the specified entity and recursively deletes all its nested entities.      The behavior varies depending on the type of entity provided:        - If a `CycleId` is provided, the nested scenarios, tasks, data nodes, and jobs are deleted.      - If a `ScenarioId` is provided, the nested tasks, data nodes, and jobs are deleted.        If the scenario is primary, it can only be deleted if it is the only scenario in the cycle.        In that case, its cycle is also deleted. Use the `is_deletable()^` function to check if        the scenario can be deleted.      - If a `SequenceId` is provided, the related jobs are deleted.      - If a `TaskId` is provided, the related data nodes, and jobs are deleted.        Parameters:          entity_id (Union[TaskId, DataNodeId, SequenceId, ScenarioId, JobId, CycleId]):              The identifier of the entity to delete.        Raises:          ModelNotFound: No entity corresponds to the specified *entity_id*.      \"\"\"      if entity_id.startswith(Job._ID_PREFIX):          job_manager = _JobManagerFactory._build_manager()          return job_manager._delete(job_manager._get(JobId(entity_id)))  # type: ignore      if entity_id.startswith(Cycle._ID_PREFIX):          return _CycleManagerFactory._build_manager()._hard_delete(CycleId(entity_id))      if entity_id.startswith(Scenario._ID_PREFIX):          return _ScenarioManagerFactory._build_manager()._hard_delete(ScenarioId(entity_id))      if entity_id.startswith(Sequence._ID_PREFIX):          return _SequenceManagerFactory._build_manager()._hard_delete(SequenceId(entity_id))      if entity_id.startswith(Task._ID_PREFIX):          return _TaskManagerFactory._build_manager()._hard_delete(TaskId(entity_id))      if entity_id.startswith(DataNode._ID_PREFIX):          return _DataManagerFactory._build_manager()._delete(DataNodeId(entity_id))      raise ModelNotFound(\"NOT_DETERMINED\", entity_id)      def get_scenarios(cycle: Optional[Cycle] = None, tag: Optional[str] = None) -> List[Scenario]:      \"\"\"Retrieve a list of existing scenarios filtered by cycle or tag.        This function allows you to retrieve a list of scenarios based on optional      filtering criteria. If both a _cycle_ and a _tag_ are provided, the returned      list contains scenarios that belong to the specified _cycle_ **and** also      have the specified _tag_.        Parameters:           cycle (Optional[Cycle^]): The optional `Cycle^` to filter scenarios by.           tag (Optional[str]): The optional tag to filter scenarios by.        Returns:          The list of scenarios filtered by cycle or tag. If no filtering criteria              are provided, this method returns all existing scenarios.      \"\"\"      if not cycle and not tag:          return _ScenarioManagerFactory._build_manager()._get_all()      if cycle and not tag:          return _ScenarioManagerFactory._build_manager()._get_all_by_cycle(cycle)      if not cycle and tag:          return _ScenarioManagerFactory._build_manager()._get_all_by_tag(tag)      if cycle and tag:          cycles_scenarios = _ScenarioManagerFactory._build_manager()()._get_all_by_cycle(cycle)          return [scenario for scenario in cycles_scenarios if scenario.has_tag(tag)]      return []      def get_primary(cycle: Cycle) -> Optional[Scenario]:      \"\"\"Retrieve the primary scenario associated with a cycle.        Parameters:          cycle (Cycle^): The cycle for which to retrieve the primary scenario.        Returns:          The primary scenario of the given _cycle_. If the cycle has no              primary scenario, this method returns None.      \"\"\"      return _ScenarioManagerFactory._build_manager()._get_primary(cycle)      def get_primary_scenarios() -> List[Scenario]:      \"\"\"Retrieve a list of all primary scenarios.        Returns:          A list containing all primary scenarios.      \"\"\"      return _ScenarioManagerFactory._build_manager()._get_primary_scenarios()      def is_promotable(scenario: Union[Scenario, ScenarioId]) -> bool:      \"\"\"Determine if a scenario can be promoted to become a primary scenario.        This function checks whether the given scenario is eligible to be promoted      as a primary scenario.        Parameters:          scenario (Union[Scenario, ScenarioId]): The scenario to be evaluated for promotability.        Returns:          True if the given scenario can be promoted to be a primary scenario. False otherwise.      \"\"\"      return _ScenarioManagerFactory._build_manager()._is_promotable_to_primary(scenario)      def set_primary(scenario: Scenario):      \"\"\"Promote a scenario as the primary scenario of its cycle.        This function promotes the given scenario as the primary scenario of its associated cycle.      If the cycle already has a primary scenario, that scenario is demoted and is      no longer considered the primary scenario for its cycle.        Parameters:          scenario (Scenario^): The scenario to promote as the new _primary_ scenario.      \"\"\"      return _ScenarioManagerFactory._build_manager()._set_primary(scenario)      def tag(scenario: Scenario, tag: str):      \"\"\"Add a tag to a scenario.        This function adds a user-defined tag to the specified scenario. If another scenario      within the same cycle already has the same tag applied, the previous scenario is untagged.        Parameters:          scenario (Scenario^): The scenario to which the tag will be added.          tag (str): The tag to apply to the scenario.      \"\"\"      return _ScenarioManagerFactory._build_manager()._tag(scenario, tag)      def untag(scenario: Scenario, tag: str):      \"\"\"Remove a tag from a scenario.        This function removes a specified tag from the given scenario. If the scenario does      not have the specified tag, it has no effect.        Parameters:          scenario (Scenario^): The scenario from which the tag will be removed.          tag (str): The tag to remove from the scenario.      \"\"\"      return _ScenarioManagerFactory._build_manager()._untag(scenario, tag)      def compare_scenarios(*scenarios: Scenario, data_node_config_id: Optional[str] = None) -> Dict[str, Any]:      \"\"\"Compare the data nodes of several scenarios.        You can specify which data node config identifier should the comparison be performed      on.        Parameters:          *scenarios (*Scenario^): The list of the scenarios to compare.          data_node_config_id (Optional[str]): The config identifier of the DataNode to perform              the comparison on. <br/>                If _data_node_config_id_ is not provided, the scenarios are              compared on all defined comparators.<br/>        Returns:          The comparison results. The key is the data node config identifier used for          comparison.        Raises:          InsufficientScenarioToCompare^: Raised when only one or no scenario for comparison              is provided.          NonExistingComparator^: Raised when the scenario comparator does not exist.          DifferentScenarioConfigs^: Raised when the provided scenarios do not share the              same scenario config.          NonExistingScenarioConfig^: Raised when the scenario config of the provided              scenarios could not be found.      \"\"\"      return _ScenarioManagerFactory._build_manager()._compare(*scenarios, data_node_config_id=data_node_config_id)      def subscribe_scenario(      callback: Callable[[Scenario, Job], None],      params: Optional[List[Any]] = None,      scenario: Optional[Scenario] = None,  ):      \"\"\"Subscribe a function to be called on job status change.        The subscription is applied to all jobs created for the execution of _scenario_.      If no scenario is provided, the subscription applies to all scenarios.        Parameters:          callback (Callable[[Scenario^, Job^], None]): The function to be called on              status change.          params (Optional[List[Any]]): The parameters to be passed to the _callback_.          scenario (Optional[Scenario^]): The scenario to which the callback is applied.              If None, the subscription is registered for all scenarios.        Note:          Notifications are applied only for jobs created **after** this subscription.      \"\"\"      params = [] if params is None else params      return _ScenarioManagerFactory._build_manager()._subscribe(callback, params, scenario)      def unsubscribe_scenario(      callback: Callable[[Scenario, Job], None], params: Optional[List[Any]] = None, scenario: Optional[Scenario] = None  ):      \"\"\"Unsubscribe a function that is called when the status of a `Job^` changes.        If no scenario is provided, the subscription is removed for all scenarios.        Parameters:          callback (Callable[[Scenario^, Job^], None]): The function to unsubscribe from.          params (Optional[List[Any]]): The parameters to be passed to the callback.          scenario (Optional[Scenario]): The scenario to unsubscribe from. If None, it              applies to all scenarios.        Note:          The callback function will continue to be called for ongoing jobs.      \"\"\"      return _ScenarioManagerFactory._build_manager()._unsubscribe(callback, params, scenario)      def subscribe_sequence(      callback: Callable[[Sequence, Job], None], params: Optional[List[Any]] = None, sequence: Optional[Sequence] = None  ):      \"\"\"Subscribe a function to be called on job status change.        The subscription is applied to all jobs created for the execution of _sequence_.        Parameters:          callback (Callable[[Sequence^, Job^], None]): The callable function to be called on              status change.          params (Optional[List[Any]]): The parameters to be passed to the _callback_.          sequence (Optional[Sequence^]): The sequence to subscribe on. If None, the subscription              is applied to all sequences.        Note:          Notifications are applied only for jobs created **after** this subscription.      \"\"\"      return _SequenceManagerFactory._build_manager()._subscribe(callback, params, sequence)      def unsubscribe_sequence(      callback: Callable[[Sequence, Job], None], params: Optional[List[Any]] = None, sequence: Optional[Sequence] = None  ):      \"\"\"Unsubscribe a function that is called when the status of a Job changes.        Parameters:          callback (Callable[[Sequence^, Job^], None]): The callable function to be called on              status change.          params (Optional[List[Any]]): The parameters to be passed to the _callback_.          sequence (Optional[Sequence^]): The sequence to unsubscribe to. If None, it applies              to all sequences.        Note:          The function will continue to be called for ongoing jobs.      \"\"\"      return _SequenceManagerFactory._build_manager()._unsubscribe(callback, params, sequence)      def get_sequences() -> List[Sequence]:      \"\"\"Return all existing sequences.        Returns:          The list of all sequences.      \"\"\"      return _SequenceManagerFactory._build_manager()._get_all()      def get_jobs() -> List[Job]:      \"\"\"Return all the existing jobs.        Returns:          The list of all jobs.      \"\"\"      return _JobManagerFactory._build_manager()._get_all()      def delete_job(job: Job, force=False):      \"\"\"Delete a job.        This function deletes the specified job. If the job is not completed and      *force* is not set to True, a `JobNotDeletedException^` may be raised.        Parameters:          job (Job^): The job to delete.          force (Optional[bool]): If True, forces the deletion of _job_, even              if it is not completed yet.      Raises:          JobNotDeletedException^: If the job is not finished.      \"\"\"      return _JobManagerFactory._build_manager()._delete(job, force)      def delete_jobs():      \"\"\"Delete all jobs.\"\"\"      return _JobManagerFactory._build_manager()._delete_all()      def cancel_job(job: Union[str, Job]):      \"\"\"Cancel a job and set the status of the subsequent jobs to ABANDONED.        This function cancels the specified job and sets the status of any subsequent jobs to ABANDONED.        Parameters:          job (Job^): The job to cancel.      \"\"\"      _JobManagerFactory._build_manager()._cancel(job)      def get_latest_job(task: Task) -> Optional[Job]:      \"\"\"Return the latest job of a task.        This function retrieves the latest job associated with a task.        Parameters:          task (Task^): The task to retrieve the latest job from.      Returns:          The latest job created from _task_, or None if no job has been created from _task_.      \"\"\"      return _JobManagerFactory._build_manager()._get_latest(task)      def get_latest_submission(entity: Union[Scenario, Sequence, Task]) -> Optional[Submission]:      \"\"\"Return the latest submission of a scenario, sequence or task.        This function retrieves the latest submission associated with a scenario, sequence or task.        Parameters:          entity (Union[Scenario^, Sequence^, Task^]): The scenario, sequence or task to          retrieve the latest submission from.      Returns:          The latest submission created from _scenario_, _sequence_ and _task_, or None          if no submission has been created from _scenario_, _sequence_ and _task_.      \"\"\"      return _SubmissionManagerFactory._build_manager()._get_latest(entity)      def get_data_nodes() -> List[DataNode]:      \"\"\"Return all the existing data nodes.        Returns:          The list of all data nodes.      \"\"\"      return _DataManagerFactory._build_manager()._get_all()      def get_cycles() -> List[Cycle]:      \"\"\"Return the list of all existing cycles.        Returns:          The list of all cycles.      \"\"\"      return _CycleManagerFactory._build_manager()._get_all()      def create_scenario(      config: ScenarioConfig,      creation_date: Optional[datetime] = None,      name: Optional[str] = None,  ) -> Scenario:      \"\"\"Create and return a new scenario based on a scenario configuration.        If the scenario belongs to a cycle, a cycle (corresponding to the _creation_date_      and the configuration frequency attribute) is created if it does not exist yet.        Parameters:          config (ScenarioConfig^): The scenario configuration used to create a new scenario.          creation_date (Optional[datetime.datetime]): The creation date of the scenario.              If None, the current date time is used.          name (Optional[str]): The displayable name of the scenario.      Returns:          The new scenario.      \"\"\"      return _ScenarioManagerFactory._build_manager()._create(config, creation_date, name)      def create_global_data_node(config: DataNodeConfig) -> DataNode:      \"\"\"Create and return a new GLOBAL data node from a data node configuration.        Parameters:          config (DataNodeConfig^): The data node configuration. It must have a `GLOBAL` scope.        Returns:          The new global data node.        Raises:          DataNodeConfigIsNotGlobal^: If the data node configuration does not have GLOBAL scope.      \"\"\"      # Check if the data node config has GLOBAL scope      if config.scope is not Scope.GLOBAL:          raise DataNodeConfigIsNotGlobal(config.id)  # type: ignore        if dns := _DataManagerFactory._build_manager()._get_by_config_id(config.id):  # type: ignore          return dns[0]      return _DataManagerFactory._build_manager()._create_and_set(config, None, None)      def clean_all_entities_by_version(version_number=None) -> bool:      \"\"\"Delete all entities of a specific version.        This function deletes all entities associated with the specified version.        Parameters:          version_number (optional[str]): The version number of the entities to be deleted.              If None, the default behavior may apply.        Returns:          True if the operation succeeded, False otherwise.        Notes:          - If the specified version does not exist, the operation will be aborted, and False will be returned.          - This function cleans all entities, including jobs, scenarios, sequences, tasks, and data nodes.          - The production version of the specified version is also deleted if it exists.      \"\"\"      version_manager = _VersionManagerFactory._build_manager()      try:          version_number = version_manager._replace_version_number(version_number)      except NonExistingVersion as e:          __logger.warning(f\"{e.message} Abort cleaning the entities of version '{version_number}'.\")          return False        _JobManagerFactory._build_manager()._delete_by_version(version_number)      _ScenarioManagerFactory._build_manager()._delete_by_version(version_number)      _SequenceManagerFactory._build_manager()._delete_by_version(version_number)      _TaskManagerFactory._build_manager()._delete_by_version(version_number)      _DataManagerFactory._build_manager()._delete_by_version(version_number)        version_manager._delete(version_number)      try:          version_manager._delete_production_version(version_number)      except VersionIsNotProductionVersion:          pass        return True      def export_scenario(      scenario_id: ScenarioId,      folder_path: Union[str, pathlib.Path],  ):      \"\"\"Export all related entities of a scenario to a folder.        This function exports all related entities of the specified scenario to the      specified folder.        Parameters:          scenario_id (ScenarioId): The ID of the scenario to export.          folder_path (Union[str, pathlib.Path]): The folder path to export the scenario to.      \"\"\"        manager = _ScenarioManagerFactory._build_manager()      scenario = manager._get(scenario_id)      entity_ids = manager._get_children_entity_ids(scenario)  # type: ignore      entity_ids.scenario_ids = {scenario_id}      entity_ids.cycle_ids = {scenario.cycle.id}        shutil.rmtree(folder_path, ignore_errors=True)        for data_node_id in entity_ids.data_node_ids:          _DataManagerFactory._build_manager()._export(data_node_id, folder_path)      for task_id in entity_ids.task_ids:          _TaskManagerFactory._build_manager()._export(task_id, folder_path)      for sequence_id in entity_ids.sequence_ids:          _SequenceManagerFactory._build_manager()._export(sequence_id, folder_path)      for cycle_id in entity_ids.cycle_ids:          _CycleManagerFactory._build_manager()._export(cycle_id, folder_path)      for scenario_id in entity_ids.scenario_ids:          _ScenarioManagerFactory._build_manager()._export(scenario_id, folder_path)      for job_id in entity_ids.job_ids:          _JobManagerFactory._build_manager()._export(job_id, folder_path)      def get_parents(      entity: Union[TaskId, DataNodeId, SequenceId, Task, DataNode, Sequence], parent_dict=None  ) -> Dict[str, Set[_Entity]]:      \"\"\"Get the parents of an entity from itself or its identifier.        Parameters:          entity (Union[TaskId, DataNodeId, SequenceId, Task, DataNode, Sequence]): The entity or its              identifier to get the parents.        Returns:          The dictionary of all parent entities.              They are grouped by their type (Scenario^, Sequences^, or tasks^) so each key corresponds              to a level of the parents and the value is a set of the parent entities.              An empty dictionary is returned if the entity does not have parents.<br/>              Example: The following instruction returns all the scenarios that include the              datanode identified by \"my_datanode_id\".              `taipy.get_parents(\"id_of_my_datanode\")[\"scenario\"]`        Raises:          ModelNotFound^: If _entity_ does not match a correct entity pattern.      \"\"\"        def update_parent_dict(parents_set, parent_dict):          for k, value in parents_set.items():              if k in parent_dict.keys():                  parent_dict[k].update(value)              else:                  parent_dict[k] = value        if isinstance(entity, str):          entity = get(entity)  # type: ignore        parent_dict = parent_dict or dict()        if isinstance(entity, (Scenario, Cycle)):          return parent_dict        current_parent_dict: Dict[str, Set] = {}      for parent in entity.parent_ids:          parent_entity = get(parent)          if parent_entity._MANAGER_NAME in current_parent_dict.keys():              current_parent_dict[parent_entity._MANAGER_NAME].add(parent_entity)          else:              current_parent_dict[parent_entity._MANAGER_NAME] = {parent_entity}        if isinstance(entity, Sequence):          update_parent_dict(current_parent_dict, parent_dict)        if isinstance(entity, Task):          parent_entity_key_to_search_next = \"scenario\"          update_parent_dict(current_parent_dict, parent_dict)          for parent in parent_dict.get(parent_entity_key_to_search_next, []):              get_parents(parent, parent_dict)        if isinstance(entity, DataNode):          parent_entity_key_to_search_next = \"task\"          update_parent_dict(current_parent_dict, parent_dict)          for parent in parent_dict.get(parent_entity_key_to_search_next, []):              get_parents(parent, parent_dict)        return parent_dict      def get_cycles_scenarios() -> Dict[Optional[Cycle], List[Scenario]]:      \"\"\"Get the scenarios grouped by cycles.        Returns:          The dictionary of all cycles and their corresponding scenarios.      \"\"\"        cycles_scenarios: Dict[Optional[Cycle], List[Scenario]] = {}      for scenario in get_scenarios():          if scenario.cycle in cycles_scenarios.keys():              cycles_scenarios[scenario.cycle].append(scenario)          else:              cycles_scenarios[scenario.cycle] = [scenario]      return cycles_scenarios      def get_entities_by_config_id(      config_id: str,  ) -> Union[List, List[Task], List[DataNode], List[Sequence], List[Scenario]]:      \"\"\"Get the entities by its config id.        Parameters:          config_id (str): The config id of the entities        Returns:          The list of all entities by the config id.      \"\"\"        entities: List = []        if entities := _ScenarioManagerFactory._build_manager()._get_by_config_id(config_id):          return entities      if entities := _TaskManagerFactory._build_manager()._get_by_config_id(config_id):          return entities      if entities := _DataManagerFactory._build_manager()._get_by_config_id(config_id):          return entities      return entities "}
{"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 copy  import json  import pathlib  import shutil  from typing import Any, Dict, Iterable, Iterator, List, Optional, Type, Union    from taipy.config.config import Config    from ..common._utils import _retry_read_entity  from ..common.typing import Converter, Entity, Json, ModelType  from ..exceptions import FileCannotBeRead, InvalidExportPath, ModelNotFound  from ._abstract_repository import _AbstractRepository  from ._decoder import _Decoder  from ._encoder import _Encoder      class _FileSystemRepository(_AbstractRepository[ModelType, Entity]):      \"\"\"      Holds common methods to be used and extended when the need for saving      dataclasses as JSON files in local storage emerges.        Some lines have type: ignore because MyPy won't recognize some generic attributes. This      should be revised in the future.        Attributes:          model_type (ModelType): Generic dataclass.          converter: A class that handles conversion to and from a database backend          dir_name (str): Folder that will hold the files for this dataclass model.      \"\"\"        __EXCEPTIONS_TO_RETRY = (FileCannotBeRead,)        def __init__(self, model_type: Type[ModelType], converter: Type[Converter], dir_name: str):          self.model_type = model_type          self.converter = converter          self._dir_name = dir_name        @property      def dir_path(self):          return self._storage_folder / self._dir_name        @property      def _storage_folder(self) -> pathlib.Path:          return pathlib.Path(Config.core.storage_folder)        ###############################      # ##   Inherited methods   ## #      ###############################        def _save(self, entity: Entity):          self.__create_directory_if_not_exists()          model = self.converter._entity_to_model(entity)  # type: ignore          self.__get_path(model.id).write_text(              json.dumps(model.to_dict(), ensure_ascii=False, indent=0, cls=_Encoder, check_circular=False),              encoding=\"UTF-8\",          )        def _exists(self, entity_id: str) -> bool:          return self.__get_path(entity_id).exists()        def _load(self, entity_id: str) -> Entity:          path = pathlib.Path(self.__get_path(entity_id))            try:              file_content = self.__read_file(path)          except (FileNotFoundError, FileCannotBeRead):              raise ModelNotFound(str(self.dir_path), entity_id)            return self.__file_content_to_entity(file_content)        def _load_all(self, filters: Optional[List[Dict]] = None) -> List[Entity]:          entities = []          try:              for f in self.dir_path.iterdir():                  if data := self.__filter_by(f, filters):                      entities.append(self.__file_content_to_entity(data))          except FileNotFoundError:              pass          return entities        def _delete(self, entity_id: str):          try:              self.__get_path(entity_id).unlink()          except FileNotFoundError:              raise ModelNotFound(str(self.dir_path), entity_id)        def _delete_all(self):          shutil.rmtree(self.dir_path, ignore_errors=True)        def _delete_many(self, ids: Iterable[str]):          for model_id in ids:              self._delete(model_id)        def _delete_by(self, attribute: str, value: str):          filters: List[Dict] = [{}]          for fil in filters:              fil.update({attribute: value})            try:              for f in self.dir_path.iterdir():                  if self.__filter_by(f, filters):                      f.unlink()          except FileNotFoundError:              pass        def _search(self, attribute: str, value: Any, filters: Optional[List[Dict]] = None) -> List[Entity]:          return list(self.__search(attribute, value, filters))        def _export(self, entity_id: str, folder_path: Union[str, pathlib.Path]):          if isinstance(folder_path, str):              folder: pathlib.Path = pathlib.Path(folder_path)          else:              folder = folder_path            if folder.resolve() == self._storage_folder.resolve():              raise InvalidExportPath(\"The export folder must not be the storage folder.\")            export_dir = folder / self._dir_name          if not export_dir.exists():              export_dir.mkdir(parents=True)            export_path = export_dir / f\"{entity_id}.json\"          # Delete if exists.          if export_path.exists():              export_path.unlink()            shutil.copy2(self.__get_path(entity_id), export_path)        ###########################################      # ##   Specific or optimized methods   ## #      ###########################################      def _get_by_configs_and_owner_ids(self, configs_and_owner_ids, filters: Optional[List[Dict]] = None):          # Design in order to optimize performance on Entity creation.          # Maintainability and readability were impacted.          if not filters:              filters = [{}]          res = {}          configs_and_owner_ids = set(configs_and_owner_ids)            try:              for f in self.dir_path.iterdir():                  config_id, owner_id, entity = self.__match_file_and_get_entity(                      f, configs_and_owner_ids, copy.deepcopy(filters)                  )                    if entity:                      key = config_id, owner_id                      res[key] = entity                      configs_and_owner_ids.remove(key)                        if len(configs_and_owner_ids) == 0:                          return res          except FileNotFoundError:              # Folder with data was not created yet.              return {}            return res        def _get_by_config_and_owner_id(          self, config_id: str, owner_id: Optional[str], filters: Optional[List[Dict]] = None      ) -> Optional[Entity]:          if not filters:              filters = [{}]          else:              filters = copy.deepcopy(filters)            if owner_id is not None:              for fil in filters:                  fil.update({\"owner_id\": owner_id})          return self.__filter_files_by_config_and_owner_id(config_id, owner_id, filters)        #############################      # ##   Private methods   ## #      #############################        def __filter_files_by_config_and_owner_id(          self, config_id: str, owner_id: Optional[str], filters: Optional[List[Dict]] = None      ):          try:              files = filter(lambda f: config_id in f.name, self.dir_path.iterdir())              entities = map(                  lambda f: self.__file_content_to_entity(self.__filter_by(f, filters)),                  files,              )              corresponding_entities = filter(                  lambda e: e is not None and e.config_id == config_id and e.owner_id == owner_id,  # type: ignore                  entities,              )              return next(corresponding_entities, None)  # type: ignore          except FileNotFoundError:              pass          return None        def __match_file_and_get_entity(self, filepath, config_and_owner_ids, filters):          if match := [(c, p) for c, p in config_and_owner_ids if c.id in filepath.name]:              for config, owner_id in match:                  for fil in filters:                      fil.update({\"config_id\": config.id, \"owner_id\": owner_id})                    if data := self.__filter_by(filepath, filters):                      return config, owner_id, self.__file_content_to_entity(data)            return None, None, None        def __create_directory_if_not_exists(self):          self.dir_path.mkdir(parents=True, exist_ok=True)        def __search(self, attribute: str, value: str, filters: Optional[List[Dict]] = None) -> Iterator[Entity]:          return filter(lambda e: getattr(e, attribute, None) == value, self._load_all(filters))        def __get_path(self, model_id) -> pathlib.Path:          return self.dir_path / f\"{model_id}.json\"        def __file_content_to_entity(self, file_content):          if not file_content:              return None          if isinstance(file_content, str):              file_content = json.loads(file_content, cls=_Decoder)          model = self.model_type.from_dict(file_content)          entity = self.converter._model_to_entity(model)          return entity        def __filter_by(self, filepath: pathlib.Path, filters: Optional[List[Dict]]) -> Optional[Json]:          if not filters:              filters = [{}]            try:              file_content = self.__read_file(filepath)          except (FileNotFoundError, FileCannotBeRead):              return None            for _filter in filters:              conditions = [                  f'\"{key}\": \"{value}\"' if value is not None else f'\"{key}\": null' for key, value in _filter.items()              ]              if all(condition in file_content for condition in conditions):                  return json.loads(file_content, cls=_Decoder)          return None        @_retry_read_entity(__EXCEPTIONS_TO_RETRY)      def __read_file(self, filepath: pathlib.Path) -> str:          if not filepath.is_file():              raise FileNotFoundError            try:              with filepath.open(\"r\", encoding=\"UTF-8\") as f:                  file_content = f.read()              return file_content          except Exception:              raise FileCannotBeRead(str(filepath)) "}
{"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": "import json  import pathlib  from typing import Any, Dict, Iterable, List, Optional, Type, Union    from sqlalchemy.dialects import sqlite  from sqlalchemy.exc import NoResultFound    from .._repository._abstract_repository import _AbstractRepository  from ..common.typing import Converter, Entity, ModelType  from ..exceptions import ModelNotFound  from .db._sql_connection import _SQLConnection      class _SQLRepository(_AbstractRepository[ModelType, Entity]):      def __init__(self, model_type: Type[ModelType], converter: Type[Converter]):          \"\"\"          Holds common methods to be used and extended when the need for saving          dataclasses in a SqlLite database.            Some lines have type: ignore because MyPy won't recognize some generic attributes. This          should be revised in the future.            Attributes:              model_type: Generic dataclass.              converter: A class that handles conversion to and from a database backend              db: An sqlite3 session object          \"\"\"          self.db = _SQLConnection.init_db()          self.model_type = model_type          self.converter = converter          self.table = self.model_type.__table__        ###############################      # ##   Inherited methods   ## #      ###############################      def _save(self, entity: Entity):          obj = self.converter._entity_to_model(entity)          if self._exists(entity.id):  # type: ignore              self._update_entry(obj)              return          self.__insert_model(obj)        def _exists(self, entity_id: str):          query = self.table.select().filter_by(id=entity_id)          return bool(self.db.execute(str(query), [entity_id]).fetchone())        def _load(self, entity_id: str) -> Entity:          query = self.table.select().filter_by(id=entity_id)            if entry := self.db.execute(str(query.compile(dialect=sqlite.dialect())), [entity_id]).fetchone():              entry = self.model_type.from_dict(entry)              return self.converter._model_to_entity(entry)          raise ModelNotFound(str(self.model_type.__name__), entity_id)        def _load_all(self, filters: Optional[List[Dict]] = None) -> List[Entity]:          query = self.table.select()          entities: List[Entity] = []            for f in filters or [{}]:              filtered_query = query.filter_by(**f)              try:                  entries = self.db.execute(                      str(filtered_query.compile(dialect=sqlite.dialect())),                      [self.__serialize_filter_values(val) for val in list(f.values())],                  ).fetchall()                    entities.extend([self.converter._model_to_entity(self.model_type.from_dict(m)) for m in entries])              except NoResultFound:                  continue          return entities        def _delete(self, entity_id: str):          delete_query = self.table.delete().filter_by(id=entity_id)          cursor = self.db.execute(str(delete_query.compile(dialect=sqlite.dialect())), [entity_id])            if cursor.rowcount == 0:              raise ModelNotFound(str(self.model_type.__name__), entity_id)            self.db.commit()        def _delete_all(self):          self.db.execute(str(self.table.delete().compile(dialect=sqlite.dialect())))          self.db.commit()        def _delete_many(self, ids: Iterable[str]):          for entity_id in ids:              self._delete(entity_id)        def _delete_by(self, attribute: str, value: str):          delete_by_query = self.table.delete().filter_by(**{attribute: value})            self.db.execute(str(delete_by_query.compile(dialect=sqlite.dialect())), [value])          self.db.commit()        def _search(self, attribute: str, value: Any, filters: Optional[List[Dict]] = None) -> List[Entity]:          query = self.table.select().filter_by(**{attribute: value})            entities: List[Entity] = []          for f in filters or [{}]:              entries = self.db.execute(                  str(query.filter_by(**f).compile(dialect=sqlite.dialect())),                  [value] + [self.__serialize_filter_values(val) for val in list(f.values())],              ).fetchall()              entities.extend([self.converter._model_to_entity(self.model_type.from_dict(m)) for m in entries])            return entities        def _export(self, entity_id: str, folder_path: Union[str, pathlib.Path]):          if isinstance(folder_path, str):              folder: pathlib.Path = pathlib.Path(folder_path)          else:              folder = folder_path            export_dir = folder / self.table.name          if not export_dir.exists():              export_dir.mkdir(parents=True)            export_path = export_dir / f\"{entity_id}.json\"            query = self.table.select().filter_by(id=entity_id)            if entry := self.db.execute(str(query.compile(dialect=sqlite.dialect())), [entity_id]).fetchone():              with open(export_path, \"w\", encoding=\"utf-8\") as export_file:                  export_file.write(json.dumps(entry))          else:              raise ModelNotFound(self.model_type, entity_id)  # type: ignore        ###########################################      # ##   Specific or optimized methods   ## #      ###########################################      def _get_multi(self, *, skip: int = 0, limit: int = 100) -> List[ModelType]:          query = self.table.select().offset(skip).limit(limit)          return self.db.execute(str(query.compile(dialect=sqlite.dialect()))).fetchall()        def _get_by_config(self, config_id: Any) -> Optional[ModelType]:          query = self.table.select().filter_by(config_id=config_id)          return self.db.execute(str(query.compile(dialect=sqlite.dialect())), [config_id]).fetchall()        def _get_by_config_and_owner_id(          self, config_id: str, owner_id: Optional[str], filters: Optional[List[Dict]] = None      ) -> Optional[Entity]:          if not filters:              filters = [{}]          if entry := self.__get_entities_by_config_and_owner(config_id, owner_id, filters):              return self.converter._model_to_entity(entry)          return None        def _get_by_configs_and_owner_ids(self, configs_and_owner_ids, filters: Optional[List[Dict]] = None):          # Design in order to optimize performance on Entity creation.          # Maintainability and readability were impacted.          if not filters:              filters = [{}]          res = {}          configs_and_owner_ids = set(configs_and_owner_ids)            for config, owner in configs_and_owner_ids:              entry = self.__get_entities_by_config_and_owner(config.id, owner, filters)              if entry:                  entity = self.converter._model_to_entity(entry)                  key = config, owner                  res[key] = entity            return res        def __get_entities_by_config_and_owner(          self, config_id: str, owner_id: Optional[str] = None, filters: Optional[List[Dict]] = None      ) -> Optional[ModelType]:          if not filters:              filters = []          versions = [item.get(\"version\") for item in filters if item.get(\"version\")]            query = self.table.select().filter_by(config_id=config_id)          parameters: List = [config_id]            if owner_id:              parameters.append(owner_id)          query = query.filter_by(owner_id=owner_id)          query = str(query.compile(dialect=sqlite.dialect()))            if versions:              table_name = self.table.name              query = query + f\" AND {table_name}.version IN ({','.join(['?']*len(versions))})\"              parameters.extend(versions)            if entry := self.db.execute(query, parameters).fetchone():              return self.model_type.from_dict(entry)          return None        #############################      # ##   Private methods   ## #      #############################      def __insert_model(self, model: ModelType):          query = self.table.insert()          self.db.execute(str(query.compile(dialect=sqlite.dialect())), model.to_list())          self.db.commit()        def _update_entry(self, model):          query = self.table.update().filter_by(id=model.id)          self.db.execute(str(query.compile(dialect=sqlite.dialect())), model.to_list() + [model.id])          self.db.commit()        @staticmethod      def __serialize_filter_values(value):          if isinstance(value, (dict, list)):              return json.dumps(value).replace('\"', \"'\")          return value "}
{"text": "#  # Licensed under the Apache License, Version 2.0 (the \"License\"); you may not use this file except in compliance with  # the License. You may obtain a copy of the License at  #  #        http://www.apache.org/licenses/LICENSE-2.0  #  # Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on  # an \"AS IS\" BASIS, WITHOUT 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": "import re  from copy import copy  from typing import Any, Dict, Optional, Union    from taipy.config import Config, UniqueSection  from taipy.config._config import _Config  from taipy.config.common._config_blocker import _ConfigBlocker  from taipy.config.common._template_handler import _TemplateHandler as _tpl    from .._init_version import _read_version  from ..exceptions.exceptions import ConfigCoreVersionMismatched      class CoreSection(UniqueSection):      \"\"\"      Configuration parameters for running the `Core^` service.        Attributes:          root_folder (str): Path of the base folder for the taipy application. The default value is \"./taipy/\"          storage_folder (str): Folder name used to store Taipy data. The default value is \".data/\". It is used in              conjunction with the *root_folder* attribute. That means the storage path is <root_folder><storage_folder>              (The default path is \"./taipy/.data/\").          repository_type (str): Type of the repository to be used to store Taipy data. The default value is              \"filesystem\".          repository_properties (Dict[str, Union[str, int]]): A dictionary of additional properties to be used by the              repository.          read_entity_retry (int): Number of retries to read an entity from the repository before return failure.              The default value is 3.          mode (str): The Taipy operating mode. By default, the `Core^` service runs in \"development\" mode.              An \"experiment\" and a \"production\" mode are also available. Please refer to the              [Versioning management](../core/versioning/index.md) documentation page for more details.          version_number (str)): The identifier of the user application version. Please refer to the              [Versioning management](../core/versioning/index.md) documentation page for more details.          force (bool): If True, force the application run even if there are some conflicts in the              configuration.          core_version (str): The Taipy Core package version.          **properties (dict[str, any]): A dictionary of additional properties.      \"\"\"        name = \"CORE\"        _ROOT_FOLDER_KEY = \"root_folder\"      _DEFAULT_ROOT_FOLDER = \"./taipy/\"        _STORAGE_FOLDER_KEY = \"storage_folder\"      _DEFAULT_STORAGE_FOLDER = \".data/\"        _REPOSITORY_TYPE_KEY = \"repository_type\"      _DEFAULT_REPOSITORY_TYPE = \"filesystem\"      _REPOSITORY_PROPERTIES_KEY = \"repository_properties\"      _DEFAULT_REPOSITORY_PROPERTIES: Dict = dict()        _READ_ENTITY_RETRY_KEY = \"read_entity_retry\"      _DEFAULT_READ_ENTITY_RETRY = 1        _MODE_KEY = \"mode\"      _DEVELOPMENT_MODE = \"development\"      _EXPERIMENT_MODE = \"experiment\"      _PRODUCTION_MODE = \"production\"      _DEFAULT_MODE = _DEVELOPMENT_MODE        _VERSION_NUMBER_KEY = \"version_number\"      _DEFAULT_VERSION_NUMBER = \"\"        _FORCE_KEY = \"force\"      _DEFAULT_FORCE = False        _CORE_VERSION_KEY = \"core_version\"      _CURRENT_CORE_VERSION = _read_version()        def __init__(          self,          root_folder: Optional[str] = None,          storage_folder: Optional[str] = None,          repository_type: Optional[str] = None,          repository_properties: Optional[Dict[str, Union[str, int]]] = None,          read_entity_retry: Optional[int] = None,          mode: Optional[str] = None,          version_number: Optional[str] = None,          force: Optional[bool] = None,          core_version: Optional[str] = None,          **properties,      ):          self._root_folder = root_folder          self._storage_folder = storage_folder          self._repository_type = repository_type          self._repository_properties = repository_properties or {}          self._read_entity_retry = (              read_entity_retry if read_entity_retry is not None else self._DEFAULT_READ_ENTITY_RETRY          )          self.mode = mode or self._DEFAULT_MODE          self.version_number = version_number or self._DEFAULT_VERSION_NUMBER          self.force = force or self._DEFAULT_FORCE            self._check_compatibility(core_version)          self._core_version = core_version            super().__init__(**properties)        def __copy__(self):          return CoreSection(              self.root_folder,              self.storage_folder,              self.repository_type,              self.repository_properties,              self.read_entity_retry,              self.mode,              self.version_number,              self.force,              self._core_version,              **copy(self._properties),          )        @property      def storage_folder(self):          return _tpl._replace_templates(self._storage_folder)        @storage_folder.setter  # type: ignore      @_ConfigBlocker._check()      def storage_folder(self, val):          self._storage_folder = val        @property      def root_folder(self):          return _tpl._replace_templates(self._root_folder)        @root_folder.setter  # type: ignore      @_ConfigBlocker._check()      def root_folder(self, val):          self._root_folder = val        @property      def repository_type(self):          return _tpl._replace_templates(self._repository_type)        @repository_type.setter  # type: ignore      @_ConfigBlocker._check()      def repository_type(self, val):          self._repository_type = val        @property      def repository_properties(self):          return (              {k: _tpl._replace_templates(v) for k, v in self._repository_properties.items()}              if self._repository_properties              else self._DEFAULT_REPOSITORY_PROPERTIES.copy()          )        @repository_properties.setter  # type: ignore      @_ConfigBlocker._check()      def repository_properties(self, val):          self._repository_properties = val        @property      def read_entity_retry(self):          return _tpl._replace_templates(self._read_entity_retry)        @read_entity_retry.setter  # type: ignore      @_ConfigBlocker._check()      def read_entity_retry(self, val):          self._read_entity_retry = val        @classmethod      def default_config(cls):          return CoreSection(              cls._DEFAULT_ROOT_FOLDER,              cls._DEFAULT_STORAGE_FOLDER,              cls._DEFAULT_REPOSITORY_TYPE,              cls._DEFAULT_REPOSITORY_PROPERTIES,              cls._DEFAULT_READ_ENTITY_RETRY,              cls._DEFAULT_MODE,              cls._DEFAULT_VERSION_NUMBER,              cls._DEFAULT_FORCE,              cls._CURRENT_CORE_VERSION,          )        def _clean(self):          self._root_folder = self._DEFAULT_ROOT_FOLDER          self._storage_folder = self._DEFAULT_STORAGE_FOLDER          self._repository_type = self._DEFAULT_REPOSITORY_TYPE          self._repository_properties = self._DEFAULT_REPOSITORY_PROPERTIES.copy()          self._read_entity_retry = self._DEFAULT_READ_ENTITY_RETRY          self.mode = self._DEFAULT_MODE          self.version_number = self._DEFAULT_VERSION_NUMBER          self.force = self._DEFAULT_FORCE          self._core_version = self._CURRENT_CORE_VERSION          self._properties.clear()        def _to_dict(self):          as_dict = {}          if self._root_folder:              as_dict[self._ROOT_FOLDER_KEY] = self._root_folder          if self._storage_folder:              as_dict[self._STORAGE_FOLDER_KEY] = self._storage_folder          if self._repository_type:              as_dict[self._REPOSITORY_TYPE_KEY] = self._repository_type          if self._repository_properties:              as_dict[self._REPOSITORY_PROPERTIES_KEY] = self._repository_properties          if self._read_entity_retry is not None:              as_dict[self._READ_ENTITY_RETRY_KEY] = self._read_entity_retry          if self.mode is not None:              as_dict[self._MODE_KEY] = self.mode          if self.version_number is not None:              as_dict[self._VERSION_NUMBER_KEY] = self.version_number          if self.force is not None:              as_dict[self._FORCE_KEY] = self.force          if self._core_version is not None:              as_dict[self._CORE_VERSION_KEY] = self._core_version          as_dict.update(self._properties)          return as_dict        @classmethod      def _from_dict(cls, as_dict: Dict[str, Any], id=None, config: Optional[_Config] = None):          root_folder = as_dict.pop(cls._ROOT_FOLDER_KEY, None)          storage_folder = as_dict.pop(cls._STORAGE_FOLDER_KEY, None)          repository_type = as_dict.pop(cls._REPOSITORY_TYPE_KEY, None)          repository_properties = as_dict.pop(cls._REPOSITORY_PROPERTIES_KEY, None)          read_entity_retry = as_dict.pop(cls._READ_ENTITY_RETRY_KEY, None)          mode = as_dict.pop(cls._MODE_KEY, None)          version_nb = as_dict.pop(cls._VERSION_NUMBER_KEY, None)          force = as_dict.pop(cls._FORCE_KEY, None)          core_version = as_dict.pop(cls._CORE_VERSION_KEY, None)          return CoreSection(              root_folder,              storage_folder,              repository_type,              repository_properties,              read_entity_retry,              mode,              version_nb,              force,              core_version,              **as_dict,          )        def _update(self, as_dict: Dict[str, Any]):          root_folder = _tpl._replace_templates(as_dict.pop(self._ROOT_FOLDER_KEY, self._root_folder))          if self._root_folder != root_folder:              self._root_folder = root_folder            storage_folder = _tpl._replace_templates(as_dict.pop(self._STORAGE_FOLDER_KEY, self._storage_folder))          if self._storage_folder != storage_folder:              self._storage_folder = storage_folder            repository_type = _tpl._replace_templates(as_dict.pop(self._REPOSITORY_TYPE_KEY, self._repository_type))          if self._repository_type != repository_type:              self._repository_type = repository_type            repository_properties = _tpl._replace_templates(              as_dict.pop(self._REPOSITORY_PROPERTIES_KEY, self._repository_properties)          )          self._repository_properties.update(repository_properties)            read_entity_retry = _tpl._replace_templates(as_dict.pop(self._READ_ENTITY_RETRY_KEY, self._read_entity_retry))          if self._read_entity_retry != read_entity_retry:              self._read_entity_retry = read_entity_retry            mode = _tpl._replace_templates(as_dict.pop(self._MODE_KEY, self.mode))          if self.mode != mode:              self.mode = mode            version_number = _tpl._replace_templates(as_dict.pop(self._VERSION_NUMBER_KEY, self.version_number))          if self.version_number != version_number:              self.version_number = version_number            force = _tpl._replace_templates(as_dict.pop(self._FORCE_KEY, self.force))          if self.force != force:              self.force = force            core_version = as_dict.pop(self._CORE_VERSION_KEY, None)          self._check_compatibility(core_version)            self._properties.update(as_dict)        @classmethod      def _check_compatibility(cls, core_version):          if not core_version:              return            version_pattern = r\"^(\\d+)\\.(\\d+)\\.(\\d+)$\"          dev_version_pattern = r\"^(\\d+)\\.(\\d+)\\.(\\d+).(\\w*)$\"            installed_match = re.match(version_pattern, cls._CURRENT_CORE_VERSION) or re.match(              dev_version_pattern, cls._CURRENT_CORE_VERSION          )          required_match = re.match(version_pattern, core_version) or re.match(dev_version_pattern, core_version)          if required_match and installed_match:              installed_group = installed_match.groups()              required_group = required_match.groups()              installed_major, installed_minor = installed_group[0], installed_group[1]              required_major, required_minor = required_group[0], required_group[1]                if required_major != installed_major or required_minor != installed_minor:                  raise ConfigCoreVersionMismatched(core_version, cls._CURRENT_CORE_VERSION)        @staticmethod      def _configure(          root_folder: Optional[str] = None,          storage_folder: Optional[str] = None,          repository_type: Optional[str] = None,          repository_properties: Optional[Dict[str, Union[str, int]]] = None,          read_entity_retry: Optional[int] = None,          mode: Optional[str] = None,          version_number: Optional[str] = None,          force: Optional[bool] = None,          **properties,      ) -> \"CoreSection\":          \"\"\"Configure the Core service.            Parameters:              root_folder (Optional[str]): Path of the base folder for the taipy application.                  The default value is \"./taipy/\"              storage_folder (Optional[str]): Folder name used to store Taipy data. The default value is \".data/\".                  It is used in conjunction with the `root_folder` field. That means the storage path is                  <root_folder><storage_folder> (The default path is \"./taipy/.data/\").              repository_type (Optional[str]): The type of the repository to be used to store Taipy data.                  The default value is \"filesystem\".              repository_properties (Optional[Dict[str, Union[str, int]]]): A dictionary of additional properties                  to be used by the repository.              read_entity_retry (Optional[int]): Number of retries to read an entity from the repository                  before return failure. The default value is 3.              mode (Optional[str]): Indicates the mode of the version management system.                  Possible values are *\"development\"*, *\"experiment\"*, or *\"production\"*.              version_number (Optional[str]): The string identifier of the version.                   In development mode, the version number is ignored.              force (Optional[bool]): If True, Taipy will override a version even if the configuration                  has changed and run the application.              **properties (Dict[str, Any]): A keyworded variable length list of additional arguments configure the                  behavior of the `Core^` service.          Returns:              The Core configuration.          \"\"\"          section = CoreSection(              root_folder=root_folder,              storage_folder=storage_folder,              repository_type=repository_type,              repository_properties=repository_properties,              read_entity_retry=read_entity_retry,              mode=mode,              version_number=version_number,              force=force,              core_version=_read_version(),              **properties,          )          Config._register(section)          return Config.unique_sections[CoreSection.name] "}
{"text": "from collections import defaultdict  from copy import copy  from typing import Any, Callable, Dict, List, Optional, Union    from taipy.config._config import _Config  from taipy.config.common._template_handler import _TemplateHandler as _tpl  from taipy.config.common._validate_id import _validate_id  from taipy.config.common.frequency import Frequency  from taipy.config.config import Config  from taipy.config.section import Section    from .data_node_config import DataNodeConfig  from .task_config import TaskConfig      class ScenarioConfig(Section):      \"\"\"      Configuration fields needed to instantiate an actual `Scenario^`.        Attributes:          id (str): Identifier of the scenario config. It must be a valid Python variable name.          tasks (Optional[Union[TaskConfig, List[TaskConfig]]]): List of task configs.<br/>              The default value is None.          additional_data_nodes (Optional[Union[DataNodeConfig, List[DataNodeConfig]]]): <br/>              List of additional data node configs. The default value is None.          frequency (Optional[Frequency]): The frequency of the scenario's cycle. The default value is None.          comparators: Optional[Dict[str, Union[List[Callable], Callable]]]: Dictionary of the data node <br/>              config id as key and a list of Callable used to compare the data nodes as value.          sequences (Optional[Dict[str, List[TaskConfig]]]): Dictionary of sequence descriptions.              The default value is None.          **properties (dict[str, any]): A dictionary of additional properties.      \"\"\"        name = \"SCENARIO\"        _SEQUENCES_KEY = \"sequences\"      _TASKS_KEY = \"tasks\"      _ADDITIONAL_DATA_NODES_KEY = \"additional_data_nodes\"      _FREQUENCY_KEY = \"frequency\"      _SEQUENCES_KEY = \"sequences\"      _COMPARATOR_KEY = \"comparators\"        def __init__(          self,          id: str,          tasks: Optional[Union[TaskConfig, List[TaskConfig]]] = None,          additional_data_nodes: Optional[Union[DataNodeConfig, List[DataNodeConfig]]] = None,          frequency: Optional[Frequency] = None,          comparators: Optional[Dict[str, Union[List[Callable], Callable]]] = None,          sequences: Optional[Dict[str, List[TaskConfig]]] = None,          **properties,      ):            if tasks:              self._tasks = list(tasks) if isinstance(tasks, TaskConfig) else copy(tasks)          else:              self._tasks = []            if additional_data_nodes:              self._additional_data_nodes = (                  list(additional_data_nodes)                  if isinstance(additional_data_nodes, DataNodeConfig)                  else copy(additional_data_nodes)              )          else:              self._additional_data_nodes = []            self.sequences = sequences if sequences else {}          self.frequency = frequency          self.comparators = defaultdict(list)            if comparators:              for k, v in comparators.items():                  if isinstance(v, list):                      self.comparators[_validate_id(k)].extend(v)                  else:                      self.comparators[_validate_id(k)].append(v)          super().__init__(id, **properties)        def __copy__(self):          comp = None if self.comparators is None else self.comparators          scenario_config = ScenarioConfig(              self.id,              copy(self._tasks),              copy(self._additional_data_nodes),              self.frequency,              copy(comp),              copy(self.sequences),              **copy(self._properties),          )          return scenario_config        def __getattr__(self, item: str) -> Optional[Any]:          return _tpl._replace_templates(self._properties.get(item))        @property      def task_configs(self) -> List[TaskConfig]:          return self._tasks        @property      def tasks(self) -> List[TaskConfig]:          return self._tasks        @property      def additional_data_node_configs(self) -> List[DataNodeConfig]:          return self._additional_data_nodes        @property      def additional_data_nodes(self) -> List[DataNodeConfig]:          return self._additional_data_nodes        @property      def data_node_configs(self) -> List[DataNodeConfig]:          return self.__get_all_unique_data_nodes()        @property      def data_nodes(self) -> List[DataNodeConfig]:          return self.__get_all_unique_data_nodes()        def __get_all_unique_data_nodes(self) -> List[DataNodeConfig]:          data_node_configs = set(self._additional_data_nodes)          for task in self._tasks:              data_node_configs.update(task.inputs)              data_node_configs.update(task.outputs)            return list(data_node_configs)        @classmethod      def default_config(cls):          return ScenarioConfig(cls._DEFAULT_KEY, list(), list(), None, dict())        def _clean(self):          self._tasks = list()          self._additional_data_nodes = list()          self.frequency = None          self.comparators = dict()          self.sequences = dict()          self._properties = dict()        def _to_dict(self) -> Dict[str, Any]:          return {              self._COMPARATOR_KEY: self.comparators,              self._TASKS_KEY: self._tasks,              self._ADDITIONAL_DATA_NODES_KEY: self._additional_data_nodes,              self._FREQUENCY_KEY: self.frequency,              self._SEQUENCES_KEY: self.sequences,              **self._properties,          }        @classmethod      def _from_dict(          cls, as_dict: Dict[str, Any], id: str, config: Optional[_Config] = None      ) -> \"ScenarioConfig\":  # type: ignore          as_dict.pop(cls._ID_KEY, id)            tasks = cls.__get_task_configs(as_dict.pop(cls._TASKS_KEY, list()), config)            additional_data_node_ids = as_dict.pop(cls._ADDITIONAL_DATA_NODES_KEY, list())          additional_data_nodes = cls.__get_additional_data_node_configs(additional_data_node_ids, config)            frequency = as_dict.pop(cls._FREQUENCY_KEY, None)          comparators = as_dict.pop(cls._COMPARATOR_KEY, dict())          sequences = as_dict.pop(cls._SEQUENCES_KEY, {})            for sequence_name, sequence_tasks in sequences.items():              sequences[sequence_name] = cls.__get_task_configs(sequence_tasks, config)            scenario_config = ScenarioConfig(              id=id,              tasks=tasks,              additional_data_nodes=additional_data_nodes,              frequency=frequency,              comparators=comparators,              sequences=sequences,              **as_dict,          )            return scenario_config        @staticmethod      def __get_task_configs(task_config_ids: List[str], config: Optional[_Config]):          task_configs = set()          if config:              if task_config_section := config._sections.get(TaskConfig.name):                  for task_config_id in task_config_ids:                      if task_config := task_config_section.get(task_config_id, None):                          task_configs.add(task_config)          return list(task_configs)        @staticmethod      def __get_additional_data_node_configs(additional_data_node_ids: List[str], config: Optional[_Config]):          additional_data_node_configs = set()          if config:              if data_node_config_section := config._sections.get(DataNodeConfig.name):                  for additional_data_node_id in additional_data_node_ids:                      if additional_data_node_config := data_node_config_section.get(additional_data_node_id):                          additional_data_node_configs.add(additional_data_node_config)          return list(additional_data_node_configs)        def _update(self, as_dict: Dict[str, Any], default_section=None):          self._tasks = as_dict.pop(self._TASKS_KEY, self._tasks)          if self._tasks is None and default_section:              self._tasks = default_section._tasks            self._additional_data_nodes = as_dict.pop(self._ADDITIONAL_DATA_NODES_KEY, self._additional_data_nodes)          if self._additional_data_nodes is None and default_section:              self._additional_data_nodes = default_section._additional_data_nodes            self.frequency = as_dict.pop(self._FREQUENCY_KEY, self.frequency)          if self.frequency is None and default_section:              self.frequency = default_section.frequency            self.comparators = as_dict.pop(self._COMPARATOR_KEY, self.comparators)          if self.comparators is None and default_section:              self.comparators = default_section.comparators            self.sequences = as_dict.pop(self._SEQUENCES_KEY, self.sequences)          if self.sequences is None and default_section:              self.sequences = default_section.sequences            self._properties.update(as_dict)          if default_section:              self._properties = {**default_section.properties, **self._properties}        def add_comparator(self, dn_config_id: str, comparator: Callable):          self.comparators[dn_config_id].append(comparator)        def delete_comparator(self, dn_config_id: str):          if dn_config_id in self.comparators:              del self.comparators[dn_config_id]        @staticmethod      def _configure(          id: str,          task_configs: Optional[List[TaskConfig]] = None,          additional_data_node_configs: Optional[List[DataNodeConfig]] = None,          frequency: Optional[Frequency] = None,          comparators: Optional[Dict[str, Union[List[Callable], Callable]]] = None,          sequences: Optional[Dict[str, List[TaskConfig]]] = None,          **properties,      ) -> \"ScenarioConfig\":          \"\"\"Configure a new scenario configuration.            Parameters:              id (str): The unique identifier of the new scenario configuration.              task_configs (Optional[List[TaskConfig^]]): The list of task configurations used by this                  scenario configuration. The default value is None.              additional_data_node_configs (Optional[List[DataNodeConfig^]]): The list of additional data nodes                  related to this scenario configuration. The default value is None.              frequency (Optional[Frequency^]): The scenario frequency.<br/>                  It corresponds to the recurrence of the scenarios instantiated from this                  configuration. Based on this frequency each scenario will be attached to the                  relevant cycle.              comparators (Optional[Dict[str, Union[List[Callable], Callable]]]): The list of                  functions used to compare scenarios. A comparator function is attached to a                  scenario's data node configuration. The key of the dictionary parameter                  corresponds to the data node configuration id. During the scenarios'                  comparison, each comparator is applied to all the data nodes instantiated from                  the data node configuration attached to the comparator. See                  `(taipy.)compare_scenarios()^` more more details.              sequences (Optional[Dict[str, List[TaskConfig]]]): Dictionary of sequence descriptions.                  The default value is None.              **properties (dict[str, any]): A keyworded variable length list of additional arguments.            Returns:              The new scenario configuration.          \"\"\"          section = ScenarioConfig(              id,              task_configs,              additional_data_node_configs,              frequency=frequency,              comparators=comparators,              sequences=sequences,              **properties,          )          Config._register(section)          return Config.sections[ScenarioConfig.name][id]        @staticmethod      def _set_default_configuration(          task_configs: Optional[List[TaskConfig]] = None,          additional_data_node_configs: List[DataNodeConfig] = None,          frequency: Optional[Frequency] = None,          comparators: Optional[Dict[str, Union[List[Callable], Callable]]] = None,          sequences: Optional[Dict[str, List[TaskConfig]]] = None,          **properties,      ) -> \"ScenarioConfig\":          \"\"\"Set the default values for scenario configurations.            This function creates the *default scenario configuration* object,          where all scenario configuration objects will find their default          values when needed.            Parameters:              task_configs (Optional[List[TaskConfig^]]): The list of task configurations used by this                  scenario configuration.              additional_data_node_configs (Optional[List[DataNodeConfig^]]): The list of additional data nodes                  related to this scenario configuration.              frequency (Optional[Frequency^]): The scenario frequency.                  It corresponds to the recurrence of the scenarios instantiated from this                  configuration. Based on this frequency each scenario will be attached to                  the relevant cycle.              comparators (Optional[Dict[str, Union[List[Callable], Callable]]]): The list of                  functions used to compare scenarios. A comparator function is attached to a                  scenario's data node configuration. The key of the dictionary parameter                  corresponds to the data node configuration id. During the scenarios'                  comparison, each comparator is applied to all the data nodes instantiated from                  the data node configuration attached to the comparator. See                  `taipy.compare_scenarios()^` more more details.              sequences (Optional[Dict[str, List[TaskConfig]]]): Dictionary of sequences. The default value is None.              **properties (dict[str, any]): A keyworded variable length list of additional arguments.            Returns:              The new default scenario configuration.          \"\"\"          section = ScenarioConfig(              _Config.DEFAULT_KEY,              task_configs,              additional_data_node_configs,              frequency=frequency,              comparators=comparators,              sequences=sequences,              **properties,          )          Config._register(section)          return Config.sections[ScenarioConfig.name][_Config.DEFAULT_KEY]        def add_sequences(self, sequences: Dict[str, List[TaskConfig]]):          self.sequences.update(sequences)        def remove_sequences(self, sequence_names: Union[str, List[str]]):          if isinstance(sequence_names, List):              for sequence_name in sequence_names:                  self.sequences.pop(sequence_name)          else:              self.sequences.pop(sequence_names) "}
{"text": "import json  from copy import copy  from datetime import timedelta  from typing import Any, Callable, Dict, List, Optional, Union    from taipy.config._config import _Config  from taipy.config.common._config_blocker import _ConfigBlocker  from taipy.config.common._template_handler import _TemplateHandler as _tpl  from taipy.config.common.scope import Scope  from taipy.config.config import Config  from taipy.config.section import Section    from ..common._warnings import _warn_deprecated  from ..common.mongo_default_document import MongoDefaultDocument      class DataNodeConfig(Section):      \"\"\"      Configuration fields needed to instantiate a `DataNode^`.        A Data Node config is made to be used as a generator for actual data nodes. It holds configuration information      needed to create an actual data node.        Attributes:          id (str): Unique identifier of the data node config. It must be a valid Python variable name.          storage_type (str): Storage type of the data nodes created from the data node config. The possible values              are : \"csv\", \"excel\", \"pickle\", \"sql_table\", \"sql\", \"mongo_collection\", \"generic\", \"json\", \"parquet\" and              \"in_memory\".              The default value is \"pickle\".              Note that the \"in_memory\" value can only be used when `JobConfig^`.mode is \"standalone\".          scope (Optional[Scope^]): The optional `Scope^` of the data nodes instantiated from the data node config.              The default value is SCENARIO.          **properties (dict[str, any]): A dictionary of additional properties.      \"\"\"        name = \"DATA_NODE\"        _STORAGE_TYPE_KEY = \"storage_type\"      _STORAGE_TYPE_VALUE_PICKLE = \"pickle\"      _STORAGE_TYPE_VALUE_SQL_TABLE = \"sql_table\"      _STORAGE_TYPE_VALUE_SQL = \"sql\"      _STORAGE_TYPE_VALUE_MONGO_COLLECTION = \"mongo_collection\"      _STORAGE_TYPE_VALUE_CSV = \"csv\"      _STORAGE_TYPE_VALUE_EXCEL = \"excel\"      _STORAGE_TYPE_VALUE_IN_MEMORY = \"in_memory\"      _STORAGE_TYPE_VALUE_GENERIC = \"generic\"      _STORAGE_TYPE_VALUE_JSON = \"json\"      _STORAGE_TYPE_VALUE_PARQUET = \"parquet\"      _DEFAULT_STORAGE_TYPE = _STORAGE_TYPE_VALUE_PICKLE      _ALL_STORAGE_TYPES = [          _STORAGE_TYPE_VALUE_PICKLE,          _STORAGE_TYPE_VALUE_SQL_TABLE,          _STORAGE_TYPE_VALUE_SQL,          _STORAGE_TYPE_VALUE_MONGO_COLLECTION,          _STORAGE_TYPE_VALUE_CSV,          _STORAGE_TYPE_VALUE_EXCEL,          _STORAGE_TYPE_VALUE_IN_MEMORY,          _STORAGE_TYPE_VALUE_GENERIC,          _STORAGE_TYPE_VALUE_JSON,          _STORAGE_TYPE_VALUE_PARQUET,      ]        _EXPOSED_TYPE_KEY = \"exposed_type\"      _EXPOSED_TYPE_PANDAS = \"pandas\"      _EXPOSED_TYPE_MODIN = \"modin\"      _EXPOSED_TYPE_NUMPY = \"numpy\"      _DEFAULT_EXPOSED_TYPE = _EXPOSED_TYPE_PANDAS        _ALL_EXPOSED_TYPES = [          _EXPOSED_TYPE_PANDAS,          _EXPOSED_TYPE_MODIN,          _EXPOSED_TYPE_NUMPY,      ]        _OPTIONAL_ENCODING_PROPERTY = \"encoding\"      _DEFAULT_ENCODING_VALUE = \"utf-8\"        # Generic      _OPTIONAL_READ_FUNCTION_GENERIC_PROPERTY = \"read_fct\"      _OPTIONAL_READ_FUNCTION_ARGS_GENERIC_PROPERTY = \"read_fct_args\"      _OPTIONAL_WRITE_FUNCTION_GENERIC_PROPERTY = \"write_fct\"      _OPTIONAL_WRITE_FUNCTION_ARGS_GENERIC_PROPERTY = \"write_fct_args\"      # CSV      _OPTIONAL_EXPOSED_TYPE_CSV_PROPERTY = \"exposed_type\"      _OPTIONAL_DEFAULT_PATH_CSV_PROPERTY = \"default_path\"      _OPTIONAL_HAS_HEADER_CSV_PROPERTY = \"has_header\"      # Excel      _OPTIONAL_EXPOSED_TYPE_EXCEL_PROPERTY = \"exposed_type\"      _OPTIONAL_DEFAULT_PATH_EXCEL_PROPERTY = \"default_path\"      _OPTIONAL_HAS_HEADER_EXCEL_PROPERTY = \"has_header\"      _OPTIONAL_SHEET_NAME_EXCEL_PROPERTY = \"sheet_name\"      # In memory      _OPTIONAL_DEFAULT_DATA_IN_MEMORY_PROPERTY = \"default_data\"      # SQL      _REQUIRED_DB_NAME_SQL_PROPERTY = \"db_name\"      _REQUIRED_DB_ENGINE_SQL_PROPERTY = \"db_engine\"      _DB_ENGINE_SQLITE = \"sqlite\"      _OPTIONAL_FOLDER_PATH_SQLITE_PROPERTY = \"sqlite_folder_path\"      _OPTIONAL_FILE_EXTENSION_SQLITE_PROPERTY = \"sqlite_file_extension\"      _OPTIONAL_DB_PASSWORD_SQL_PROPERTY = \"db_password\"      _OPTIONAL_DB_USERNAME_SQL_PROPERTY = \"db_username\"      _OPTIONAL_PORT_SQL_PROPERTY = \"db_port\"      _OPTIONAL_HOST_SQL_PROPERTY = \"db_host\"      _OPTIONAL_DRIVER_SQL_PROPERTY = \"db_driver\"      _OPTIONAL_DB_EXTRA_ARGS_SQL_PROPERTY = \"db_extra_args\"      _OPTIONAL_EXPOSED_TYPE_SQL_PROPERTY = \"exposed_type\"      # SQL_TABLE      _REQUIRED_TABLE_NAME_SQL_TABLE_PROPERTY = \"table_name\"      # SQL      _REQUIRED_READ_QUERY_SQL_PROPERTY = \"read_query\"      _REQUIRED_WRITE_QUERY_BUILDER_SQL_PROPERTY = \"write_query_builder\"      _OPTIONAL_APPEND_QUERY_BUILDER_SQL_PROPERTY = \"append_query_builder\"      # MONGO      _REQUIRED_DB_NAME_MONGO_PROPERTY = \"db_name\"      _REQUIRED_COLLECTION_NAME_MONGO_PROPERTY = \"collection_name\"      _OPTIONAL_CUSTOM_DOCUMENT_MONGO_PROPERTY = \"custom_document\"      _OPTIONAL_USERNAME_MONGO_PROPERTY = \"db_username\"      _OPTIONAL_PASSWORD_MONGO_PROPERTY = \"db_password\"      _OPTIONAL_HOST_MONGO_PROPERTY = \"db_host\"      _OPTIONAL_PORT_MONGO_PROPERTY = \"db_port\"      _OPTIONAL_DRIVER_MONGO_PROPERTY = \"db_driver\"      _OPTIONAL_DB_EXTRA_ARGS_MONGO_PROPERTY = \"db_extra_args\"      # Pickle      _OPTIONAL_DEFAULT_PATH_PICKLE_PROPERTY = \"default_path\"      _OPTIONAL_DEFAULT_DATA_PICKLE_PROPERTY = \"default_data\"      # JSON      _OPTIONAL_ENCODER_JSON_PROPERTY = \"encoder\"      _OPTIONAL_DECODER_JSON_PROPERTY = \"decoder\"      _OPTIONAL_DEFAULT_PATH_JSON_PROPERTY = \"default_path\"      # Parquet      _OPTIONAL_EXPOSED_TYPE_PARQUET_PROPERTY = \"exposed_type\"      _OPTIONAL_DEFAULT_PATH_PARQUET_PROPERTY = \"default_path\"      _OPTIONAL_ENGINE_PARQUET_PROPERTY = \"engine\"      _OPTIONAL_COMPRESSION_PARQUET_PROPERTY = \"compression\"      _OPTIONAL_READ_KWARGS_PARQUET_PROPERTY = \"read_kwargs\"      _OPTIONAL_WRITE_KWARGS_PARQUET_PROPERTY = \"write_kwargs\"        _REQUIRED_PROPERTIES: Dict[str, List] = {          _STORAGE_TYPE_VALUE_PICKLE: [],          _STORAGE_TYPE_VALUE_SQL_TABLE: [              _REQUIRED_DB_NAME_SQL_PROPERTY,              _REQUIRED_DB_ENGINE_SQL_PROPERTY,              _REQUIRED_TABLE_NAME_SQL_TABLE_PROPERTY,          ],          _STORAGE_TYPE_VALUE_SQL: [              _REQUIRED_DB_NAME_SQL_PROPERTY,              _REQUIRED_DB_ENGINE_SQL_PROPERTY,              _REQUIRED_READ_QUERY_SQL_PROPERTY,              _REQUIRED_WRITE_QUERY_BUILDER_SQL_PROPERTY,          ],          _STORAGE_TYPE_VALUE_MONGO_COLLECTION: [              _REQUIRED_DB_NAME_MONGO_PROPERTY,              _REQUIRED_COLLECTION_NAME_MONGO_PROPERTY,          ],          _STORAGE_TYPE_VALUE_CSV: [],          _STORAGE_TYPE_VALUE_EXCEL: [],          _STORAGE_TYPE_VALUE_IN_MEMORY: [],          _STORAGE_TYPE_VALUE_GENERIC: [],          _STORAGE_TYPE_VALUE_JSON: [],          _STORAGE_TYPE_VALUE_PARQUET: [],      }        _OPTIONAL_PROPERTIES = {          _STORAGE_TYPE_VALUE_GENERIC: {              _OPTIONAL_READ_FUNCTION_GENERIC_PROPERTY: None,              _OPTIONAL_WRITE_FUNCTION_GENERIC_PROPERTY: None,              _OPTIONAL_READ_FUNCTION_ARGS_GENERIC_PROPERTY: None,              _OPTIONAL_WRITE_FUNCTION_ARGS_GENERIC_PROPERTY: None,          },          _STORAGE_TYPE_VALUE_CSV: {              _OPTIONAL_DEFAULT_PATH_CSV_PROPERTY: None,              _OPTIONAL_ENCODING_PROPERTY: _DEFAULT_ENCODING_VALUE,              _OPTIONAL_HAS_HEADER_CSV_PROPERTY: True,              _OPTIONAL_EXPOSED_TYPE_CSV_PROPERTY: _DEFAULT_EXPOSED_TYPE,          },          _STORAGE_TYPE_VALUE_EXCEL: {              _OPTIONAL_DEFAULT_PATH_EXCEL_PROPERTY: None,              _OPTIONAL_HAS_HEADER_EXCEL_PROPERTY: True,              _OPTIONAL_SHEET_NAME_EXCEL_PROPERTY: None,              _OPTIONAL_EXPOSED_TYPE_EXCEL_PROPERTY: _DEFAULT_EXPOSED_TYPE,          },          _STORAGE_TYPE_VALUE_IN_MEMORY: {_OPTIONAL_DEFAULT_DATA_IN_MEMORY_PROPERTY: None},          _STORAGE_TYPE_VALUE_SQL_TABLE: {              _OPTIONAL_DB_USERNAME_SQL_PROPERTY: None,              _OPTIONAL_DB_PASSWORD_SQL_PROPERTY: None,              _OPTIONAL_HOST_SQL_PROPERTY: \"localhost\",              _OPTIONAL_PORT_SQL_PROPERTY: 1433,              _OPTIONAL_DRIVER_SQL_PROPERTY: \"\",              _OPTIONAL_FOLDER_PATH_SQLITE_PROPERTY: None,              _OPTIONAL_FILE_EXTENSION_SQLITE_PROPERTY: \".db\",              _OPTIONAL_DB_EXTRA_ARGS_SQL_PROPERTY: None,              _OPTIONAL_EXPOSED_TYPE_SQL_PROPERTY: _DEFAULT_EXPOSED_TYPE,          },          _STORAGE_TYPE_VALUE_SQL: {              _OPTIONAL_DB_USERNAME_SQL_PROPERTY: None,              _OPTIONAL_DB_PASSWORD_SQL_PROPERTY: None,              _OPTIONAL_HOST_SQL_PROPERTY: \"localhost\",              _OPTIONAL_PORT_SQL_PROPERTY: 1433,              _OPTIONAL_DRIVER_SQL_PROPERTY: \"\",              _OPTIONAL_APPEND_QUERY_BUILDER_SQL_PROPERTY: None,              _OPTIONAL_FOLDER_PATH_SQLITE_PROPERTY: None,              _OPTIONAL_FILE_EXTENSION_SQLITE_PROPERTY: \".db\",              _OPTIONAL_DB_EXTRA_ARGS_SQL_PROPERTY: None,              _OPTIONAL_EXPOSED_TYPE_SQL_PROPERTY: _DEFAULT_EXPOSED_TYPE,          },          _STORAGE_TYPE_VALUE_MONGO_COLLECTION: {              _OPTIONAL_CUSTOM_DOCUMENT_MONGO_PROPERTY: MongoDefaultDocument,              _OPTIONAL_USERNAME_MONGO_PROPERTY: \"\",              _OPTIONAL_PASSWORD_MONGO_PROPERTY: \"\",              _OPTIONAL_HOST_MONGO_PROPERTY: \"localhost\",              _OPTIONAL_PORT_MONGO_PROPERTY: 27017,              _OPTIONAL_DRIVER_MONGO_PROPERTY: \"\",              _OPTIONAL_DB_EXTRA_ARGS_MONGO_PROPERTY: None,          },          _STORAGE_TYPE_VALUE_PICKLE: {              _OPTIONAL_DEFAULT_PATH_PICKLE_PROPERTY: None,              _OPTIONAL_DEFAULT_DATA_PICKLE_PROPERTY: None,          },          _STORAGE_TYPE_VALUE_JSON: {              _OPTIONAL_DEFAULT_PATH_PICKLE_PROPERTY: None,              _OPTIONAL_ENCODING_PROPERTY: _DEFAULT_ENCODING_VALUE,              _OPTIONAL_ENCODER_JSON_PROPERTY: None,              _OPTIONAL_DECODER_JSON_PROPERTY: None,          },          _STORAGE_TYPE_VALUE_PARQUET: {              _OPTIONAL_DEFAULT_PATH_PARQUET_PROPERTY: None,              _OPTIONAL_ENGINE_PARQUET_PROPERTY: \"pyarrow\",              _OPTIONAL_COMPRESSION_PARQUET_PROPERTY: \"snappy\",              _OPTIONAL_READ_KWARGS_PARQUET_PROPERTY: None,              _OPTIONAL_WRITE_KWARGS_PARQUET_PROPERTY: None,              _OPTIONAL_EXPOSED_TYPE_PARQUET_PROPERTY: _DEFAULT_EXPOSED_TYPE,          },      }        _SCOPE_KEY = \"scope\"      _DEFAULT_SCOPE = Scope.SCENARIO        _VALIDITY_PERIOD_KEY = \"validity_period\"      _DEFAULT_VALIDITY_PERIOD = None        def __init__(          self,          id: str,          storage_type: Optional[str] = None,          scope: Optional[Scope] = None,          validity_period: Optional[timedelta] = None,          **properties,      ):          self._storage_type = storage_type          self._scope = scope          self._validity_period = validity_period          super().__init__(id, **properties)        def __copy__(self):          return DataNodeConfig(self.id, self._storage_type, self._scope, self._validity_period, **copy(self._properties))        def __getattr__(self, item: str) -> Optional[Any]:          return _tpl._replace_templates(self._properties.get(item))        @property      def storage_type(self):          return _tpl._replace_templates(self._storage_type)        @storage_type.setter  # type: ignore      @_ConfigBlocker._check()      def storage_type(self, val):          self._storage_type = val        @property      def scope(self):          return _tpl._replace_templates(self._scope)        @scope.setter  # type: ignore      @_ConfigBlocker._check()      def scope(self, val):          self._scope = val        @property      def validity_period(self):          return _tpl._replace_templates(self._validity_period)        @validity_period.setter  # type: ignore      @_ConfigBlocker._check()      def validity_period(self, val):          self._validity_period = val        @property      def cacheable(self):          _warn_deprecated(\"cacheable\", suggest=\"the skippable feature\")          cacheable = self._properties.get(\"cacheable\")          if cacheable is not None:              return _tpl._replace_templates(cacheable)          else:              return False        @cacheable.setter  # type: ignore      @_ConfigBlocker._check()      def cacheable(self, val):          _warn_deprecated(\"cacheable\", suggest=\"the skippable feature\")          self._properties[\"cacheable\"] = val        @classmethod      def default_config(cls):          return DataNodeConfig(              cls._DEFAULT_KEY, cls._DEFAULT_STORAGE_TYPE, cls._DEFAULT_SCOPE, cls._DEFAULT_VALIDITY_PERIOD          )        def _clean(self):          self._storage_type = self._DEFAULT_STORAGE_TYPE          self._scope = self._DEFAULT_SCOPE          self._validity_period = self._DEFAULT_VALIDITY_PERIOD          self._properties.clear()        def _to_dict(self):          as_dict = {}          if self._storage_type is not None:              as_dict[self._STORAGE_TYPE_KEY] = self._storage_type          if self._scope is not None:              as_dict[self._SCOPE_KEY] = self._scope          if self._validity_period is not None:              as_dict[self._VALIDITY_PERIOD_KEY] = self._validity_period          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)          storage_type = as_dict.pop(cls._STORAGE_TYPE_KEY, None)          scope = as_dict.pop(cls._SCOPE_KEY, None)          validity_perid = as_dict.pop(cls._VALIDITY_PERIOD_KEY, None)          return DataNodeConfig(id=id, storage_type=storage_type, scope=scope, validity_period=validity_perid, **as_dict)        def _update(self, as_dict, default_section=None):          self._storage_type = as_dict.pop(self._STORAGE_TYPE_KEY, self._storage_type)          if self._storage_type is None and default_section:              self._storage_type = default_section.storage_type            self._scope = as_dict.pop(self._SCOPE_KEY, self._scope)          if self._scope is None and default_section:              if default_section.scope and self._storage_type == default_section.storage_type:                  self._scope = default_section.scope              else:                  self._scope = self._DEFAULT_SCOPE            self._validity_period = as_dict.pop(self._VALIDITY_PERIOD_KEY, self._validity_period)          if self._validity_period is None and default_section:              self._validity_period = default_section.validity_period            self._properties.update(as_dict)          if default_section and self._storage_type == default_section.storage_type:              self._properties = {**default_section.properties, **self._properties}            # Assign default value to optional properties if not defined by user          if self._OPTIONAL_PROPERTIES.get(self._storage_type):              for optional_property, default_value in self._OPTIONAL_PROPERTIES[self._storage_type].items():                  if default_value is not None and self._properties.get(optional_property) is None:                      self._properties[optional_property] = default_value        @staticmethod      def _set_default_configuration(          storage_type: str, scope: Optional[Scope] = None, validity_period: Optional[timedelta] = None, **properties      ) -> \"DataNodeConfig\":          \"\"\"Set the default values for data node configurations.            This function creates the _default data node configuration_ object,          where all data node configuration objects will find their default          values when needed.            Parameters:              storage_type (str): The default storage type for all data node configurations.                  The possible values are *\"pickle\"* (the default value), *\"csv\"*, *\"excel\"*,                  *\"sql\"*, *\"mongo_collection\"*, *\"in_memory\"*, *\"json\"*, *\"parquet\"* or                  *\"generic\"*.              scope (Optional[Scope^]): The default scope for all data node configurations.<br/>                  The default value is `Scope.SCENARIO`.              validity_period (Optional[timedelta]): The duration 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 configs page](../core/config/task-config.md) for more details).                  If *validity_period* is set to None, the data node is always up-to-date.              **properties (dict[str, any]): A keyworded variable length list of additional arguments.            Returns:              The default data node configuration.          \"\"\"          section = DataNodeConfig(_Config.DEFAULT_KEY, storage_type, scope, validity_period, **properties)          Config._register_default(section)          return Config.sections[DataNodeConfig.name][_Config.DEFAULT_KEY]        @classmethod      def _configure_from(          cls,          source_configuration: \"DataNodeConfig\",          id: str,          **properties,      ) -> \"DataNodeConfig\":          \"\"\"Configure a new data node configuration from an existing one.            Parameters:              source_configuration (DataNodeConfig): The source data node configuration.              id (str): The unique identifier of the new data node configuration.              **properties (dict[str, any]): A keyworded variable length list of additional arguments.<br/>                  The default properties are the properties of the source data node configuration.            Returns:              The new data node configuration.          \"\"\"          scope = properties.pop(\"scope\", None) or source_configuration.scope          validity_period = properties.pop(\"validity_period\", None) or source_configuration.validity_period          properties = {**source_configuration.properties, **properties}  # type: ignore            return cls.__configure(id, source_configuration.storage_type, scope, validity_period, **properties)        @classmethod      def _configure(          cls,          id: str,          storage_type: Optional[str] = None,          scope: Optional[Scope] = None,          validity_period: Optional[timedelta] = None,          **properties,      ) -> \"DataNodeConfig\":          \"\"\"Configure a new data node configuration.            Parameters:              id (str): The unique identifier of the new data node configuration.              storage_type (Optional[str]): The data node configuration storage type. The possible values                  are None (which is the default value of *\"pickle\"*, unless it has been overloaded by the                  *storage_type* value set in the default data node configuration                  (see `(Config.)set_default_data_node_configuration()^`)), *\"pickle\"*, *\"csv\"*, *\"excel\"*,                  *\"sql_table\"*, *\"sql\"*, *\"json\"*, *\"parquet\"*, *\"mongo_collection\"*, *\"in_memory\"*, or                  *\"generic\"*.              scope (Optional[Scope^]): The scope of the data node configuration.<br/>                  The default value is `Scope.SCENARIO` (or the one specified in                  `(Config.)set_default_data_node_configuration()^`).              validity_period (Optional[timedelta]): The duration 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 configs page](../core/config/task-config.md) for more details).                  If *validity_period* is set to None, the data node is always up-to-date.              **properties (dict[str, any]): A keyworded variable length list of additional arguments.            Returns:              The new data node configuration.          \"\"\"          configuration_map: Dict[str, Callable] = {              cls._STORAGE_TYPE_VALUE_PICKLE: cls._configure_pickle,              cls._STORAGE_TYPE_VALUE_SQL_TABLE: cls._configure_sql_table,              cls._STORAGE_TYPE_VALUE_SQL: cls._configure_sql,              cls._STORAGE_TYPE_VALUE_MONGO_COLLECTION: cls._configure_mongo_collection,              cls._STORAGE_TYPE_VALUE_CSV: cls._configure_csv,              cls._STORAGE_TYPE_VALUE_EXCEL: cls._configure_excel,              cls._STORAGE_TYPE_VALUE_IN_MEMORY: cls._configure_in_memory,              cls._STORAGE_TYPE_VALUE_GENERIC: cls._configure_generic,              cls._STORAGE_TYPE_VALUE_JSON: cls._configure_json,              cls._STORAGE_TYPE_VALUE_PARQUET: cls._configure_parquet,          }            if storage_type in cls._ALL_STORAGE_TYPES:              return configuration_map[storage_type](id=id, scope=scope, validity_period=validity_period, **properties)            return cls.__configure(id, storage_type, scope, validity_period, **properties)        @classmethod      def _configure_csv(          cls,          id: str,          default_path: Optional[str] = None,          encoding: Optional[str] = None,          has_header: Optional[bool] = None,          exposed_type: Optional[str] = None,          scope: Optional[Scope] = None,          validity_period: Optional[timedelta] = None,          **properties,      ) -> \"DataNodeConfig\":          \"\"\"Configure a new CSV data node configuration.            Parameters:              id (str): The unique identifier of the new CSV data node configuration.              default_path (Optional[str]): The default path of the CSV file.              encoding (Optional[str]): The encoding of the CSV file.              has_header (Optional[bool]): If True, indicates that the CSV file has a header.              exposed_type (Optional[str]): The exposed type of the data read from CSV file.<br/>                  The default value is `pandas`.              scope (Optional[Scope^]): The scope of the CSV data node configuration.<br/>                  The default value is `Scope.SCENARIO`.              validity_period (Optional[timedelta]): The duration 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 configs page](../core/config/task-config.md) for more details).                  If *validity_period* is set to None, the data node is always up-to-date.              **properties (dict[str, any]): A keyworded variable length list of additional arguments.            Returns:              The new CSV data node configuration.          \"\"\"          if default_path is not None:              properties[cls._OPTIONAL_DEFAULT_PATH_CSV_PROPERTY] = default_path          if encoding is not None:              properties[cls._OPTIONAL_ENCODING_PROPERTY] = encoding          if has_header is not None:              properties[cls._OPTIONAL_HAS_HEADER_CSV_PROPERTY] = has_header          if exposed_type is not None:              properties[cls._OPTIONAL_EXPOSED_TYPE_CSV_PROPERTY] = exposed_type            return cls.__configure(id, DataNodeConfig._STORAGE_TYPE_VALUE_CSV, scope, validity_period, **properties)        @classmethod      def _configure_json(          cls,          id: str,          default_path: Optional[str] = None,          encoding: Optional[str] = None,          encoder: Optional[json.JSONEncoder] = None,          decoder: Optional[json.JSONDecoder] = None,          scope: Optional[Scope] = None,          validity_period: Optional[timedelta] = None,          **properties,      ) -> \"DataNodeConfig\":          \"\"\"Configure a new JSON data node configuration.            Parameters:              id (str): The unique identifier of the new JSON data node configuration.              default_path (Optional[str]): The default path of the JSON file.              encoding (Optional[str]): The encoding of the JSON file.              encoder (Optional[json.JSONEncoder]): The JSON encoder used to write data into the JSON file.              decoder (Optional[json.JSONDecoder]): The JSON decoder used to read data from the JSON file.              scope (Optional[Scope^]): The scope of the JSON data node configuration.<br/>                  The default value is `Scope.SCENARIO`.              validity_period (Optional[timedelta]): The duration 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 configs page](../core/config/task-config.md) for more details).                  If *validity_period* is set to None, the data node is always up-to-date.              **properties (dict[str, any]): A keyworded variable length list of additional arguments.          Returns:              The new JSON data node configuration.          \"\"\"          if default_path is not None:              properties[cls._OPTIONAL_DEFAULT_PATH_JSON_PROPERTY] = default_path          if encoding is not None:              properties[cls._OPTIONAL_ENCODING_PROPERTY] = encoding          if encoder is not None:              properties[cls._OPTIONAL_ENCODER_JSON_PROPERTY] = encoder          if decoder is not None:              properties[cls._OPTIONAL_DECODER_JSON_PROPERTY] = decoder            return cls.__configure(id, DataNodeConfig._STORAGE_TYPE_VALUE_JSON, scope, validity_period, **properties)        @classmethod      def _configure_parquet(          cls,          id: str,          default_path: Optional[str] = None,          engine: Optional[str] = None,          compression: Optional[str] = None,          read_kwargs: Optional[Dict] = None,          write_kwargs: Optional[Dict] = None,          exposed_type: Optional[str] = None,          scope: Optional[Scope] = None,          validity_period: Optional[timedelta] = None,          **properties,      ) -> \"DataNodeConfig\":          \"\"\"Configure a new Parquet data node configuration.            Parameters:              id (str): The unique identifier of the new Parquet data node configuration.              default_path (Optional[str]): The default path of the Parquet file.              engine (Optional[str]): Parquet library to use. Possible values are *\"fastparquet\"* or                  *\"pyarrow\"*.<br/>                  The default value is *\"pyarrow\"*.              compression (Optional[str]): Name of the compression to use. Possible values are *\"snappy\"*,                  *\"gzip\"*, *\"brotli\"*, or *\"none\"* (no compression). The default value is *\"snappy\"*.              read_kwargs (Optional[dict]): Additional parameters passed to the `pandas.read_parquet()`                  function.              write_kwargs (Optional[dict]): Additional parameters passed to the                  `pandas.DataFrame.write_parquet()` function.<br/>                  The parameters in *read_kwargs* and *write_kwargs* have a **higher precedence** than the                  top-level parameters which are also passed to Pandas.              exposed_type (Optional[str]): The exposed type of the data read from Parquet file.<br/>                  The default value is `pandas`.              scope (Optional[Scope^]): The scope of the Parquet data node configuration.<br/>                  The default value is `Scope.SCENARIO`.              validity_period (Optional[timedelta]): The duration 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 configs page](../core/config/task-config.md) for more details).                  If *validity_period* is set to None, the data node is always up-to-date.              **properties (dict[str, any]): A keyworded variable length list of additional arguments.            Returns:              The new Parquet data node configuration.          \"\"\"          if default_path is not None:              properties[cls._OPTIONAL_DEFAULT_PATH_PARQUET_PROPERTY] = default_path          if engine is not None:              properties[cls._OPTIONAL_ENGINE_PARQUET_PROPERTY] = engine          if compression is not None:              properties[cls._OPTIONAL_COMPRESSION_PARQUET_PROPERTY] = compression          if read_kwargs is not None:              properties[cls._OPTIONAL_READ_KWARGS_PARQUET_PROPERTY] = read_kwargs          if write_kwargs is not None:              properties[cls._OPTIONAL_WRITE_KWARGS_PARQUET_PROPERTY] = write_kwargs          if exposed_type is not None:              properties[cls._OPTIONAL_EXPOSED_TYPE_PARQUET_PROPERTY] = exposed_type            return cls.__configure(id, DataNodeConfig._STORAGE_TYPE_VALUE_PARQUET, scope, validity_period, **properties)        @classmethod      def _configure_excel(          cls,          id: str,          default_path: Optional[str] = None,          has_header: Optional[bool] = None,          sheet_name: Optional[Union[List[str], str]] = None,          exposed_type: Optional[str] = None,          scope: Optional[Scope] = None,          validity_period: Optional[timedelta] = None,          **properties,      ) -> \"DataNodeConfig\":          \"\"\"Configure a new Excel data node configuration.            Parameters:              id (str): The unique identifier of the new Excel data node configuration.              default_path (Optional[str]): The path of the Excel file.              has_header (Optional[bool]): If True, indicates that the Excel file has a header.              sheet_name (Optional[Union[List[str], str]]): The list of sheet names to be used.                  This can be a unique name.              exposed_type (Optional[str]): The exposed type of the data read from Excel file.<br/>                  The default value is `pandas`.              scope (Optional[Scope^]): The scope of the Excel data node configuration.<br/>                  The default value is `Scope.SCENARIO`.              validity_period (Optional[timedelta]): The duration 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 configs page](../core/config/task-config.md) for more details).                  If *validity_period* is set to None, the data node is always up-to-date.              **properties (dict[str, any]): A keyworded variable length list of additional arguments.            Returns:              The new Excel data node configuration.          \"\"\"          if default_path is not None:              properties[cls._OPTIONAL_DEFAULT_PATH_EXCEL_PROPERTY] = default_path          if has_header is not None:              properties[cls._OPTIONAL_HAS_HEADER_EXCEL_PROPERTY] = has_header          if sheet_name is not None:              properties[cls._OPTIONAL_SHEET_NAME_EXCEL_PROPERTY] = sheet_name          if exposed_type is not None:              properties[cls._OPTIONAL_EXPOSED_TYPE_EXCEL_PROPERTY] = exposed_type            return cls.__configure(id, DataNodeConfig._STORAGE_TYPE_VALUE_EXCEL, scope, validity_period, **properties)        @classmethod      def _configure_generic(          cls,          id: str,          read_fct: Optional[Callable] = None,          write_fct: Optional[Callable] = None,          read_fct_args: Optional[List] = None,          write_fct_args: Optional[List] = None,          scope: Optional[Scope] = None,          validity_period: Optional[timedelta] = None,          **properties,      ) -> \"DataNodeConfig\":          \"\"\"Configure a new generic data node configuration.            Parameters:              id (str): The unique identifier of the new generic data node configuration.              read_fct (Optional[Callable]): The Python function called to read the data.              write_fct (Optional[Callable]): The Python function called to write the data.                  The provided function must have at least one parameter that receives the data to be written.              read_fct_args (Optional[List]): The list of arguments that are passed to the function                  *read_fct* to read data.              write_fct_args (Optional[List]): The list of arguments that are passed to the function                  *write_fct* to write the data.              scope (Optional[Scope^]): The scope of the Generic data node configuration.<br/>                  The default value is `Scope.SCENARIO`.              validity_period (Optional[timedelta]): The duration 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 configs page](../core/config/task-config.md) for more details).                  If *validity_period* is set to None, the data node is always up-to-date.              **properties (dict[str, any]): A keyworded variable length list of additional arguments.          Returns:              The new Generic data node configuration.          \"\"\"          if read_fct is not None:              properties[cls._OPTIONAL_READ_FUNCTION_GENERIC_PROPERTY] = read_fct          if write_fct is not None:              properties[cls._OPTIONAL_WRITE_FUNCTION_GENERIC_PROPERTY] = write_fct          if read_fct_args is not None:              properties[cls._OPTIONAL_READ_FUNCTION_ARGS_GENERIC_PROPERTY] = read_fct_args          if write_fct_args is not None:              properties[cls._OPTIONAL_WRITE_FUNCTION_ARGS_GENERIC_PROPERTY] = write_fct_args            return cls.__configure(id, DataNodeConfig._STORAGE_TYPE_VALUE_GENERIC, scope, validity_period, **properties)        @classmethod      def _configure_in_memory(          cls,          id: str,          default_data: Optional[Any] = None,          scope: Optional[Scope] = None,          validity_period: Optional[timedelta] = None,          **properties,      ) -> \"DataNodeConfig\":          \"\"\"Configure a new *in-memory* data node configuration.            Parameters:              id (str): The unique identifier of the new in_memory data node configuration.              default_data (Optional[any]): The default data of the data nodes instantiated from                  this in_memory data node configuration.              scope (Optional[Scope^]): The scope of the in_memory data node configuration.<br/>                  The default value is `Scope.SCENARIO`.              validity_period (Optional[timedelta]): The duration 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 configs page](../core/config/task-config.md) for more details).                  If *validity_period* is set to None, the data node is always up-to-date.              **properties (dict[str, any]): A keyworded variable length list of additional arguments.            Returns:              The new *in-memory* data node configuration.          \"\"\"          if default_data is not None:              properties[cls._OPTIONAL_DEFAULT_DATA_IN_MEMORY_PROPERTY] = default_data            return cls.__configure(id, DataNodeConfig._STORAGE_TYPE_VALUE_IN_MEMORY, scope, validity_period, **properties)        @classmethod      def _configure_pickle(          cls,          id: str,          default_path: Optional[str] = None,          default_data: Optional[Any] = None,          scope: Optional[Scope] = None,          validity_period: Optional[timedelta] = None,          **properties,      ) -> \"DataNodeConfig\":          \"\"\"Configure a new pickle data node configuration.            Parameters:              id (str): The unique identifier of the new pickle data node configuration.              default_path (Optional[str]): The path of the pickle file.              default_data (Optional[any]): The default data of the data nodes instantiated from                  this pickle data node configuration.              scope (Optional[Scope^]): The scope of the pickle data node configuration.<br/>                  The default value is `Scope.SCENARIO`.              validity_period (Optional[timedelta]): The duration 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 configs page](../core/config/task-config.md) for more details).                  If *validity_period* is set to None, the data node is always up-to-date.              **properties (dict[str, any]): A keyworded variable length list of additional arguments.            Returns:              The new pickle data node configuration.          \"\"\"          if default_path is not None:              properties[cls._OPTIONAL_DEFAULT_PATH_PICKLE_PROPERTY] = default_path          if default_data is not None:              properties[cls._OPTIONAL_DEFAULT_DATA_PICKLE_PROPERTY] = default_data            return cls.__configure(id, DataNodeConfig._STORAGE_TYPE_VALUE_PICKLE, scope, validity_period, **properties)        @classmethod      def _configure_sql_table(          cls,          id: str,          db_name: str,          db_engine: str,          table_name: str,          db_username: Optional[str] = None,          db_password: Optional[str] = None,          db_host: Optional[str] = None,          db_port: Optional[int] = None,          db_driver: Optional[str] = None,          sqlite_folder_path: Optional[str] = None,          sqlite_file_extension: Optional[str] = None,          db_extra_args: Optional[Dict[str, Any]] = None,          exposed_type: Optional[str] = None,          scope: Optional[Scope] = None,          validity_period: Optional[timedelta] = None,          **properties,      ) -> \"DataNodeConfig\":          \"\"\"Configure a new SQL table data node configuration.            Parameters:              id (str): The unique identifier of the new SQL data node configuration.              db_name (str): The database name, or the name of the SQLite database file.              db_engine (str): The database engine. Possible values are *\"sqlite\"*, *\"mssql\"*, *\"mysql\"*,                  or *\"postgresql\"*.              table_name (str): The name of the SQL table.              db_username (Optional[str]): The database username. Required by the *\"mssql\"*, *\"mysql\"*, and                  *\"postgresql\"* engines.              db_password (Optional[str]): The database password. Required by the *\"mssql\"*, *\"mysql\"*, and                  *\"postgresql\"* engines.              db_host (Optional[str]): The database host.<br/>                  The default value is \"localhost\".              db_port (Optional[int]): The database port.<br/>                  The default value is 1433.              db_driver (Optional[str]): The database driver.              sqlite_folder_path (Optional[str]): The path to the folder that contains SQLite file.<br/>                  The default value is the current working folder.              sqlite_file_extension (Optional[str]): The file extension of the SQLite file.<br/>                  The default value is \".db\".              db_extra_args (Optional[dict[str, any]]): A dictionary of additional arguments to be passed                  into database connection string.              exposed_type (Optional[str]): The exposed type of the data read from SQL table.<br/>                  The default value is \"pandas\".              scope (Optional[Scope^]): The scope of the SQL data node configuration.<br/>                  The default value is `Scope.SCENARIO`.              validity_period (Optional[timedelta]): The duration 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 configs page](../core/config/task-config.md) for more details).                  If *validity_period* is set to None, the data node is always up-to-date.              **properties (dict[str, any]): A keyworded variable length list of additional arguments.            Returns:              The new SQL data node configuration.          \"\"\"          properties.update(              {                  cls._REQUIRED_DB_NAME_SQL_PROPERTY: db_name,                  cls._REQUIRED_DB_ENGINE_SQL_PROPERTY: db_engine,                  cls._REQUIRED_TABLE_NAME_SQL_TABLE_PROPERTY: table_name,              }          )            if db_username is not None:              properties[cls._OPTIONAL_DB_USERNAME_SQL_PROPERTY] = db_username          if db_password is not None:              properties[cls._OPTIONAL_DB_PASSWORD_SQL_PROPERTY] = db_password          if db_host is not None:              properties[cls._OPTIONAL_HOST_SQL_PROPERTY] = db_host          if db_port is not None:              properties[cls._OPTIONAL_PORT_SQL_PROPERTY] = db_port          if db_driver is not None:              properties[cls._OPTIONAL_DRIVER_SQL_PROPERTY] = db_driver          if sqlite_folder_path is not None:              properties[cls._OPTIONAL_FOLDER_PATH_SQLITE_PROPERTY] = sqlite_folder_path          if sqlite_file_extension is not None:              properties[cls._OPTIONAL_FILE_EXTENSION_SQLITE_PROPERTY] = sqlite_file_extension          if db_extra_args is not None:              properties[cls._OPTIONAL_DB_EXTRA_ARGS_SQL_PROPERTY] = db_extra_args          if exposed_type is not None:              properties[cls._OPTIONAL_EXPOSED_TYPE_SQL_PROPERTY] = exposed_type            return cls.__configure(id, DataNodeConfig._STORAGE_TYPE_VALUE_SQL_TABLE, scope, validity_period, **properties)        @classmethod      def _configure_sql(          cls,          id: str,          db_name: str,          db_engine: str,          read_query: str,          write_query_builder: Callable,          append_query_builder: Optional[Callable] = None,          db_username: Optional[str] = None,          db_password: Optional[str] = None,          db_host: Optional[str] = None,          db_port: Optional[int] = None,          db_driver: Optional[str] = None,          sqlite_folder_path: Optional[str] = None,          sqlite_file_extension: Optional[str] = None,          db_extra_args: Optional[Dict[str, Any]] = None,          exposed_type: Optional[str] = None,          scope: Optional[Scope] = None,          validity_period: Optional[timedelta] = None,          **properties,      ) -> \"DataNodeConfig\":          \"\"\"Configure a new SQL data node configuration.            Parameters:              id (str): The unique identifier of the new SQL data node configuration.              db_name (str): The database name, or the name of the SQLite database file.              db_engine (str): The database engine. Possible values are *\"sqlite\"*, *\"mssql\"*, *\"mysql\"*,                  or *\"postgresql\"*.              read_query (str): The SQL query string used to read the data from the database.              write_query_builder (Callable): A callback function that takes the data as an input parameter                  and returns a list of SQL queries to be executed when writing data to the data node.              append_query_builder (Optional[Callable]): A callback function that takes the data as an input parameter                  and returns a list of SQL queries to be executed when appending data to the data node.              db_username (Optional[str]): The database username. Required by the *\"mssql\"*, *\"mysql\"*, and                  *\"postgresql\"* engines.              db_password (Optional[str]): The database password. Required by the *\"mssql\"*, *\"mysql\"*, and                  *\"postgresql\"* engines.              db_host (Optional[str]): The database host.<br/>                  The default value is \"localhost\".              db_port (Optional[int]): The database port.<br/>                  The default value is 1433.              db_driver (Optional[str]): The database driver.              sqlite_folder_path (Optional[str]): The path to the folder that contains SQLite file.<br/>                  The default value is the current working folder.              sqlite_file_extension (Optional[str]): The file extension of the SQLite file.<br/>                  The default value is \".db\".              db_extra_args (Optional[dict[str, any]]): A dictionary of additional arguments to be passed                  into database connection string.              exposed_type (Optional[str]): The exposed type of the data read from SQL query.<br/>                  The default value is \"pandas\".              scope (Optional[Scope^]): The scope of the SQL data node configuration.<br/>                  The default value is `Scope.SCENARIO`.              validity_period (Optional[timedelta]): The duration 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 configs page](../core/config/task-config.md) for more details).                  If *validity_period* is set to None, the data node is always up-to-date.              **properties (dict[str, any]): A keyworded variable length list of additional arguments.          Returns:              The new SQL data node configuration.          \"\"\"          properties.update(              {                  cls._REQUIRED_DB_NAME_SQL_PROPERTY: db_name,                  cls._REQUIRED_DB_ENGINE_SQL_PROPERTY: db_engine,                  cls._REQUIRED_READ_QUERY_SQL_PROPERTY: read_query,                  cls._REQUIRED_WRITE_QUERY_BUILDER_SQL_PROPERTY: write_query_builder,              }          )            if append_query_builder is not None:              properties[cls._OPTIONAL_APPEND_QUERY_BUILDER_SQL_PROPERTY] = append_query_builder          if db_username is not None:              properties[cls._OPTIONAL_DB_USERNAME_SQL_PROPERTY] = db_username          if db_password is not None:              properties[cls._OPTIONAL_DB_PASSWORD_SQL_PROPERTY] = db_password          if db_host is not None:              properties[cls._OPTIONAL_HOST_SQL_PROPERTY] = db_host          if db_port is not None:              properties[cls._OPTIONAL_PORT_SQL_PROPERTY] = db_port          if db_driver is not None:              properties[cls._OPTIONAL_DRIVER_SQL_PROPERTY] = db_driver          if sqlite_folder_path is not None:              properties[cls._OPTIONAL_FOLDER_PATH_SQLITE_PROPERTY] = sqlite_folder_path          if sqlite_file_extension is not None:              properties[cls._OPTIONAL_FILE_EXTENSION_SQLITE_PROPERTY] = sqlite_file_extension          if db_extra_args is not None:              properties[cls._OPTIONAL_DB_EXTRA_ARGS_SQL_PROPERTY] = db_extra_args          if exposed_type is not None:              properties[cls._OPTIONAL_EXPOSED_TYPE_SQL_PROPERTY] = exposed_type            return cls.__configure(id, DataNodeConfig._STORAGE_TYPE_VALUE_SQL, scope, validity_period, **properties)        @classmethod      def _configure_mongo_collection(          cls,          id: str,          db_name: str,          collection_name: str,          custom_document: Optional[Any] = None,          db_username: Optional[str] = None,          db_password: Optional[str] = None,          db_host: Optional[str] = None,          db_port: Optional[int] = None,          db_driver: Optional[str] = None,          db_extra_args: Optional[Dict[str, Any]] = None,          scope: Optional[Scope] = None,          validity_period: Optional[timedelta] = None,          **properties,      ) -> \"DataNodeConfig\":          \"\"\"Configure a new Mongo collection data node configuration.            Parameters:              id (str): The unique identifier of the new Mongo collection data node configuration.              db_name (str): The database name.              collection_name (str): The collection in the database to read from and to write the data to.              custom_document (Optional[any]): The custom document class to store, encode, and decode data                  when reading and writing to a Mongo collection. The custom_document can have an optional                  *decode()* method to decode data in the Mongo collection to a custom object, and an                  optional *encode()*) method to encode the object's properties to the Mongo collection                  when writing.              db_username (Optional[str]): The database username.              db_password (Optional[str]): The database password.              db_host (Optional[str]): The database host.<br/>                  The default value is \"localhost\".              db_port (Optional[int]): The database port.<br/>                  The default value is 27017.              db_driver (Optional[str]): The database driver.              db_extra_args (Optional[dict[str, any]]): A dictionary of additional arguments to be passed                  into database connection string.              scope (Optional[Scope^]): The scope of the Mongo collection data node configuration.<br/>                  The default value is `Scope.SCENARIO`.              validity_period (Optional[timedelta]): The duration 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 configs page](../core/config/task-config.md) for more details).                  If *validity_period* is set to None, the data node is always up-to-date.              **properties (dict[str, any]): A keyworded variable length list of additional arguments.            Returns:              The new Mongo collection data node configuration.          \"\"\"          properties.update(              {                  cls._REQUIRED_DB_NAME_MONGO_PROPERTY: db_name,                  cls._REQUIRED_COLLECTION_NAME_MONGO_PROPERTY: collection_name,              }          )            if custom_document is not None:              properties[cls._OPTIONAL_CUSTOM_DOCUMENT_MONGO_PROPERTY] = custom_document          if db_username is not None:              properties[cls._OPTIONAL_USERNAME_MONGO_PROPERTY] = db_username          if db_password is not None:              properties[cls._OPTIONAL_PASSWORD_MONGO_PROPERTY] = db_password          if db_host is not None:              properties[cls._OPTIONAL_HOST_MONGO_PROPERTY] = db_host          if db_port is not None:              properties[cls._OPTIONAL_PORT_MONGO_PROPERTY] = db_port          if db_driver is not None:              properties[cls._OPTIONAL_DRIVER_MONGO_PROPERTY] = db_driver          if db_extra_args is not None:              properties[cls._OPTIONAL_DB_EXTRA_ARGS_MONGO_PROPERTY] = db_extra_args            return cls.__configure(              id, DataNodeConfig._STORAGE_TYPE_VALUE_MONGO_COLLECTION, scope, validity_period, **properties          )        @staticmethod      def __configure(          id: str,          storage_type: Optional[str] = None,          scope: Optional[Scope] = None,          validity_period: Optional[timedelta] = None,          **properties,      ):          section = DataNodeConfig(id, storage_type, scope, validity_period, **properties)          Config._register(section)          return Config.sections[DataNodeConfig.name][id] "}
{"text": "from copy import copy  from typing import Any, Dict, List, 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 ..common._warnings import _warn_deprecated  from .data_node_config import DataNodeConfig      class TaskConfig(Section):      \"\"\"      Configuration fields needed to instantiate an actual `Task^`.        Attributes:          id (str): Identifier of the task config. Must be a valid Python variable name.          inputs (Union[DataNodeConfig^, List[DataNodeConfig^]]): The optional list of              `DataNodeConfig^` inputs.<br/>              The default value is [].          outputs (Union[DataNodeConfig^, List[DataNodeConfig^]]): The optional list of              `DataNodeConfig^` outputs.<br/>              The default value is [].          skippable (bool): If True, indicates that the task can be skipped if no change has              been made on inputs.<br/>              The default value is False.          function (Callable): User function taking as inputs some parameters compatible with the              exposed types (*exposed_type* field) of the input data nodes and returning results              compatible with the exposed types (*exposed_type* field) of the outputs list.<br/>              The default value is None.          **properties (dict[str, any]): A dictionary of additional properties.      \"\"\"        name = \"TASK\"        _INPUT_KEY = \"inputs\"      _FUNCTION = \"function\"      _OUTPUT_KEY = \"outputs\"      _IS_SKIPPABLE_KEY = \"skippable\"        def __init__(          self,          id: str,          function,          inputs: Optional[Union[DataNodeConfig, List[DataNodeConfig]]] = None,          outputs: Optional[Union[DataNodeConfig, List[DataNodeConfig]]] = None,          skippable: Optional[bool] = False,          **properties,      ):          if inputs:              self._inputs = [inputs] if isinstance(inputs, DataNodeConfig) else copy(inputs)          else:              self._inputs = []          if outputs:              self._outputs = [outputs] if isinstance(outputs, DataNodeConfig) else copy(outputs)              outputs_all_cacheable = all(output.cacheable for output in self._outputs)              if not skippable and outputs_all_cacheable:                  _warn_deprecated(\"cacheable\", suggest=\"the skippable feature\")                  skippable = True          else:              self._outputs = []          self._skippable = skippable          self.function = function          super().__init__(id, **properties)        def __copy__(self):          return TaskConfig(              self.id, self.function, copy(self._inputs), copy(self._outputs), self.skippable, **copy(self._properties)          )        def __getattr__(self, item: str) -> Optional[Any]:          return _tpl._replace_templates(self._properties.get(item))        @property      def input_configs(self) -> List[DataNodeConfig]:          return list(self._inputs)        @property      def inputs(self) -> List[DataNodeConfig]:          return list(self._inputs)        @property      def output_configs(self) -> List[DataNodeConfig]:          return list(self._outputs)        @property      def outputs(self) -> List[DataNodeConfig]:          return list(self._outputs)        @property      def skippable(self):          return _tpl._replace_templates(self._skippable)        @classmethod      def default_config(cls):          return TaskConfig(cls._DEFAULT_KEY, None, [], [], False)        def _clean(self):          self.function = None          self._inputs = []          self._outputs = []          self._skippable = False          self._properties.clear()        def _to_dict(self):          return {              self._FUNCTION: self.function,              self._INPUT_KEY: self._inputs,              self._OUTPUT_KEY: self._outputs,              self._IS_SKIPPABLE_KEY: self._skippable,              **self._properties,          }        @classmethod      def _from_dict(cls, as_dict: Dict[str, Any], id: str, config: Optional[_Config]):          as_dict.pop(cls._ID_KEY, id)          funct = as_dict.pop(cls._FUNCTION, None)          dn_configs = config._sections.get(DataNodeConfig.name, None) or []  # type: ignore          inputs = []          if inputs_as_str := as_dict.pop(cls._INPUT_KEY, None):              inputs = [dn_configs[dn_id] for dn_id in inputs_as_str if dn_id in dn_configs]          outputs = []          if outputs_as_str := as_dict.pop(cls._OUTPUT_KEY, None):              outputs = [dn_configs[ds_id] for ds_id in outputs_as_str if ds_id in dn_configs]          skippable = as_dict.pop(cls._IS_SKIPPABLE_KEY, False)          return TaskConfig(id=id, function=funct, inputs=inputs, outputs=outputs, skippable=skippable, **as_dict)        def _update(self, as_dict, default_section=None):          function = as_dict.pop(self._FUNCTION, None)          if function is not None and type(function) is not str:              self.function = function          self._inputs = as_dict.pop(self._INPUT_KEY, self._inputs)          if self._inputs is None and default_section:              self._inputs = default_section._inputs          self._outputs = as_dict.pop(self._OUTPUT_KEY, self._outputs)          if self._outputs is None and default_section:              self._outputs = default_section._outputs          self._skippable = as_dict.pop(self._IS_SKIPPABLE_KEY, self._skippable)          self._properties.update(as_dict)          if default_section:              self._properties = {**default_section.properties, **self._properties}        @staticmethod      def _configure(          id: str,          function,          input: Optional[Union[DataNodeConfig, List[DataNodeConfig]]] = None,          output: Optional[Union[DataNodeConfig, List[DataNodeConfig]]] = None,          skippable: Optional[bool] = False,          **properties,      ) -> \"TaskConfig\":          \"\"\"Configure a new task configuration.            Parameters:              id (str): The unique identifier of this task configuration.              function (Callable): The python function called by Taipy to run the task.              input (Optional[Union[DataNodeConfig^, List[DataNodeConfig^]]]): The list of the                  function input data node configurations. This can be a unique data node                  configuration if there is a single input data node, or None if there are none.              output (Optional[Union[DataNodeConfig^, List[DataNodeConfig^]]]): The list of the                  function output data node configurations. This can be a unique data node                  configuration if there is a single output data node, or None if there are none.              skippable (bool): If True, indicates that the task can be skipped if no change has                  been made on inputs.<br/>                  The default value is False.              **properties (dict[str, any]): A keyworded variable length list of additional arguments.            Returns:              The new task configuration.          \"\"\"          section = TaskConfig(id, function, input, output, skippable, **properties)          Config._register(section)          return Config.sections[TaskConfig.name][id]        @staticmethod      def _set_default_configuration(          function,          input: Optional[Union[DataNodeConfig, List[DataNodeConfig]]] = None,          output: Optional[Union[DataNodeConfig, List[DataNodeConfig]]] = None,          skippable: Optional[bool] = False,          **properties,      ) -> \"TaskConfig\":          \"\"\"Set the default values for task configurations.            This function creates the *default task configuration* object,          where all task configuration objects will find their default          values when needed.            Parameters:              function (Callable): The python function called by Taipy to run the task.              input (Optional[Union[DataNodeConfig^, List[DataNodeConfig^]]]): The list of the                  input data node configurations. This can be a unique data node                  configuration if there is a single input data node, or None if there are none.              output (Optional[Union[DataNodeConfig^, List[DataNodeConfig^]]]): The list of the                  output data node configurations. This can be a unique data node                  configuration if there is a single output data node, or None if there are none.              skippable (bool): If True, indicates that the task can be skipped if no change has                  been made on inputs.<br/>                  The default value is False.              **properties (dict[str, any]): A keyworded variable length list of additional                  arguments.          Returns:              The default task configuration.          \"\"\"          section = TaskConfig(_Config.DEFAULT_KEY, function, input, output, skippable, **properties)          Config._register(section)          return Config.sections[TaskConfig.name][_Config.DEFAULT_KEY] "}
{"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 import Config  from taipy.config._config import _Config  from taipy.config.checker._checkers._config_checker import _ConfigChecker  from taipy.config.checker.issue_collector import IssueCollector  from taipy.config.common.frequency import Frequency    from ..data_node_config import DataNodeConfig  from ..scenario_config import ScenarioConfig  from ..task_config import TaskConfig      class _ScenarioConfigChecker(_ConfigChecker):      def __init__(self, config: _Config, collector: IssueCollector):          super().__init__(config, collector)        def _check(self) -> IssueCollector:          scenario_configs = self._config._sections[ScenarioConfig.name]          for scenario_config_id, scenario_config in scenario_configs.items():              if scenario_config_id != _Config.DEFAULT_KEY:                  self._check_if_entity_property_key_used_is_predefined(scenario_config)                  self._check_existing_config_id(scenario_config)                  self._check_frequency(scenario_config_id, scenario_config)                  self._check_task_configs(scenario_config_id, scenario_config)                  self._check_addition_data_node_configs(scenario_config_id, scenario_config)                  self._check_additional_dns_not_overlapping_tasks_dns(scenario_config_id, scenario_config)                  self._check_tasks_in_sequences_exist_in_scenario_tasks(scenario_config_id, scenario_config)                  self._check_comparators(scenario_config_id, scenario_config)            return self._collector        def _check_task_configs(self, scenario_config_id: str, scenario_config: ScenarioConfig):          self._check_children(              ScenarioConfig,              scenario_config_id,              scenario_config._TASKS_KEY,              scenario_config.tasks,              TaskConfig,          )        def _check_addition_data_node_configs(self, scenario_config_id: str, scenario_config: ScenarioConfig):          self._check_children(              ScenarioConfig,              scenario_config_id,              scenario_config._ADDITIONAL_DATA_NODES_KEY,              scenario_config.additional_data_nodes,              DataNodeConfig,              can_be_empty=True,          )        def _check_frequency(self, scenario_config_id: str, scenario_config: ScenarioConfig):          if scenario_config.frequency and not isinstance(scenario_config.frequency, Frequency):              self._error(                  scenario_config._FREQUENCY_KEY,                  scenario_config.frequency,                  f\"{scenario_config._FREQUENCY_KEY} field of ScenarioConfig `{scenario_config_id}` must be\"                  f\" populated with a Frequency value.\",              )        def _check_comparators(self, scenario_config_id: str, scenario_config: ScenarioConfig):          if scenario_config.comparators is not None and not isinstance(scenario_config.comparators, dict):              self._error(                  ScenarioConfig._COMPARATOR_KEY,                  scenario_config.comparators,                  f\"{ScenarioConfig._COMPARATOR_KEY} field of ScenarioConfig\"                  f\" `{scenario_config_id}` must be populated with a dictionary value.\",              )          else:              for data_node_id, comparator in scenario_config.comparators.items():                  if data_node_id not in Config.data_nodes:                      self._error(                          ScenarioConfig._COMPARATOR_KEY,                          scenario_config.comparators,                          f\"The key `{data_node_id}` in {ScenarioConfig._COMPARATOR_KEY} field of ScenarioConfig\"                          f\" `{scenario_config_id}` must be populated with a valid data node configuration id.\",                      )                  if not callable(comparator):                      if not isinstance(comparator, list) or not all(callable(comp) for comp in comparator):                          self._error(                              ScenarioConfig._COMPARATOR_KEY,                              scenario_config.comparators,                              f\"The value of `{data_node_id}` in {ScenarioConfig._COMPARATOR_KEY} field of ScenarioConfig\"                              f\" `{scenario_config_id}` must be populated with a list of Callable values.\",                          )        def _check_additional_dns_not_overlapping_tasks_dns(self, scenario_config_id: str, scenario_config: ScenarioConfig):          data_node_configs = set()          for task_config in scenario_config.task_configs:              if isinstance(task_config, TaskConfig):                  input_dn_configs = task_config.input_configs if task_config.input_configs else []                  output_dn_configs = task_config.output_configs if task_config.output_configs else []                  data_node_configs.update({*input_dn_configs, *output_dn_configs})            for additional_data_node_config in scenario_config.additional_data_node_configs:              if additional_data_node_config in data_node_configs:                  self._warning(                      ScenarioConfig._ADDITIONAL_DATA_NODES_KEY,                      scenario_config.additional_data_node_configs,                      f\"The additional data node `{additional_data_node_config.id}` in\"                      f\" {ScenarioConfig._ADDITIONAL_DATA_NODES_KEY} field of ScenarioConfig\"                      f\" `{scenario_config_id}` has already existed as an input or output data node of\"                      f\" ScenarioConfig `{scenario_config_id}` tasks.\",                  )        def _check_tasks_in_sequences_exist_in_scenario_tasks(          self, scenario_config_id: str, scenario_config: ScenarioConfig      ):          scenario_task_ids = set()          for task_config in scenario_config.tasks:              if isinstance(task_config, TaskConfig):                  scenario_task_ids.add(task_config.id)          for sequence_tasks in scenario_config.sequences.values():              self._check_children(                  ScenarioConfig,                  scenario_config_id,                  scenario_config._SEQUENCES_KEY,                  sequence_tasks,                  TaskConfig,                  can_be_empty=True,              )              for task in sequence_tasks:                  if isinstance(task, TaskConfig) and task.id not in scenario_task_ids:                      self._error(                          ScenarioConfig._SEQUENCES_KEY,                          scenario_config.sequences,                          f\"The task `{task.id}` in {ScenarioConfig._SEQUENCES_KEY} field of ScenarioConfig\"                          f\" `{scenario_config_id}` must exist in {ScenarioConfig._TASKS_KEY} field of ScenarioConfig\"                          f\" `{scenario_config_id}`.\",                      ) "}
{"text": "from datetime import timedelta  from typing import Dict    from taipy.config._config import _Config  from taipy.config.checker._checker import _ConfigChecker  from taipy.config.checker.issue_collector import IssueCollector  from taipy.config.common.scope import Scope    from ..data_node_config import DataNodeConfig      class _DataNodeConfigChecker(_ConfigChecker):      def __init__(self, config: _Config, collector: IssueCollector):          super().__init__(config, collector)        def _check(self) -> IssueCollector:          data_node_configs: Dict[str, DataNodeConfig] = self._config._sections[DataNodeConfig.name]          for data_node_config_id, data_node_config in data_node_configs.items():              self._check_existing_config_id(data_node_config)              self._check_if_entity_property_key_used_is_predefined(data_node_config)              self._check_storage_type(data_node_config_id, data_node_config)              self._check_scope(data_node_config_id, data_node_config)              self._check_validity_period(data_node_config_id, data_node_config)              self._check_required_properties(data_node_config_id, data_node_config)              self._check_callable(data_node_config_id, data_node_config)              self._check_generic_read_write_fct_and_args(data_node_config_id, data_node_config)              self._check_exposed_type(data_node_config_id, data_node_config)          return self._collector        def _check_storage_type(self, data_node_config_id: str, data_node_config: DataNodeConfig):          if data_node_config.storage_type not in DataNodeConfig._ALL_STORAGE_TYPES:              self._error(                  data_node_config._STORAGE_TYPE_KEY,                  data_node_config.storage_type,                  f\"`{data_node_config._STORAGE_TYPE_KEY}` field of DataNodeConfig `{data_node_config_id}` must be\"                  f\" either csv, sql_table, sql, mongo_collection, pickle, excel, generic, json, parquet, or in_memory.\",              )        def _check_scope(self, data_node_config_id: str, data_node_config: DataNodeConfig):          if not isinstance(data_node_config.scope, Scope):              self._error(                  data_node_config._SCOPE_KEY,                  data_node_config.scope,                  f\"`{data_node_config._SCOPE_KEY}` field of DataNodeConfig `{data_node_config_id}` must be\"                  f\" populated with a Scope value.\",              )        def _check_validity_period(self, data_node_config_id: str, data_node_config: DataNodeConfig):          if data_node_config.validity_period and not isinstance(data_node_config.validity_period, timedelta):              self._error(                  data_node_config._VALIDITY_PERIOD_KEY,                  data_node_config.validity_period,                  f\"`{data_node_config._VALIDITY_PERIOD_KEY}` field of DataNodeConfig `{data_node_config_id}` must be\"                  f\" None or populated with a timedelta value.\",              )        def _check_required_properties(self, data_node_config_id: str, data_node_config: DataNodeConfig):          if storage_type := data_node_config.storage_type:              if storage_type in DataNodeConfig._REQUIRED_PROPERTIES:                  required_properties = DataNodeConfig._REQUIRED_PROPERTIES[storage_type]                  if storage_type == DataNodeConfig._STORAGE_TYPE_VALUE_SQL:                      if data_node_config.properties:                          if engine := data_node_config.properties.get(DataNodeConfig._REQUIRED_DB_ENGINE_SQL_PROPERTY):                              if engine == DataNodeConfig._DB_ENGINE_SQLITE:                                  required_properties = [                                      DataNodeConfig._REQUIRED_DB_NAME_SQL_PROPERTY,                                      DataNodeConfig._REQUIRED_DB_ENGINE_SQL_PROPERTY,                                      DataNodeConfig._REQUIRED_READ_QUERY_SQL_PROPERTY,                                      DataNodeConfig._REQUIRED_WRITE_QUERY_BUILDER_SQL_PROPERTY,                                  ]                              else:                                  required_properties = [                                      DataNodeConfig._OPTIONAL_DB_USERNAME_SQL_PROPERTY,                                      DataNodeConfig._OPTIONAL_DB_PASSWORD_SQL_PROPERTY,                                      DataNodeConfig._REQUIRED_DB_NAME_SQL_PROPERTY,                                      DataNodeConfig._REQUIRED_DB_ENGINE_SQL_PROPERTY,                                      DataNodeConfig._REQUIRED_READ_QUERY_SQL_PROPERTY,                                      DataNodeConfig._REQUIRED_WRITE_QUERY_BUILDER_SQL_PROPERTY,                                  ]                  if storage_type == DataNodeConfig._STORAGE_TYPE_VALUE_SQL_TABLE:                      if data_node_config.properties:                          if engine := data_node_config.properties.get(DataNodeConfig._REQUIRED_DB_ENGINE_SQL_PROPERTY):                              if engine == DataNodeConfig._DB_ENGINE_SQLITE:                                  required_properties = [                                      DataNodeConfig._REQUIRED_DB_NAME_SQL_PROPERTY,                                      DataNodeConfig._REQUIRED_DB_ENGINE_SQL_PROPERTY,                                      DataNodeConfig._REQUIRED_TABLE_NAME_SQL_TABLE_PROPERTY,                                  ]                              else:                                  required_properties = [                                      DataNodeConfig._OPTIONAL_DB_USERNAME_SQL_PROPERTY,                                      DataNodeConfig._OPTIONAL_DB_PASSWORD_SQL_PROPERTY,                                      DataNodeConfig._REQUIRED_DB_NAME_SQL_PROPERTY,                                      DataNodeConfig._REQUIRED_DB_ENGINE_SQL_PROPERTY,                                      DataNodeConfig._REQUIRED_TABLE_NAME_SQL_TABLE_PROPERTY,                                  ]                  for required_property in required_properties:                      if not data_node_config.properties or required_property not in data_node_config.properties:                          if data_node_config_id == DataNodeConfig._DEFAULT_KEY:                              self._warning(                                  required_property,                                  None,                                  f\"DataNodeConfig `{data_node_config_id}` is missing the required \"                                  f\"property `{required_property}` for type `{storage_type}`.\",                              )                          else:                              self._error(                                  required_property,                                  None,                                  f\"DataNodeConfig `{data_node_config_id}` is missing the required \"                                  f\"property `{required_property}` for type `{storage_type}`.\",                              )        def _check_generic_read_write_fct_and_args(self, data_node_config_id: str, data_node_config: DataNodeConfig):          if data_node_config.storage_type == DataNodeConfig._STORAGE_TYPE_VALUE_GENERIC:              properties_to_check = [                  DataNodeConfig._OPTIONAL_READ_FUNCTION_ARGS_GENERIC_PROPERTY,                  DataNodeConfig._OPTIONAL_WRITE_FUNCTION_ARGS_GENERIC_PROPERTY,              ]              for prop_key in properties_to_check:                  if data_node_config.properties and prop_key in data_node_config.properties:                      prop_value = data_node_config.properties[prop_key]                      if not isinstance(prop_value, list):                          self._error(                              prop_key,                              prop_value,                              f\"`{prop_key}` field of DataNodeConfig\"                              f\" `{data_node_config_id}` must be populated with a List value.\",                          )              if data_node_config_id != DataNodeConfig._DEFAULT_KEY:                  properties_to_check_at_least_one = [                      DataNodeConfig._OPTIONAL_READ_FUNCTION_GENERIC_PROPERTY,                      DataNodeConfig._OPTIONAL_WRITE_FUNCTION_GENERIC_PROPERTY,                  ]                  has_at_least_one = False                  for prop_key in properties_to_check_at_least_one:                      if data_node_config.properties and prop_key in data_node_config.properties:                          has_at_least_one = True                  if not has_at_least_one:                      self._error(                          \", \".join(properties_to_check_at_least_one),                          None,                          f\"Either `{DataNodeConfig._OPTIONAL_READ_FUNCTION_GENERIC_PROPERTY}` field or \"                          f\"`{DataNodeConfig._OPTIONAL_WRITE_FUNCTION_GENERIC_PROPERTY}` field of \"                          f\"DataNodeConfig `{data_node_config_id}` must be populated with a Callable function.\",                      )        def _check_callable(self, data_node_config_id: str, data_node_config: DataNodeConfig):          properties_to_check = {              DataNodeConfig._STORAGE_TYPE_VALUE_GENERIC: [                  DataNodeConfig._OPTIONAL_READ_FUNCTION_GENERIC_PROPERTY,                  DataNodeConfig._OPTIONAL_WRITE_FUNCTION_GENERIC_PROPERTY,              ],              DataNodeConfig._STORAGE_TYPE_VALUE_SQL: [                  DataNodeConfig._REQUIRED_WRITE_QUERY_BUILDER_SQL_PROPERTY,                  DataNodeConfig._OPTIONAL_APPEND_QUERY_BUILDER_SQL_PROPERTY,              ],          }            if data_node_config.storage_type in properties_to_check.keys():              for prop_key in properties_to_check[data_node_config.storage_type]:                  prop_value = data_node_config.properties.get(prop_key) if data_node_config.properties else None                  if prop_value and not callable(prop_value):                      self._error(                          prop_key,                          prop_value,                          f\"`{prop_key}` of DataNodeConfig `{data_node_config_id}` must be\"                          f\" populated with a Callable function.\",                      )        def _check_exposed_type(self, data_node_config_id: str, data_node_config: DataNodeConfig):          if not isinstance(data_node_config.exposed_type, str):              return          if data_node_config.exposed_type not in DataNodeConfig._ALL_EXPOSED_TYPES:              self._error(                  data_node_config._EXPOSED_TYPE_KEY,                  data_node_config.exposed_type,                  f\"The `{data_node_config._EXPOSED_TYPE_KEY}` of DataNodeConfig `{data_node_config_id}` \"                  f'must be either \"pandas\", \"modin\", \"numpy\", or a custom type.',              ) "}
{"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": "from queue import SimpleQueue  from typing import Any, Dict, Optional, Set, Tuple    from ._registration import _Registration  from ._topic import _Topic  from .event import Event, EventEntityType, EventOperation      def _publish_event(      entity_type: EventEntityType,      operation: EventOperation,      /,      entity_id: Optional[str] = None,      attribute_name: Optional[str] = None,      attribute_value: Optional[Any] = None,      **kwargs,  ):      \"\"\"Internal helper function to send events.        It basically creates an event corresponding to the given arguments      and send it using `Notifier.publish(event)`        Parameters:          entity_type (EventEntityType^)          operation (EventOperation^)          entity_id (Optional[str])          attribute_name (Optional[str])          attribute_value (Optional[Any])          **kwargs      \"\"\"      event = Event(          entity_id=entity_id,          entity_type=entity_type,          operation=operation,          attribute_name=attribute_name,          attribute_value=attribute_value,          metadata=kwargs,      )      Notifier.publish(event)      class Notifier:      \"\"\"A class for managing event registrations and publishing `Core^` service events.\"\"\"        _topics_registrations_list: Dict[_Topic, Set[_Registration]] = {}        @classmethod      def register(          cls,          entity_type: Optional[EventEntityType] = None,          entity_id: Optional[str] = None,          operation: Optional[EventOperation] = None,          attribute_name: Optional[str] = None,      ) -> Tuple[str, SimpleQueue]:          \"\"\"Register a listener for a specific event topic.            The topic is defined by the combination of the entity type, the entity id,          the operation and the attribute name.            Parameters:              entity_type (Optional[EventEntityType^]): If provided, the listener will                  be notified for all events related to this entity type. Otherwise,                  the listener will be notified for events related to all entity types.                  <br>                  The possible entity type values are defined in the `EventEntityType^`                  enum. The possible values are:                  <ul>                      <li>CYCLE</li>                      <li>SCENARIO</li>                      <li>SEQUENCE</li>                      <li>TASK</li>                      <li>DATA_NODE</li>                      <li>JOB</li>                  </ul>              entity_id (Optional[str]): If provided, the listener will be notified                  for all events related to this entity. Otherwise, the listener                  will be notified for events related to all entities.              operation (Optional[EventOperation^]): If provided, the listener will                  be notified for all events related to this operation. Otherwise,                  the listener will be notified for events related to all operations.                  <br>                  The possible operation values are defined in the `EventOperation^`                  enum. The possible values are:                  <ul>                      <li>CREATION</li>                      <li>UPDATE</li>                      <li>DELETION</li>                      <li>SUBMISSION</li>                  </ul>              attribute_name (Optional[str]): If provided, the listener will be notified                  for all events related to this entity's attribute. Otherwise, the listener                  will be notified for events related to all attributes.            Returns:              A tuple containing the registration id and the event queue.          \"\"\"          registration = _Registration(entity_type, entity_id, operation, attribute_name)            if registrations := cls._topics_registrations_list.get(registration.topic, None):              registrations.add(registration)          else:              cls._topics_registrations_list[registration.topic] = {registration}            return registration.registration_id, registration.queue        @classmethod      def unregister(cls, registration_id: str):          \"\"\"Unregister a listener.            Parameters:              registration_id (RegistrationId^): The registration id returned by the `register` method.          \"\"\"          to_remove_registration: Optional[_Registration] = None            for _, registrations in cls._topics_registrations_list.items():              for registration in registrations:                  if registration.registration_id == registration_id:                      to_remove_registration = registration                      break            if to_remove_registration:              registrations = cls._topics_registrations_list[to_remove_registration.topic]              registrations.remove(to_remove_registration)              if len(registrations) == 0:                  del cls._topics_registrations_list[to_remove_registration.topic]        @classmethod      def publish(cls, event):          \"\"\"Publish a `Core^` service event to all registered listeners whose topic matches the event.            Parameters:              event (Event^): The event to publish.          \"\"\"          for topic, registrations in cls._topics_registrations_list.items():              if Notifier._is_matching(event, topic):                  for registration in registrations:                      registration.queue.put(event)        @staticmethod      def _is_matching(event: Event, topic: _Topic) -> bool:          \"\"\"Check if an event matches a topic.\"\"\"          if topic.entity_type is not None and event.entity_type != topic.entity_type:              return False          if topic.entity_id is not None and event.entity_id != topic.entity_id:              return False          if topic.operation is not None and event.operation != topic.operation:              return False          if topic.attribute_name is not None and event.attribute_name and event.attribute_name != topic.attribute_name:              return False          return True "}
{"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": "import re  import uuid  from datetime import datetime  from typing import Any, Dict, Optional    from taipy.config.common.frequency import Frequency    from .._entity._entity import _Entity  from .._entity._labeled import _Labeled  from .._entity._properties import _Properties  from .._entity._reload import _Reloader, _self_reload, _self_setter  from ..exceptions.exceptions import _SuspiciousFileOperation  from ..notification.event import Event, EventEntityType, EventOperation, _make_event  from .cycle_id import CycleId      class Cycle(_Entity, _Labeled):      \"\"\"An iteration of a recurrent work pattern.        Attributes:          id (str): The unique identifier of the cycle.          frequency (Frequency^): The frequency of this cycle.          creation_date (datetime): The date and time of the creation of this cycle.          start_date (datetime): The date and time of the start of this cycle.          end_date (datetime): The date and time of the end of this cycle.          name (str): The name of this cycle.          properties (dict[str, Any]): A dictionary of additional properties.      \"\"\"        _ID_PREFIX = \"CYCLE\"      __SEPARATOR = \"_\"      _MANAGER_NAME = \"cycle\"        def __init__(          self,          frequency: Frequency,          properties: Dict[str, Any],          creation_date: datetime,          start_date: datetime,          end_date: datetime,          name: Optional[str] = None,          id: Optional[CycleId] = None,      ):          self._frequency = frequency          self._creation_date = creation_date          self._start_date = start_date          self._end_date = end_date          self._name = self._new_name(name)          self.id = id or self._new_id(self._name)          self._properties = _Properties(self, **properties)        def _new_name(self, name: Optional[str] = None) -> str:          if name:              return name          if self._frequency == Frequency.DAILY:              # Example \"Monday, 2. January 2023\"              return self._start_date.strftime(\"%A, %d. %B %Y\")          if self._frequency == Frequency.WEEKLY:              # Example \"Week 01 2023, from 2. January\"              return self._start_date.strftime(\"Week %W %Y, from %d. %B\")          if self._frequency == Frequency.MONTHLY:              # Example \"January 2023\"              return self._start_date.strftime(\"%B %Y\")          if self._frequency == Frequency.QUARTERLY:              # Example \"2023 Q1\"              return f\"{self._start_date.strftime('%Y')} Q{(self._start_date.month-1)//3+1}\"          if self._frequency == Frequency.YEARLY:              # Example \"2023\"              return self._start_date.strftime(\"%Y\")          return Cycle.__SEPARATOR.join([str(self._frequency.value), self._start_date.ctime()])        @property  # type: ignore      @_self_reload(_MANAGER_NAME)      def frequency(self):          return self._frequency        @frequency.setter  # type: ignore      @_self_setter(_MANAGER_NAME)      def frequency(self, val):          self._frequency = val        @property  # type: ignore      @_self_reload(_MANAGER_NAME)      def creation_date(self):          return self._creation_date        @creation_date.setter  # type: ignore      @_self_setter(_MANAGER_NAME)      def creation_date(self, val):          self._creation_date = val        @property  # type: ignore      @_self_reload(_MANAGER_NAME)      def start_date(self):          return self._start_date        @start_date.setter  # type: ignore      @_self_setter(_MANAGER_NAME)      def start_date(self, val):          self._start_date = val        @property  # type: ignore      @_self_reload(_MANAGER_NAME)      def end_date(self):          return self._end_date        @end_date.setter  # type: ignore      @_self_setter(_MANAGER_NAME)      def end_date(self, val):          self._end_date = val        @property  # type: ignore      @_self_reload(_MANAGER_NAME)      def name(self):          return self._name        @name.setter  # type: ignore      @_self_setter(_MANAGER_NAME)      def name(self, val):          self._name = val        @property      def properties(self):          self._properties = _Reloader()._reload(self._MANAGER_NAME, self)._properties          return self._properties        @staticmethod      def _new_id(name: str) -> CycleId:          def _get_valid_filename(name: str) -> str:              \"\"\"              Source: https://github.com/django/django/blob/main/django/utils/text.py              \"\"\"              s = str(name).strip().replace(\" \", \"_\")              s = re.sub(r\"(?u)[^-\\w.]\", \"\", s)              if s in {\"\", \".\", \"..\"}:                  raise _SuspiciousFileOperation(\"Could not derive file name from '%s'\" % name)              s = str(s).strip().replace(\" \", \"_\")              return re.sub(r\"(?u)[^-\\w.]\", \"\", s)            return CycleId(_get_valid_filename(Cycle.__SEPARATOR.join([Cycle._ID_PREFIX, name, str(uuid.uuid4())])))        def __getattr__(self, attribute_name):          protected_attribute_name = attribute_name          if protected_attribute_name in self._properties:              return self._properties[protected_attribute_name]          raise AttributeError(f\"{attribute_name} is not an attribute of cycle {self.id}\")        def __eq__(self, other):          return self.id == other.id        def __hash__(self):          return hash(self.id)        def get_label(self) -> str:          \"\"\"Returns the cycle label.            Returns:              The label of the cycle as a string.          \"\"\"          return self._get_label()        def get_simple_label(self) -> str:          \"\"\"Returns the cycle simple label.            Returns:              The simple label of the cycle as a string.          \"\"\"          return self._get_simple_label()      @_make_event.register(Cycle)  def _make_event_for_cycle(      cycle: Cycle,      operation: EventOperation,      /,      attribute_name: Optional[str] = None,      attribute_value: Optional[Any] = None,      **kwargs,  ) -> Event:      metadata = {**kwargs}      return Event(          entity_type=EventEntityType.CYCLE,          entity_id=cycle.id,          operation=operation,          attribute_name=attribute_name,          attribute_value=attribute_value,          metadata=metadata,      ) "}
{"text": "import calendar  from datetime import datetime, time, timedelta  from typing import Callable, Dict, List, Optional    from taipy.config.common.frequency import Frequency    from .._entity._entity_ids import _EntityIds  from .._manager._manager import _Manager  from .._repository._abstract_repository import _AbstractRepository  from ..job._job_manager_factory import _JobManagerFactory  from ..notification import EventEntityType, EventOperation, _publish_event  from ..submission._submission_manager_factory import _SubmissionManagerFactory  from .cycle import Cycle  from .cycle_id import CycleId      class _CycleManager(_Manager[Cycle]):      _ENTITY_NAME = Cycle.__name__      _repository: _AbstractRepository      _EVENT_ENTITY_TYPE = EventEntityType.CYCLE        @classmethod      def _create(          cls, frequency: Frequency, name: Optional[str] = None, creation_date: Optional[datetime] = None, **properties      ):          creation_date = creation_date if creation_date else datetime.now()          start_date = _CycleManager._get_start_date_of_cycle(frequency, creation_date)          end_date = _CycleManager._get_end_date_of_cycle(frequency, start_date)          cycle = Cycle(              frequency, properties, creation_date=creation_date, start_date=start_date, end_date=end_date, name=name          )          cls._set(cycle)          _publish_event(              cls._EVENT_ENTITY_TYPE,              EventOperation.CREATION,              entity_id=cycle.id,          )          return cycle        @classmethod      def _get_or_create(          cls, frequency: Frequency, creation_date: Optional[datetime] = None, name: Optional[str] = None      ) -> Cycle:          creation_date = creation_date if creation_date else datetime.now()          start_date = _CycleManager._get_start_date_of_cycle(frequency, creation_date)          cycles = cls._get_cycles_by_frequency_and_start_date(              frequency=frequency, start_date=start_date, cycles=cls._get_all()          )          if len(cycles) > 0:              return cycles[0]          else:              return cls._create(frequency=frequency, creation_date=creation_date, name=name)        @staticmethod      def _get_start_date_of_cycle(frequency: Frequency, creation_date: datetime):          start_date = creation_date.date()          start_time = time()          if frequency == Frequency.DAILY:              start_date = start_date          if frequency == Frequency.WEEKLY:              start_date = start_date - timedelta(days=start_date.weekday())          if frequency == Frequency.MONTHLY:              start_date = start_date.replace(day=1)          if frequency == Frequency.YEARLY:              start_date = start_date.replace(day=1, month=1)          return datetime.combine(start_date, start_time)        @staticmethod      def _get_end_date_of_cycle(frequency: Frequency, start_date: datetime):          end_date = start_date          if frequency == Frequency.DAILY:              end_date = end_date + timedelta(days=1)          if frequency == Frequency.WEEKLY:              end_date = end_date + timedelta(7 - end_date.weekday())          if frequency == Frequency.MONTHLY:              last_day_of_month = calendar.monthrange(start_date.year, start_date.month)[1]              end_date = end_date.replace(day=last_day_of_month) + timedelta(days=1)          if frequency == Frequency.YEARLY:              end_date = end_date.replace(month=12, day=31) + timedelta(days=1)          return end_date - timedelta(microseconds=1)        @classmethod      def _hard_delete(cls, cycle_id: CycleId):          cycle = cls._get(cycle_id)          entity_ids_to_delete = cls._get_children_entity_ids(cycle)          entity_ids_to_delete.cycle_ids.add(cycle.id)          cls._delete_entities_of_multiple_types(entity_ids_to_delete)        @classmethod      def _get_children_entity_ids(cls, cycle: Cycle) -> _EntityIds:          from ..scenario._scenario_manager_factory import _ScenarioManagerFactory            entity_ids = _EntityIds()            scenarios = _ScenarioManagerFactory._build_manager()._get_all_by_cycle(cycle)            for scenario in scenarios:              entity_ids.scenario_ids.add(scenario.id)              owner_ids = {scenario.id, cycle.id}              for sequence in scenario.sequences.values():                  if sequence.owner_id in owner_ids:                      entity_ids.sequence_ids.add(sequence.id)              for task in scenario.tasks.values():                  if task.owner_id in owner_ids:                      entity_ids.task_ids.add(task.id)              for data_node in scenario.data_nodes.values():                  if data_node.owner_id in owner_ids:                      entity_ids.data_node_ids.add(data_node.id)            jobs = _JobManagerFactory._build_manager()._get_all()          for job in jobs:              if job.task.id in entity_ids.task_ids:                  entity_ids.job_ids.add(job.id)            submissions = _SubmissionManagerFactory._build_manager()._get_all()          submitted_entity_ids = list(entity_ids.scenario_ids.union(entity_ids.sequence_ids, entity_ids.task_ids))          for submission in submissions:              if submission.entity_id in submitted_entity_ids:                  entity_ids.submission_ids.add(submission.id)            return entity_ids        @classmethod      def _get_cycles_by_frequency_and_start_date(          cls, frequency: Frequency, start_date: datetime, cycles: List[Cycle]      ) -> List[Cycle]:          return cls._get_cycles_cdt(              lambda cycle: cycle.frequency == frequency and cycle.start_date == start_date, cycles          )        @classmethod      def _get_cycles_by_frequency_and_overlapping_date(          cls, frequency: Frequency, date: datetime, cycles: List[Cycle]      ) -> List[Cycle]:          return cls._get_cycles_cdt(              lambda cycle: cycle.frequency == frequency and cycle.start_date <= date <= cycle.end_date, cycles          )        @classmethod      def _get_cycles_cdt(cls, cdt: Callable[[Cycle], bool], cycles: List[Cycle]) -> List[Cycle]:          return [cycle for cycle in cycles if cdt(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. "}
{"text": "#  # Licensed under the Apache License, Version 2.0 (the \"License\"); you may not use this file except in compliance with  # the License. You may obtain a copy of the License at  #  #        http://www.apache.org/licenses/LICENSE-2.0  #  # Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on  # an \"AS IS\" BASIS, WITHOUT 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": "import uuid  from typing import List, Optional, Union    from taipy.config import Config  from taipy.config._config_comparator._comparator_result import _ComparatorResult  from taipy.config.checker.issue_collector import IssueCollector  from taipy.config.exceptions.exceptions import InconsistentEnvVariableError  from taipy.logger._taipy_logger import _TaipyLogger    from .._manager._manager import _Manager  from ..exceptions.exceptions import ConflictedConfigurationError, ModelNotFound, NonExistingVersion  from ._version import _Version  from ._version_fs_repository import _VersionFSRepository      class _VersionManager(_Manager[_Version]):      _ENTITY_NAME = _Version.__name__        __logger = _TaipyLogger._get_logger()        __DEVELOPMENT_VERSION = [\"development\", \"dev\"]      __LATEST_VERSION = \"latest\"      __PRODUCTION_VERSION = \"production\"      __ALL_VERSION = [\"all\", \"\"]        _DEFAULT_VERSION = __LATEST_VERSION        _repository: _VersionFSRepository        @classmethod      def _get(cls, entity: Union[str, _Version], default=None) -> _Version:          \"\"\"          Returns the version entity by id or reference.          \"\"\"          entity_id = entity if isinstance(entity, str) else entity.id          try:              return cls._repository._load(entity_id)          except ModelNotFound:              return default        @classmethod      def _get_or_create(cls, id: str, force: bool) -> _Version:          if version := cls._get(id):              comparator_result = Config._comparator._find_conflict_config(version.config, Config._applied_config, id)              if comparator_result.get(_ComparatorResult.CONFLICTED_SECTION_KEY):                  if force:                      cls.__logger.warning(                          f\"Option --force is detected, overriding the configuration of version {id} ...\"                      )                      version.config = Config._applied_config                  else:                      raise ConflictedConfigurationError()            else:              version = _Version(id=id, config=Config._applied_config)            cls._set(version)          return version        @classmethod      def _get_all(cls, version_number: Optional[Union[str, List]] = \"all\") -> List[_Version]:          \"\"\"          Returns all entities.          \"\"\"          version_number = cls._replace_version_number(version_number)  # type: ignore          if not isinstance(version_number, List):              version_number = [version_number] if version_number else []          filters = [{\"version\": version} for version in version_number]          return cls._repository._load_all(filters)        @classmethod      def _set_development_version(cls, version_number: str) -> str:          cls._get_or_create(version_number, force=True)          cls._repository._set_development_version(version_number)          return version_number        @classmethod      def _get_development_version(cls) -> str:          try:              return cls._repository._get_development_version()          except (FileNotFoundError, ModelNotFound):              return cls._set_development_version(str(uuid.uuid4()))        @classmethod      def _set_experiment_version(cls, version_number: str, force: bool = False) -> str:          if version_number == cls._get_development_version():              raise SystemExit(                  f\"Version number {version_number} is the development version. Please choose a different name\"                  f\" for this experiment.\"              )            if version_number in cls._get_production_versions():              raise SystemExit(                  f\"Version number {version_number} is already a production version. Please choose a different name\"                  f\" for this experiment.\"              )            try:              cls._get_or_create(version_number, force)          except ConflictedConfigurationError:              raise SystemExit(                  f\"Please add a new experiment version or run your application with --force option to\"                  f\" override the Config of experiment {version_number}.\"              )          cls._repository._set_latest_version(version_number)          return version_number        @classmethod      def _get_latest_version(cls) -> str:          try:              return cls._repository._get_latest_version()          except (FileNotFoundError, ModelNotFound):              # If there is no version in the system yet, create a new version as development version              # This set the default versioning behavior on Jupyter notebook to Development mode              return cls._set_development_version(str(uuid.uuid4()))        @classmethod      def _set_production_version(cls, version_number: str, force: bool = False) -> str:          if version_number == cls._get_development_version():              cls._set_development_version(str(uuid.uuid4()))            try:              cls._get_or_create(version_number, force)          except ConflictedConfigurationError:              raise SystemExit(                  f\"Please add a new production version with migration functions.\\n\"                  f\"If old entities remain compatible with the new configuration, you can also run your application with\"                  f\" --force option to override the production configuration of version {version_number}.\"              )          cls._repository._set_production_version(version_number)          return version_number        @classmethod      def _get_production_versions(cls) -> List[str]:          try:              return cls._repository._get_production_versions()          except (FileNotFoundError, ModelNotFound):              return []        @classmethod      def _delete_production_version(cls, version_number) -> str:          return cls._repository._delete_production_version(version_number)        @classmethod      def _replace_version_number(cls, version_number: Optional[str] = None):          if version_number is None:              version_number = cls._replace_version_number(cls._DEFAULT_VERSION)                production_versions = cls._get_production_versions()              if version_number in production_versions:                  return production_versions                return version_number            if version_number == cls.__LATEST_VERSION:              return cls._get_latest_version()          if version_number in cls.__DEVELOPMENT_VERSION:              return cls._get_development_version()          if version_number == cls.__PRODUCTION_VERSION:              return cls._get_production_versions()          if version_number in cls.__ALL_VERSION:              return \"\"            try:              if version := cls._get(version_number):                  return version.id          except InconsistentEnvVariableError:  # The version exist but the Config is alternated              return version_number            raise NonExistingVersion(version_number)        @classmethod      def _manage_version(cls):          from ..taipy import clean_all_entities_by_version            if Config.core.mode == \"development\":              current_version_number = cls._get_development_version()              cls.__logger.info(f\"Development mode: Clean all entities of version {current_version_number}\")              clean_all_entities_by_version(current_version_number)              cls._set_development_version(current_version_number)            elif Config.core.mode in [\"experiment\", \"production\"]:              default_version_number = {                  \"experiment\": str(uuid.uuid4()),                  \"production\": cls._get_latest_version(),              }              version_setter = {                  \"experiment\": cls._set_experiment_version,                  \"production\": cls._set_production_version,              }                if Config.core.version_number:                  current_version_number = Config.core.version_number              else:                  current_version_number = default_version_number[Config.core.mode]                version_setter[Config.core.mode](current_version_number, Config.core.force)              if Config.core.mode == \"production\":                  cls.__check_production_migration_config()          else:              raise SystemExit(f\"Undefined execution mode: {Config.core.mode}.\")        @classmethod      def __check_production_migration_config(self):          from ..config.checkers._migration_config_checker import _MigrationConfigChecker            collector = _MigrationConfigChecker(Config._applied_config, IssueCollector())._check()          for issue in collector._warnings:              self.__logger.warning(str(issue))          for issue in collector._infos:              self.__logger.info(str(issue))          for issue in collector._errors:              self.__logger.error(str(issue))          if len(collector._errors) != 0:              raise SystemExit(\"Configuration errors found. Please check the error log for more information.\")        @classmethod      def _delete_entities_of_multiple_types(cls, _entity_ids):          raise NotImplementedError "}
{"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": "import sys    from taipy._cli._base_cli import _CLI  from taipy.config import Config  from taipy.config.exceptions.exceptions import InconsistentEnvVariableError  from taipy.logger._taipy_logger import _TaipyLogger    from ...data._data_manager_factory import _DataManagerFactory  from ...exceptions.exceptions import VersionIsNotProductionVersion  from ...job._job_manager_factory import _JobManagerFactory  from ...scenario._scenario_manager_factory import _ScenarioManagerFactory  from ...sequence._sequence_manager_factory import _SequenceManagerFactory  from ...taipy import clean_all_entities_by_version  from ...task._task_manager_factory import _TaskManagerFactory  from .._version_manager_factory import _VersionManagerFactory  from ._bcolor import _Bcolors      class _VersionCLI:      \"\"\"Command-line interface of the versioning system.\"\"\"        __logger = _TaipyLogger._get_logger()        @classmethod      def create_parser(cls):          version_parser = _CLI._add_subparser(\"manage-versions\", help=\"Taipy version control system.\")            version_parser.add_argument(              \"-l\", \"--list\", action=\"store_true\", help=\"List all existing versions of the Taipy application.\"          )            version_parser.add_argument(              \"--rename\", nargs=2, metavar=(\"OLD_VERSION\", \"NEW_VERSION\"), help=\"Rename a Taipy version.\"          )            version_parser.add_argument(              \"--compare-config\",              nargs=2,              metavar=(\"VERSION_1\", \"VERSION_2\"),              help=\"Compare the Configuration of 2 Taipy versions.\",          )            version_parser.add_argument(              \"-d\", \"--delete\", metavar=\"VERSION\", help=\"Delete a Taipy version by version number.\"          )            version_parser.add_argument(              \"-dp\",              \"--delete-production\",              metavar=\"VERSION\",              help=\"Delete a Taipy version from production by version number. The version is still kept as an experiment \"              \"version.\",          )        @classmethod      def parse_arguments(cls):          args = _CLI._parse()            if getattr(args, \"which\", None) != \"manage-versions\":              return            if args.list:              print(cls.__list_versions())              sys.exit(0)            if args.rename:              try:                  cls.__rename_version(args.rename[0], args.rename[1])              except InconsistentEnvVariableError as error:                  cls.__logger.error(                      f\"Fail to rename version {args.rename[0]} to {args.rename[1]} due to outdated Configuration.\"                      f\"Detail: {str(error)}\"                  )                  sys.exit(1)                cls.__logger.info(f\"Successfully renamed version '{args.rename[0]}' to '{args.rename[1]}'.\")              sys.exit(0)            if args.compare_config:              cls.__compare_version_config(args.compare_config[0], args.compare_config[1])              sys.exit(0)            if args.delete_production:              try:                  _VersionManagerFactory._build_manager()._delete_production_version(args.delete_production)                  cls.__logger.info(                      f\"Successfully delete version {args.delete_production} from the production version list.\"                  )                  sys.exit(0)              except VersionIsNotProductionVersion as e:                  raise SystemExit(e)            if args.delete:              if clean_all_entities_by_version(args.delete):                  cls.__logger.info(f\"Successfully delete version {args.delete}.\")              else:                  sys.exit(1)                sys.exit(0)        @classmethod      def __list_versions(cls):          list_version_message = f\"\\n{'Version number':<36}   {'Mode':<20}   {'Creation date':<20}\\n\"            latest_version_number = _VersionManagerFactory._build_manager()._get_latest_version()          development_version_number = _VersionManagerFactory._build_manager()._get_development_version()          production_version_numbers = _VersionManagerFactory._build_manager()._get_production_versions()            versions = _VersionManagerFactory._build_manager()._get_all()          versions.sort(key=lambda x: x.creation_date, reverse=True)            bold = False          for version in versions:              if version.id == development_version_number:                  list_version_message += _Bcolors.GREEN                  mode = \"Development\"              elif version.id in production_version_numbers:                  list_version_message += _Bcolors.PURPLE                  mode = \"Production\"              else:                  list_version_message += _Bcolors.BLUE                  mode = \"Experiment\"                if version.id == latest_version_number:                  list_version_message += _Bcolors.BOLD                  bold = True                  mode += \" (latest)\"                list_version_message += (                  f\"{(version.id):<36}   {mode:<20}   {version.creation_date.strftime('%Y-%m-%d %H:%M:%S'):<20}\"              )              list_version_message += _Bcolors.END                if bold:                  list_version_message += _Bcolors.END              list_version_message += \"\\n\"            return list_version_message        @classmethod      def __rename_version(cls, old_version: str, new_version: str):          _version_manager = _VersionManagerFactory._build_manager()            # Check if the new version already exists, return an error          if _version_manager._get(new_version):              cls.__logger.error(f\"Version name '{new_version}' is already used.\")              sys.exit(1)            # Make sure that all entities of the old version are exists and loadable          version_entity = _version_manager._get(old_version)          if version_entity is None:              cls.__logger.error(f\"Version '{old_version}' does not exist.\")              sys.exit(1)            jobs = _JobManagerFactory._build_manager()._get_all(version_number=old_version)          scenarios = _ScenarioManagerFactory._build_manager()._get_all(version_number=old_version)          sequences = _SequenceManagerFactory._build_manager()._get_all(version_number=old_version)          tasks = _TaskManagerFactory._build_manager()._get_all(version_number=old_version)          datanodes = _DataManagerFactory._build_manager()._get_all(version_number=old_version)            # Update the version of all entities          for job in jobs:              job._version = new_version              _JobManagerFactory._build_manager()._set(job)          for scenario in scenarios:              scenario._version = new_version              _ScenarioManagerFactory._build_manager()._set(scenario)          for sequence in sequences:              sequence._version = new_version              _SequenceManagerFactory._build_manager()._set(sequence)          for task in tasks:              task._version = new_version              _TaskManagerFactory._build_manager()._set(task)          for datanode in datanodes:              datanode._version = new_version              _DataManagerFactory._build_manager()._set(datanode)            # Update the version entity          if old_version in _version_manager._get_production_versions():              _version_manager._set_production_version(new_version)          if old_version == _version_manager._get_latest_version():              _version_manager._set_experiment_version(new_version)          if old_version == _version_manager._get_development_version():              _version_manager._set_development_version(new_version)          _version_manager._delete(old_version)            try:              _version_manager._delete_production_version(old_version)          except VersionIsNotProductionVersion:              pass            if not _version_manager._get(new_version):              version_entity.id = new_version              _version_manager._set(version_entity)        @classmethod      def __compare_version_config(cls, version_1: str, version_2: str):          version_entity_1 = _VersionManagerFactory._build_manager()._get(version_1)          if version_entity_1 is None:              cls.__logger.error(f\"Version '{version_1}' does not exist.\")              sys.exit(1)            version_entity_2 = _VersionManagerFactory._build_manager()._get(version_2)          if version_entity_2 is None:              cls.__logger.error(f\"Version '{version_2}' does not exist.\")              sys.exit(1)            Config._comparator._compare(              version_entity_1.config,              version_entity_2.config,              version_1,              version_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": "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": "  from typing import List, Optional      class ConfigCoreVersionMismatched(Exception):      \"\"\"Raised if core version in Config does not match with the version of Taipy Core.\"\"\"        def __init__(self, config_core_version: str, core_version: str) -> None:          self.message = (              f\"Core version {config_core_version} in Config does not match with version of Taipy Core {core_version}.\"          )      class CoreServiceIsAlreadyRunning(Exception):      \"\"\"Raised if the Core service is already running.\"\"\"      class CycleAlreadyExists(Exception):      \"\"\"Raised if it is trying to create a Cycle that has already exists.\"\"\"      class NonExistingCycle(Exception):      \"\"\"Raised if a requested cycle is not known by the Cycle manager.\"\"\"        def __init__(self, cycle_id: str):          self.message = f\"Cycle: {cycle_id} does not exist.\"      class MissingRequiredProperty(Exception):      \"\"\"Raised if a required property is missing when creating a Data Node.\"\"\"      class InvalidDataNodeType(Exception):      \"\"\"Raised if a data node storage type does not exist.\"\"\"      class MultipleDataNodeFromSameConfigWithSameOwner(Exception):      \"\"\"      Raised if there are multiple data nodes from the same data node configuration and the same owner identifier.      \"\"\"      class NoData(Exception):      \"\"\"Raised if a data node is read before it has been written.        This exception can be raised by `DataNode.read_or_raise()^`.      \"\"\"      class UnknownDatabaseEngine(Exception):      \"\"\"Raised if the database engine is not known when creating a connection with a SQLDataNode.\"\"\"      class MissingAppendQueryBuilder(Exception):      \"\"\"Raised if no append query build is provided when appending data to a SQLDataNode.\"\"\"      class UnknownParquetEngine(Exception):      \"\"\"Raised if the parquet engine is not known or not supported when create a ParquetDataNode.\"\"\"      class UnknownCompressionAlgorithm(Exception):      \"\"\"Raised if the compression algorithm is not supported by ParquetDataNode.\"\"\"      class NonExistingDataNode(Exception):      \"\"\"Raised if a requested DataNode is not known by the DataNode Manager.\"\"\"        def __init__(self, data_node_id: str):          self.message = f\"DataNode: {data_node_id} does not exist.\"      class DataNodeIsBeingEdited(Exception):      \"\"\"Raised if a DataNode is being edited.\"\"\"        def __init__(self, data_node_id: str, editor_id: Optional[str] = None):          self.message = f\"DataNode {data_node_id} is being edited{ ' by ' + editor_id if editor_id else ''}.\"      class NonExistingDataNodeConfig(Exception):      \"\"\"Raised if a requested DataNodeConfig is not known by the DataNode Manager.\"\"\"        def __init__(self, data_node_config_id: str):          self.message = f\"Data node config: {data_node_config_id} does not exist.\"      class NonExistingExcelSheet(Exception):      \"\"\"Raised if a requested Sheet name does not exist in the provided Excel file.\"\"\"        def __init__(self, sheet_name: str, excel_file_name: str):          self.message = f\"{sheet_name} does not exist in {excel_file_name}.\"      class ExposedTypeLengthMismatch(Exception):      \"\"\"Raised if length of exposed type list does not match with number of sheets in the provided Excel file.\"\"\"      class SheetNameLengthMismatch(Exception):      \"\"\"Raised if length of sheet_name list does not match      with number of sheets in the data to be written to Excel file.\"\"\"      class InvalidExposedType(Exception):      \"\"\"Raised if an invalid exposed type is provided.\"\"\"      class InvalidCustomDocument(Exception):      \"\"\"Raised if an invalid custom document class is provided to a `MongoCollectionDataNode`.\"\"\"      class DataNodeConfigIsNotGlobal(Exception):      \"\"\"Raised if a DataNode is not global.\"\"\"        def __init__(self, data_node_config_id: str):          self.message = f\"Data node config `{data_node_config_id}` does not have GLOBAL scope.\"      class MissingReadFunction(Exception):      \"\"\"Raised if no read function is provided for the GenericDataNode.\"\"\"      class MissingWriteFunction(Exception):      \"\"\"Raised if no write function is provided for the GenericDataNode.\"\"\"      class JobNotDeletedException(RuntimeError):      \"\"\"Raised if there is an attempt to delete a job that cannot be deleted.        This exception can be raised by `taipy.delete_job()^`.      \"\"\"        def __init__(self, job_id: str):          self.message = f\"Job: {job_id} cannot be deleted.\"      class NonExistingJob(RuntimeError):      \"\"\"Raised if a requested job is not known by the Job manager.\"\"\"        def __init__(self, job_id: str):          self.message = f\"Job: {job_id} does not exist.\"      class DataNodeWritingError(RuntimeError):      \"\"\"Raised if an error happens during the writing in a data node.\"\"\"      class InvalidSubscriber(RuntimeError):      \"\"\"Raised if the loaded function is not valid.\"\"\"      class InvalidSequenceId(Exception):      \"\"\"Raised if a Sequence id can not be broken down.\"\"\"        def __init__(self, sequence_id: str):          self.message = f\"Sequence: {sequence_id} is invalid.\"      class InvalidSequence(Exception):      \"\"\"Raised if a Sequence is not a connected Directed Acyclic Graph.\"\"\"        def __init__(self, sequence_id: str):          self.message = f\"Sequence: {sequence_id} is not a connected Directed Acyclic Graph.\"      class NonExistingSequence(Exception):      \"\"\"Raised if a requested Sequence is not known by the Sequence Manager.\"\"\"        def __init__(self, sequence_id: str):          self.message = f\"Sequence: {sequence_id} does not exist.\"      class SequenceBelongsToNonExistingScenario(Exception):      \"\"\"Raised if a Sequence does not belong to an existing Scenario.\"\"\"        def __init__(self, sequence_id: str, scenario_id: str):          self.message = f\"Sequence: {sequence_id} belongs to a non-existing Scenario: {scenario_id}.\"      class SequenceTaskDoesNotExistInScenario(Exception):      \"\"\"Raised if Tasks of a Sequence do not exist in the same Scenario that the Sequence belongs to.\"\"\"        def __init__(self, task_ids: List[Optional[str]], sequence_name: str, scenario_id: str):          self.message = f\"Tasks {task_ids} of Sequence {sequence_name} does not exist in Scenario {scenario_id}.\"      class SequenceTaskConfigDoesNotExistInSameScenarioConfig(Exception):      \"\"\"Raised if TaskConfigs of a Sequence do not exist in the same ScenarioConfig that the Sequence belongs to.\"\"\"        def __init__(self, task_config_ids: List[Optional[str]], sequence_name: str, scenario_config_id: str):          self.message = f\"TaskConfig {task_config_ids} of Sequence name {sequence_name} \"          self.message += f\"does not exist in ScenarioConfig {scenario_config_id}.\"      class NonExistingSequenceConfig(Exception):      \"\"\"Raised if a requested Sequence configuration is not known by the Sequence Manager.\"\"\"        def __init__(self, sequence_config_id: str):          self.message = f\"Sequence config: {sequence_config_id} does not exist.\"      class MultipleSequenceFromSameConfigWithSameOwner(Exception):      \"\"\"Raised if it exists multiple sequences from the same sequence config and with the same _owner_id_.\"\"\"      class ModelNotFound(Exception):      \"\"\"Raised when trying to fetch a non-existent model.        This exception can be raised by `taipy.get()^` and `taipy.delete()^`.      \"\"\"        def __init__(self, model_name: str, model_id: str):          self.message = f\"A {model_name} model with id {model_id} could not be found.\"      class NonExistingScenario(Exception):      \"\"\"Raised if a requested scenario is not known by the Scenario Manager.\"\"\"        def __init__(self, scenario_id: str):          self.message = f\"Scenario: {scenario_id} does not exist.\"      class NonExistingScenarioConfig(Exception):      \"\"\"Raised if a requested scenario configuration is not known by the Scenario Manager.        This exception can be raised by `taipy.compare_scenarios()^`.      \"\"\"        def __init__(self, scenario_config_id: str):          self.message = f\"Scenario config: {scenario_config_id} does not exist.\"      class InvalidSscenario(Exception):      \"\"\"Raised if a Scenario is not a Directed Acyclic Graph.\"\"\"        def __init__(self, scenario_id: str):          self.message = f\"Scenario: {scenario_id} is not a Directed Acyclic Graph.\"      class DoesNotBelongToACycle(Exception):      \"\"\"Raised if a scenario without any cycle is promoted as primary scenario.\"\"\"      class DeletingPrimaryScenario(Exception):      \"\"\"Raised if a primary scenario is deleted.\"\"\"      class DifferentScenarioConfigs(Exception):      \"\"\"Raised if scenario comparison is requested on scenarios with different scenario configs.        This exception can be raised by `taipy.compare_scenarios()^`.      \"\"\"      class InsufficientScenarioToCompare(Exception):      \"\"\"Raised if too few scenarios are requested to be compared.        Scenario comparison need at least two scenarios to compare.        This exception can be raised by `taipy.compare_scenarios()^`.      \"\"\"      class NonExistingComparator(Exception):      \"\"\"Raised if a scenario comparator does not exist.        This exception can be raised by `taipy.compare_scenarios()^`.      \"\"\"      class UnauthorizedTagError(Exception):      \"\"\"Must provide an authorized tag.\"\"\"      class DependencyNotInstalled(Exception):      \"\"\"Raised if a package is missing.\"\"\"        def __init__(self, package_name: str):          self.message = f\"\"\"          Package '{package_name}' should be installed.          Run 'pip install taipy[{package_name}]' to installed it.          \"\"\"      class NonExistingTask(Exception):      \"\"\"Raised if a requested task is not known by the Task Manager.\"\"\"        def __init__(self, task_id: str):          self.message = f\"Task: {task_id} does not exist.\"      class NonExistingTaskConfig(Exception):      \"\"\"Raised if a requested task configuration is not known by the Task Manager.\"\"\"        def __init__(self, id: str):          self.message = f\"Task config: {id} does not exist.\"      class MultipleTaskFromSameConfigWithSameOwner(Exception):      \"\"\"Raised if there are multiple tasks from the same task configuration and the same owner identifier.\"\"\"      class OrchestratorNotBuilt(Exception):      \"\"\"Raised if the orchestrator was not built in the OrchestratorFactory\"\"\"      class ModeNotAvailable(Exception):      \"\"\"Raised if the mode in JobConfig is not supported.\"\"\"      class InvalidExportPath(Exception):      \"\"\"Raised if the export path is not valid.\"\"\"      class NonExistingVersion(Exception):      \"\"\"Raised if request a Version that is not known by the Version Manager.\"\"\"        def __init__(self, version_number: str):          self.message = f\"Version '{version_number}' does not exist.\"      class VersionIsNotProductionVersion(Exception):      \"\"\"Raised if the version is not a production version.\"\"\"      class ConflictedConfigurationError(Exception):      \"\"\"Conflicts have been detected between the current and previous Configurations.\"\"\"      class InvalidEventAttributeName(Exception):      \"\"\"      Raised if the attribute doesn't exist or an attribute name is provided      when operation is either creation, deletion or submission      \"\"\"      class InvalidEventOperation(Exception):      \"\"\"Raised when operation doesn't belong to the entity\"\"\"      class FileCannotBeRead(Exception):      \"\"\"Raised when a file cannot be read.\"\"\"      class _SuspiciousFileOperation(Exception):      pass "}
{"text": "#  # Licensed under the Apache License, Version 2.0 (the \"License\"); you may not use this file except in compliance with  # the License. You may obtain a copy of the License at  #  #        http://www.apache.org/licenses/LICENSE-2.0  #  # Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on  # an \"AS IS\" BASIS, WITHOUT 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": "import json  from typing import Dict, List, Optional, Tuple    from taipy.logger._taipy_logger import _TaipyLogger    __logger = _TaipyLogger._get_logger()      def __update_parent_ids(entity: Dict, data: Dict) -> Dict:      # parent_ids was not present in 2.0, need to be search for in tasks      parent_ids = entity.get(\"parent_ids\", [])      if not parent_ids:          parent_ids = __search_parent_ids(entity[\"id\"], data)      entity[\"parent_ids\"] = parent_ids        return entity      def __update_config_parent_ids(id: str, entity: Dict, entity_type: str, config: Dict) -> Dict:      # parent_ids was not present in 2.0, need to be search for in tasks      parent_ids = entity.get(\"parent_ids\", [])        if not parent_ids:          parent_ids = __search_parent_config(id, config, entity_type)      entity[\"parent_ids\"] = parent_ids        return entity      def __search_parent_ids(entity_id: str, data: Dict) -> List:      parents = []      entity_type = entity_id.split(\"_\", 1)[0]        for _id, entity_data in data.items():          entity_data = entity_data[\"data\"]          if entity_type == \"DATANODE\" and \"TASK\" in _id:              if entity_id in entity_data[\"input_ids\"] or entity_id in entity_data[\"output_ids\"]:                  parents.append(_id)            if entity_type == \"TASK\" and \"SCENARIO\" in _id:              if entity_id in entity_data[\"tasks\"]:                  parents.append(_id)      parents.sort()      return parents      def __search_parent_config(entity_id: str, config: Dict, entity_type: str) -> List:      parents = []      possible_parents = \"TASK\" if entity_type == \"DATA_NODE\" else \"SCENARIO\"      data = config[possible_parents]        for _id, entity_data in data.items():          section_id = f\"{entity_id}:SECTION\"          if entity_type == \"DATANODE\" and possible_parents == \"TASK\":              if section_id in entity_data[\"input_ids\"] or section_id in entity_data[\"output_ids\"]:                  parents.append(section_id)            if entity_type == \"TASK\" and possible_parents == \"SCENARIO\":              if section_id in entity_data[\"tasks\"]:                  parents.append(section_id)        parents.sort()      return parents      def __fetch_tasks_from_pipelines(pipelines: List, data: Dict) -> List:      tasks = []      for pipeline in pipelines:          pipeline_data = data[pipeline][\"data\"]          tasks.extend(pipeline_data[\"tasks\"])      return tasks      def __migrate_subscriber(fct_module, fct_name):      \"\"\"Rename scheduler by orchestrator on old jobs. Used to migrate from <=2.2 to >=2.3 version.\"\"\"      if fct_module == \"taipy.core._scheduler._scheduler\":          fct_module = fct_module.replace(\"_scheduler\", \"_orchestrator\")          fct_name = fct_name.replace(\"_Scheduler\", \"_Orchestrator\")      return fct_module, fct_name      def __migrate_scenario(scenario: Dict, data: Dict) -> Dict:      # pipelines were replaced by tasks      scenario[\"tasks\"] = __fetch_tasks_from_pipelines(scenario[\"pipelines\"], data)        # pipeline attribute not removed in 3.0      scenario[\"pipelines\"] = None        # additional_data_nodes attribute added      scenario[\"additional_data_nodes\"] = []        return scenario      def __is_cacheable(task: Dict, data: Dict) -> bool:      output_ids = task.get(\"output_ids\", []) or task.get(\"outputs\", [])  # output_ids is on entity, outputs is on config        for output_id in output_ids:          if output_id.endswith(\":SECTION\"):  # Get the config_id if the task is a Config              output_id = output_id.split(\":\")[0]          dn = data.get(output_id, {})          if \"data\" in dn:              dn = dn.get(\"data\", {})            if \"cacheable\" not in dn or not dn[\"cacheable\"] or dn[\"cacheable\"] == \"False:bool\":              return False      return True      def __migrate_task(task: Dict, data: Dict, is_entity: bool = True) -> Dict:      if is_entity:          # parent_id has been renamed to owner_id          try:              task[\"owner_id\"] = task[\"parent_id\"]              del task[\"parent_id\"]          except KeyError:              pass            # properties was not present in 2.0          task[\"properties\"] = task.get(\"properties\", {})        # skippable was not present in 2.0      task[\"skippable\"] = task.get(\"skippable\", False) or __is_cacheable(task, data)        return task      def __migrate_task_entity(task: Dict, data: Dict) -> Dict:      task = __update_parent_ids(task, data)      return __migrate_task(task, data)      def __migrate_task_config(task: Dict, config: Dict) -> Dict:      task = __migrate_task(task, config[\"DATA_NODE\"], False)        # Convert the skippable boolean to a string if needed      if isinstance(task.get(\"skippable\"), bool):          task[\"skippable\"] = str(task[\"skippable\"]) + \":bool\"      return task      def __update_scope(scope: str):      if scope in \"<Scope.SCENARIO: 2>\":          return \"<Scope.SCENARIO: 1>\"      elif scope == \"<Scope.CYCLE: 3>\":          return \"<Scope.CYCLE: 2>\"      elif scope == \"<Scope.GLOBAL: 4>\":          return \"<Scope.GLOBAL: 3>\"      return scope      def __migrate_datanode(datanode: Dict) -> Dict:      # cacheable was removed in after 2.0      _ = datanode.pop(\"cacheable\", False)        # job_ids was replaced by edits      if \"job_ids\" in datanode:          datanode[\"edits\"] = [{\"job_id\": job, \"timestamp\": datanode[\"last_edit_date\"]} for job in datanode[\"job_ids\"]]      elif \"edits\" in datanode:          # make sure timestamp inside edits is a string          edits = []          for edit in datanode[\"edits\"]:              timestamp = edit.get(\"timestamp\")              if isinstance(timestamp, dict):                  timestamp = timestamp.get(\"__value__\")              new_edit = {\"timestamp\": timestamp}              if \"job_id\" in edit:                  new_edit[\"job_id\"] = edit[\"job_id\"]              edits.append(new_edit)          datanode[\"edits\"] = edits        # parent_id has been renamed to owner_id      try:          datanode[\"owner_id\"] = datanode[\"parent_id\"]          del datanode[\"parent_id\"]      except KeyError:          pass        # Update Scope enum after Pipeline removal      datanode[\"scope\"] = __update_scope(datanode[\"scope\"])        # Update move name attribute to properties dictionary      datanode[\"data_node_properties\"][\"name\"] = datanode.pop(\"name\", None)        if \"last_edit_date\" not in datanode:          datanode[\"last_edit_date\"] = datanode.get(\"last_edition_date\")          if \"last_edition_date\" in datanode:              del datanode[\"last_edition_date\"]        if \"edit_in_progress\" not in datanode:          datanode[\"edit_in_progress\"] = datanode.get(\"edition_in_progress\")          if \"edition_in_progress\" in datanode:              del datanode[\"edition_in_progress\"]        return datanode      def __migrate_datanode_entity(datanode: Dict, data: Dict) -> Dict:      datanode = __update_parent_ids(datanode, data)      return __migrate_datanode(datanode)      def __migrate_datanode_config(datanode: Dict) -> Dict:      if datanode[\"storage_type\"] in [\"csv\", \"json\"]:          datanode[\"encoding\"] = \"utf-8\"      return datanode      def __migrate_job(job: Dict) -> Dict:      # submit_entity_id was not present before 3.0      job[\"submit_entity_id\"] = job.get(\"submit_entity_id\", None)      if \"subscribers\" in job:          for sub in job[\"subscribers\"]:              sub[\"fct_module\"], sub[\"fct_name\"] = __migrate_subscriber(sub[\"fct_module\"], sub[\"fct_name\"])      return job      def __migrate_global_config(config: Dict):      fields_to_remove = [\"clean_entities_enabled\"]      fields_to_move = [\"root_folder\", \"storage_folder\", \"repository_type\", \"read_entity_retry\"]        for field in fields_to_remove:          if field in config[\"TAIPY\"]:              del config[\"TAIPY\"][field]      try:          for field in fields_to_move:              if field not in config[\"CORE\"]:                  config[\"CORE\"][field] = config[\"TAIPY\"][field]                  del config[\"TAIPY\"][field]      except KeyError:          pass        return config      def __migrate_version(version: Dict) -> Dict:      config_str = version[\"config\"]        # Remove PIPELINE scope      config_str = config_str.replace(\"PIPELINE:SCOPE\", \"SCENARIO:SCOPE\")      config = json.loads(config_str)        # remove unused fields and move others from TAIPY to CORE section      config = __migrate_global_config(config)        # replace pipelines for tasks      pipelines_section = config[\"PIPELINE\"]      for id, content in config[\"SCENARIO\"].items():          tasks = []          for _pipeline in content[\"pipelines\"]:              pipeline_id = _pipeline.split(\":\")[0]              tasks = pipelines_section[pipeline_id][\"tasks\"]          config[\"SCENARIO\"][id][\"tasks\"] = tasks          del config[\"SCENARIO\"][id][\"pipelines\"]        for id, content in config[\"TASK\"].items():          config[\"TASK\"][id] = __migrate_task_config(content, config)        for id, content in config[\"DATA_NODE\"].items():          config[\"DATA_NODE\"][id] = __migrate_datanode_config(content)        del config[\"PIPELINE\"]        version[\"config\"] = json.dumps(config, ensure_ascii=False, indent=0)      return version      def __migrate_entities(entity_type: str, data: Dict) -> Dict:      migration_fct = FCT_MIGRATION_MAP.get(entity_type)      _entities = {k: data[k] for k in data if entity_type in k}        for k, v in _entities.items():          if entity_type in [\"JOB\", \"VERSION\"]:              v[\"data\"] = migration_fct(v[\"data\"])  # type: ignore          else:              v[\"data\"] = migration_fct(v[\"data\"], data)  # type: ignore          data[k] = v      return data      FCT_MIGRATION_MAP = {      \"SCENARIO\": __migrate_scenario,      \"TASK\": __migrate_task_entity,      \"DATANODE\": __migrate_datanode_entity,      \"JOB\": __migrate_job,      \"VERSION\": __migrate_version,  }      def _migrate(entities: Dict, versions: Optional[Dict] = None) -> Tuple[Dict, Dict]:      __logger.info(\"Migrating SCENARIOS\")      entities = __migrate_entities(\"SCENARIO\", entities)        __logger.info(\"Migrating TASKS\")      entities = __migrate_entities(\"TASK\", entities)        __logger.info(\"Migrating DATANODES\")      entities = __migrate_entities(\"DATANODE\", entities)        __logger.info(\"Migrating JOBS\")      entities = __migrate_entities(\"JOB\", entities)        __logger.info(\"Migrating VERSION\")      if versions:          versions = __migrate_entities(\"VERSION\", versions)      else:          entities = __migrate_entities(\"VERSION\", entities)          versions = {}      return entities, versions "}
{"text": "import json  import os  import shutil  import sqlite3  from typing import Dict, Tuple    from taipy.logger._taipy_logger import _TaipyLogger    from ._utils import _migrate    __logger = _TaipyLogger._get_logger()      def _load_all_entities_from_sql(db_file: str) -> Tuple[Dict, Dict]:      conn = sqlite3.connect(db_file)      query = \"SELECT model_id, document FROM taipy_model\"      query_version = \"SELECT * FROM taipy_version\"      cursor = conn.execute(query)      entities = {}      versions = {}        for row in cursor:          _id = row[0]          document = row[1]          entities[_id] = {\"data\": json.loads(document)}        cursor = conn.execute(query_version)      for row in cursor:          id = row[0]          config_id = row[1]          creation_date = row[2]          is_production = row[3]          is_development = row[4]          is_latest = row[5]          versions[id] = {              \"config_id\": config_id,              \"creation_date\": creation_date,              \"is_production\": is_production,              \"is_development\": is_development,              \"is_latest\": is_latest,          }      return entities, versions      def __insert_scenario(scenario: dict, conn):      query = f\"\"\"          INSERT INTO scenario (id, config_id, tasks, additional_data_nodes, creation_date, primary_scenario, subscribers,           tags, version, pipelines, cycle)          VALUES ({scenario['id']}, {scenario['config_id']}, {scenario['tasks']}, {scenario['additional_data_nodes']},          {scenario['creation_date']}, {scenario['primary_scenario']}, {scenario['subscribers']}, {scenario['tags']},          {scenario['version']}, {scenario['pipelines']}, {scenario['cycle']})          \"\"\"      conn.execute(query)      conn.commit()      def __insert_task(task: dict, conn):      query = f\"\"\"          INSERT INTO task (id, owner_id, parent_ids, config_id, input_ids, function_name, function_module, output_ids,          version, skippable, properties)          VALUES ({task['id']}, {task['owner_id']}, {task['parent_ids']}, {task['config_id']}, {task['input_ids']},           {task['function_name']}, {task['function_module']}, {task['output_ids']}, {task['version']},           {task['skippable']}, {task['properties']})      \"\"\"      conn.execute(query)      conn.commit()      def __insert_datanode(datanode: dict, conn):      query = f\"\"\"          INSERT INTO data_node (id, config_id, scope, storage_type, name, owner_id, parent_ids, last_edit_date, edits,          version, validity_days, validity_seconds, edit_in_progress, data_node_properties)          VALUES ({datanode['id']}, {datanode['config_id']}, {datanode['scope']}, {datanode['storage_type']},          {datanode['name']}, {datanode['owner_id']}, {datanode['parent_ids']}, {datanode['last_edit_date']},          {datanode['edits']}, {datanode['version']}, {datanode['validity_days']}, {datanode['validity_seconds']},          {datanode['edit_in_progress']}, {datanode['data_node_properties']})      \"\"\"      conn.execute(query)      conn.commit()      def __insert_job(job: dict, conn):      query = f\"\"\"          INSERT INTO job (id, task_id, status, force, submit_id, submit_entity_id, creation_date, subscribers,          stacktrace, version)          VALUES ({job['id']}, {job['task_id']}, {job['status']}, {job['force']}, {job['submit_id']},          {job['submit_entity_id']}, {job['creation_date']}, {job['subscribers']}, {job['stacktrace']}, {job['version']})      \"\"\"      conn.execute(query)      conn.commit()      def __insert_cycle(cycle: dict, conn):      query = f\"\"\"          INSERT INTO scenario (id, name, frequency, properties, creation_date, start_date, end_date)          VALUES ({cycle['id']}, {cycle['name']}, {cycle['frequency']}, {cycle['properties']}, {cycle['creation_date']},          {cycle['start_date']}, {cycle['end_date']})      \"\"\"      conn.execute(query)      conn.commit()      def __insert_version(version: dict, conn):      query = f\"\"\"          INSERT INTO version (id, config_id, creation_date, is_production, is_development, is_latest)          VALUES ({version['id']}, {version['config_id']}, {version['creation_date']}, {version['is_production']},          {version['is_development']}, {version['is_latest']})      \"\"\"      conn.execute(query)      conn.commit()      def __write_entities_to_sql(_entities: Dict, _versions: Dict, db_file: str):      conn = sqlite3.connect(db_file)        for k, entity in _entities.items():          if \"SCENARIO\" in k:              __insert_scenario(entity[\"data\"], conn)          elif \"TASK\" in k:              __insert_task(entity[\"data\"], conn)          elif \"DATANODE\" in k:              __insert_datanode(entity[\"data\"], conn)          elif \"JOB\" in k:              __insert_job(entity[\"data\"], conn)          elif \"CYCLE\" in k:              __insert_cycle(entity[\"data\"], conn)        for k, version in _versions.items():          __insert_version(version, conn)      def _restore_migrate_sql_entities(path: str) -> bool:      file_name, file_extension = path.rsplit(\".\", 1)      backup_path = f\"{file_name}_backup.{file_extension}\"        if not os.path.exists(backup_path):          __logger.error(f\"The backup database '{backup_path}' does not exist.\")          return False        if os.path.exists(path):          os.remove(path)      else:          __logger.warning(f\"The original entities database '{path}' does not exist.\")        os.rename(backup_path, path)      __logger.info(f\"Restored entities from the backup database '{backup_path}' to '{path}'.\")      return True      def _remove_backup_sql_entities(path: str) -> bool:      file_name, file_extension = path.rsplit(\".\", 1)      backup_path = f\"{file_name}_backup.{file_extension}\"      if not os.path.exists(backup_path):          __logger.error(f\"The backup database '{backup_path}' does not exist.\")          return False        os.remove(backup_path)      __logger.info(f\"Removed backup entities from the backup database '{backup_path}'.\")      return True      def _migrate_sql_entities(path: str, backup: bool = True) -> bool:      \"\"\"Migrate entities from sqlite database to the current version.        Args:          path (str): The path to the sqlite database.          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 path:          __logger.error(\"Missing the required sqlite path.\")          return False      if not os.path.exists(path):          __logger.error(f\"File '{path}' does not exist.\")          return False        if backup:          file_name, file_extension = path.rsplit(\".\", 1)          shutil.copyfile(path, f\"{file_name}_backup.{file_extension}\")          __logger.info(f\"Backed up entities from '{path}' to '{file_name}_backup.{file_extension}' before migration.\")        __logger.info(f\"Starting entity migration from sqlite database '{path}'\")        entities, versions = _load_all_entities_from_sql(path)      entities, versions = _migrate(entities, versions)      __write_entities_to_sql(entities, versions, 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": "from __future__ import annotations    import pathlib  import uuid  from datetime import datetime  from typing import Any, Callable, Dict, List, Optional, Set, Union    import networkx as nx    from taipy.config.common._template_handler import _TemplateHandler as _tpl  from taipy.config.common._validate_id import _validate_id    from .._entity._entity import _Entity  from .._entity._labeled import _Labeled  from .._entity._properties import _Properties  from .._entity._reload import _Reloader, _self_reload, _self_setter  from .._entity.submittable import Submittable  from .._version._version_manager_factory import _VersionManagerFactory  from ..common._listattributes import _ListAttributes  from ..common._utils import _Subscriber  from ..cycle.cycle import Cycle  from ..data._data_manager_factory import _DataManagerFactory  from ..data.data_node import DataNode  from ..data.data_node_id import DataNodeId  from ..exceptions.exceptions import (      InvalidSequence,      NonExistingDataNode,      NonExistingSequence,      NonExistingTask,      SequenceTaskDoesNotExistInScenario,  )  from ..job.job import Job  from ..notification import Event, EventEntityType, EventOperation, Notifier, _make_event  from ..sequence.sequence import Sequence  from ..task._task_manager_factory import _TaskManagerFactory  from ..task.task import Task  from ..task.task_id import TaskId  from .scenario_id import ScenarioId      class Scenario(_Entity, Submittable, _Labeled):      \"\"\"Instance of a Business case to solve.        A scenario holds a set of tasks (instances of `Task^` class) to submit for execution in order to      solve the Business case. It also holds a set of additional data nodes (instances of `DataNode` class)      for extra data related to the scenario.        Attributes:          config_id (str): The identifier of the `ScenarioConfig^`.          tasks (Set[Task^]): The set of tasks.          additional_data_nodes (Set[DataNode^]): The set of additional data nodes.          sequences (Dict[str, Sequence^]): The dictionary of sequences: subsets of tasks that can be submitted              together independently of the rest of the scenario's tasks.          properties (dict[str, Any]): A dictionary of additional properties.          scenario_id (str): The unique identifier of this scenario.          creation_date (datetime): The date and time of the scenario's creation.          is_primary (bool): True if the scenario is the primary of its cycle. False otherwise.          cycle (Cycle^): The cycle of the scenario.          subscribers (List[Callable]): The list of callbacks to be called on `Job^`'s status change.          tags (Set[str]): The list of scenario's tags.          version (str): The string indicates the application version of the scenario to instantiate.              If not provided, the latest version is used.      \"\"\"        _ID_PREFIX = \"SCENARIO\"      _MANAGER_NAME = \"scenario\"      _MIGRATED_SEQUENCES_KEY = \"sequences\"      __SEPARATOR = \"_\"      _SEQUENCE_TASKS_KEY = \"tasks\"      _SEQUENCE_PROPERTIES_KEY = \"properties\"      _SEQUENCE_SUBSCRIBERS_KEY = \"subscribers\"        def __init__(          self,          config_id: str,          tasks: Optional[Union[Set[TaskId], Set[Task]]],          properties: Dict[str, Any],          additional_data_nodes: Optional[Union[Set[DataNodeId], Set[DataNode]]] = None,          scenario_id: Optional[ScenarioId] = None,          creation_date: Optional[datetime] = None,          is_primary: bool = False,          cycle: Optional[Cycle] = None,          subscribers: Optional[List[_Subscriber]] = None,          tags: Optional[Set[str]] = None,          version: str = None,          sequences: Optional[Dict[str, Dict]] = None,      ):          super().__init__(subscribers or [])          self.config_id = _validate_id(config_id)          self.id: ScenarioId = scenario_id or self._new_id(self.config_id)            self._tasks: Union[Set[TaskId], Set[Task], Set] = tasks or set()          self._additional_data_nodes: Union[Set[DataNodeId], Set[DataNode], Set] = additional_data_nodes or set()            self._creation_date = creation_date or datetime.now()          self._cycle = cycle          self._primary_scenario = is_primary          self._tags = tags or set()          self._properties = _Properties(self, **properties)          self._sequences: Dict[str, Dict] = sequences or {}            _scenario_task_ids = set([task.id if isinstance(task, Task) else task for task in self._tasks])          for sequence_name, sequence_data in self._sequences.items():              sequence_task_ids = set(                  [task.id if isinstance(task, Task) else task for task in sequence_data.get(\"tasks\", [])]              )              self.__check_sequence_tasks_exist_in_scenario_tasks(                  sequence_name, sequence_task_ids, self.id, _scenario_task_ids              )            self._version = version or _VersionManagerFactory._build_manager()._get_latest_version()        @staticmethod      def _new_id(config_id: str) -> ScenarioId:          \"\"\"Generate a unique scenario identifier.\"\"\"          return ScenarioId(Scenario.__SEPARATOR.join([Scenario._ID_PREFIX, _validate_id(config_id), str(uuid.uuid4())]))        def __getstate__(self):          return self.id        def __setstate__(self, id):          from ... import core as tp            sc = tp.get(id)          self.__dict__ = sc.__dict__        def __hash__(self):          return hash(self.id)        def __eq__(self, other):          return self.id == other.id        def __getattr__(self, attribute_name):          protected_attribute_name = _validate_id(attribute_name)          if protected_attribute_name in self._properties:              return _tpl._replace_templates(self._properties[protected_attribute_name])            sequences = self._get_sequences()          if protected_attribute_name in sequences:              return sequences[protected_attribute_name]          tasks = self.tasks          if protected_attribute_name in tasks:              return tasks[protected_attribute_name]          data_nodes = self.data_nodes          if protected_attribute_name in data_nodes:              return data_nodes[protected_attribute_name]          raise AttributeError(f\"{attribute_name} is not an attribute of scenario {self.id}\")        @property  # type: ignore      @_self_reload(_MANAGER_NAME)      def sequences(self) -> Dict[str, Sequence]:          return self._get_sequences()        @sequences.setter  # type: ignore      @_self_setter(_MANAGER_NAME)      def sequences(          self, sequences: Dict[str, Dict[str, Union[List[Task], List[TaskId], _ListAttributes, List[_Subscriber], Dict]]]      ):          self._sequences = sequences          actual_sequences = self._get_sequences()          for sequence_name in sequences.keys():              if not actual_sequences[sequence_name]._is_consistent():                  raise InvalidSequence(actual_sequences[sequence_name].id)        def add_sequence(          self,          name: str,          tasks: Union[List[Task], List[TaskId]],          properties: Optional[Dict] = None,          subscribers: Optional[List[_Subscriber]] = None,      ):          \"\"\"Add a sequence to the scenario.            Parameters:              name (str): The name of the sequence.              tasks (Union[List[Task], List[TaskId]]): The list of scenario's tasks to add to the sequence.              properties (Optional[Dict]): The optional properties of the sequence.              subscribers (Optional[List[_Subscriber]]): The optional list of callbacks to be called on                  `Job^`'s status change.            Raises:              SequenceTaskDoesNotExistInScenario^: If a task in the sequence does not exist in the scenario.          \"\"\"          _scenario = _Reloader()._reload(self._MANAGER_NAME, self)          _scenario_task_ids = set([task.id if isinstance(task, Task) else task for task in _scenario._tasks])          _sequence_task_ids: Set[TaskId] = set([task.id if isinstance(task, Task) else task for task in tasks])          self.__check_sequence_tasks_exist_in_scenario_tasks(name, _sequence_task_ids, self.id, _scenario_task_ids)          _sequences = _Reloader()._reload(self._MANAGER_NAME, self)._sequences          _sequences.update(              {                  name: {                      self._SEQUENCE_TASKS_KEY: tasks,                      self._SEQUENCE_PROPERTIES_KEY: properties or {},                      self._SEQUENCE_SUBSCRIBERS_KEY: subscribers or [],                  }              }          )          self.sequences = _sequences  # type: ignore          if not self.sequences[name]._is_consistent():              raise InvalidSequence(name)          Notifier.publish(_make_event(self.sequences[name], EventOperation.CREATION))        def add_sequences(self, sequences: Dict[str, Union[List[Task], List[TaskId]]]):          \"\"\"Add multiple sequences to the scenario.            Note:              To provide properties and subscribers for the sequences, use `Scenario.add_sequence^` instead.            Parameters:              sequences (Dict[str, Union[List[Task], List[TaskId]]]):                  A dictionary containing sequences to add. Each key is a sequence name, and the value must                  be a list of the scenario tasks.            Raises:              SequenceTaskDoesNotExistInScenario^: If a task in the sequence does not exist in the scenario.          \"\"\"          _scenario = _Reloader()._reload(self._MANAGER_NAME, self)          _sc_task_ids = set([task.id if isinstance(task, Task) else task for task in _scenario._tasks])          for name, tasks in sequences.items():              _seq_task_ids: Set[TaskId] = set([task.id if isinstance(task, Task) else task for task in tasks])              self.__check_sequence_tasks_exist_in_scenario_tasks(name, _seq_task_ids, self.id, _sc_task_ids)          # Need to parse twice the sequences to avoid adding some sequences and not others in case of exception          for name, tasks in sequences.items():              self.add_sequence(name, tasks)        def remove_sequence(self, name: str):          \"\"\"Remove a sequence from the scenario.            Parameters:              name (str): The name of the sequence to remove.          \"\"\"          seq_id = self.sequences[name].id          _sequences = _Reloader()._reload(self._MANAGER_NAME, self)._sequences          _sequences.pop(name)          self.sequences = _sequences  # type: ignore          Notifier.publish(Event(EventEntityType.SEQUENCE, EventOperation.DELETION, entity_id=seq_id))        def remove_sequences(self, sequence_names: List[str]):          \"\"\"          Remove multiple sequences from the scenario.            Parameters:              sequence_names (List[str]): A list of sequence names to remove.          \"\"\"          _sequences = _Reloader()._reload(self._MANAGER_NAME, self)._sequences          for sequence_name in sequence_names:              seq_id = self.sequences[sequence_name].id              _sequences.pop(sequence_name)              Notifier.publish(                  Event(                      EventEntityType.SEQUENCE,                      EventOperation.DELETION,                      entity_id=seq_id,                  )              )          self.sequences = _sequences  # type: ignore        @staticmethod      def __check_sequence_tasks_exist_in_scenario_tasks(          sequence_name: str, sequence_task_ids: Set[TaskId], scenario_id: ScenarioId, scenario_task_ids: Set[TaskId]      ):          non_existing_sequence_task_ids_in_scenario = set()          for sequence_task_id in sequence_task_ids:              if sequence_task_id not in scenario_task_ids:                  non_existing_sequence_task_ids_in_scenario.add(sequence_task_id)          if len(non_existing_sequence_task_ids_in_scenario) > 0:              raise SequenceTaskDoesNotExistInScenario(                  list(non_existing_sequence_task_ids_in_scenario), sequence_name, scenario_id              )        def _get_sequences(self) -> Dict[str, Sequence]:          _sequences = {}            from ..sequence._sequence_manager_factory import _SequenceManagerFactory            sequence_manager = _SequenceManagerFactory._build_manager()            for sequence_name, sequence_data in self._sequences.items():              p = sequence_manager._create(                  sequence_name,                  sequence_data.get(self._SEQUENCE_TASKS_KEY, []),                  sequence_data.get(self._SEQUENCE_SUBSCRIBERS_KEY, []),                  sequence_data.get(self._SEQUENCE_PROPERTIES_KEY, {}),                  self.id,                  self.version,              )              if not isinstance(p, Sequence):                  raise NonExistingSequence(sequence_name)              _sequences[sequence_name] = p          return _sequences        @property  # type: ignore      @_self_reload(_MANAGER_NAME)      def tasks(self) -> Dict[str, Task]:          return self.__get_tasks()        def __get_tasks(self) -> Dict[str, Task]:          _tasks = {}          task_manager = _TaskManagerFactory._build_manager()            for task_or_id in self._tasks:              t = task_manager._get(task_or_id, task_or_id)                if not isinstance(t, Task):                  raise NonExistingTask(task_or_id)              _tasks[t.config_id] = t          return _tasks        @tasks.setter  # type: ignore      @_self_setter(_MANAGER_NAME)      def tasks(self, val: Union[Set[TaskId], Set[Task]]):          self._tasks = set(val)        @property  # type: ignore      @_self_reload(_MANAGER_NAME)      def additional_data_nodes(self) -> Dict[str, DataNode]:          return self.__get_additional_data_nodes()        def __get_additional_data_nodes(self):          additional_data_nodes = {}          data_manager = _DataManagerFactory._build_manager()            for dn_or_id in self._additional_data_nodes:              dn = data_manager._get(dn_or_id, dn_or_id)                if not isinstance(dn, DataNode):                  raise NonExistingDataNode(dn_or_id)              additional_data_nodes[dn.config_id] = dn          return additional_data_nodes        @additional_data_nodes.setter  # type: ignore      @_self_setter(_MANAGER_NAME)      def additional_data_nodes(self, val: Union[Set[TaskId], Set[DataNode]]):          self._additional_data_nodes = set(val)        def _get_set_of_tasks(self) -> Set[Task]:          return set(self.tasks.values())        @property  # type: ignore      @_self_reload(_MANAGER_NAME)      def data_nodes(self) -> Dict[str, DataNode]:          data_nodes_dict = self.__get_additional_data_nodes()          for _, task in self.__get_tasks().items():              data_nodes_dict.update(task.data_nodes)          return data_nodes_dict        @property  # type: ignore      @_self_reload(_MANAGER_NAME)      def creation_date(self):          return self._creation_date        @creation_date.setter  # type: ignore      @_self_setter(_MANAGER_NAME)      def creation_date(self, val):          self._creation_date = val        @property  # type: ignore      @_self_reload(_MANAGER_NAME)      def cycle(self):          return self._cycle        @cycle.setter  # type: ignore      @_self_setter(_MANAGER_NAME)      def cycle(self, val):          self._cycle = val        @property  # type: ignore      @_self_reload(_MANAGER_NAME)      def is_primary(self):          return self._primary_scenario        @is_primary.setter  # type: ignore      @_self_setter(_MANAGER_NAME)      def is_primary(self, val):          self._primary_scenario = val        @property  # type: ignore      @_self_reload(_MANAGER_NAME)      def subscribers(self):          return self._subscribers        @subscribers.setter  # type: ignore      @_self_setter(_MANAGER_NAME)      def subscribers(self, val):          self._subscribers = _ListAttributes(self, val)        @property  # type: ignore      @_self_reload(_MANAGER_NAME)      def tags(self):          return self._tags        @tags.setter  # type: ignore      @_self_setter(_MANAGER_NAME)      def tags(self, val):          self._tags = val or set()        @property      def version(self):          return self._version        @property      def owner_id(self):          return self._cycle.id        @property      def properties(self):          self._properties = _Reloader()._reload(self._MANAGER_NAME, self)._properties          return self._properties        @property  # type: ignore      def name(self) -> Optional[str]:          return self.properties.get(\"name\")        @name.setter  # type: ignore      def name(self, val):          self.properties[\"name\"] = val        def has_tag(self, tag: str) -> bool:          \"\"\"Indicate if the scenario has a given tag.            Parameters:              tag (str): The tag to search among the set of scenario's tags.          Returns:              True if the scenario has the tag given as parameter. False otherwise.          \"\"\"          return tag in self.tags        def _add_tag(self, tag: str):          self._tags = _Reloader()._reload(\"scenario\", self)._tags          self._tags.add(tag)        def _remove_tag(self, tag: str):          self._tags = _Reloader()._reload(\"scenario\", self)._tags          if self.has_tag(tag):              self._tags.remove(tag)        def subscribe(          self,          callback: Callable[[Scenario, Job], None],          params: Optional[List[Any]] = None,      ):          \"\"\"Subscribe a function to be called on `Job^` status change.            The subscription is applied to all jobs created from the scenario's execution.            Parameters:              callback (Callable[[Scenario^, Job^], None]): The callable function to be called                  on status change.              params (Optional[List[Any]]): The parameters to be passed to the _callback_.            Note:              Notification will be available only for jobs created after this subscription.          \"\"\"          from ... import core as tp            return tp.subscribe_scenario(callback, params, self)        def unsubscribe(self, callback: Callable[[Scenario, Job], None], params: Optional[List[Any]] = None):          \"\"\"Unsubscribe a function that is called when the status of a `Job^` changes.            Parameters:              callback (Callable[[Scenario^, Job^], None]): The callable function to unsubscribe.              params (Optional[List[Any]]): The parameters to be passed to the _callback_.            Note:              The function will continue to be called for ongoing jobs.          \"\"\"          from ... import core as tp            return tp.unsubscribe_scenario(callback, params, self)        def submit(          self,          callbacks: Optional[List[Callable]] = None,          force: bool = False,          wait: bool = False,          timeout: Optional[Union[float, int]] = None,      ) -> List[Job]:          \"\"\"Submit this scenario for execution.            All the `Task^`s of the scenario will be submitted for execution.            Parameters:              callbacks (List[Callable]): The list of callable functions to be called on status                  change.              force (bool): Force execution even if the data nodes are in cache.              wait (bool): Wait for the orchestrated jobs created from the scenario submission to be finished in                  asynchronous mode.              timeout (Union[float, int]): The optional maximum number of seconds to wait for the jobs to be finished                  before returning.            Returns:              A list of created `Job^`s.          \"\"\"          from ._scenario_manager_factory import _ScenarioManagerFactory            return _ScenarioManagerFactory._build_manager()._submit(self, callbacks, force, wait, timeout)        def export(          self,          folder_path: Union[str, pathlib.Path],      ):          \"\"\"Export all related entities of this scenario to a folder.            Parameters:              folder_path (Union[str, pathlib.Path]): The folder path to export the scenario to.          \"\"\"          from ... import core as tp            return tp.export_scenario(self.id, folder_path)        def set_primary(self):          \"\"\"Promote the scenario as the primary scenario of its cycle.            If the cycle already has a primary scenario, it will be demoted, and it will no longer          be primary for the cycle.          \"\"\"          from ... import core as tp            return tp.set_primary(self)        def add_tag(self, tag: str):          \"\"\"Add a tag to this scenario.            If the scenario's cycle already have another scenario tagged with _tag_ the other          scenario will be untagged.            Parameters:              tag (str): The tag to add to this scenario.          \"\"\"          from ... import core as tp            return tp.tag(self, tag)        def remove_tag(self, tag: str):          \"\"\"Remove a tag from this scenario.            Parameters:              tag (str): The tag to remove from the set of the scenario's tags.          \"\"\"          from ... import core as tp            return tp.untag(self, tag)        def is_deletable(self) -> bool:          \"\"\"Indicate if the scenario can be deleted.            Returns:              True if the scenario can be deleted. False otherwise.          \"\"\"          from ... import core as tp            return tp.is_deletable(self)        def get_label(self) -> str:          \"\"\"Returns the scenario simple label prefixed by its owner label.            Returns:              The label of the scenario as a string.          \"\"\"          return self._get_label()        def get_simple_label(self) -> str:          \"\"\"Returns the scenario simple label.            Returns:              The simple label of the scenario as a string.          \"\"\"          return self._get_simple_label()        def _is_consistent(self) -> bool:          dag = self._build_dag()          if dag.number_of_nodes() == 0:              return True          if not nx.is_directed_acyclic_graph(dag):              return False          for left_node, right_node in dag.edges:              if (isinstance(left_node, DataNode) and isinstance(right_node, Task)) or (                  isinstance(left_node, Task) and isinstance(right_node, DataNode)              ):                  continue              return False          return True      @_make_event.register(Scenario)  def _make_event_for_scenario(      scenario: Scenario,      operation: EventOperation,      /,      attribute_name: Optional[str] = None,      attribute_value: Optional[Any] = None,      **kwargs,  ) -> Event:      metadata = {\"config_id\": scenario.config_id, \"version\": scenario._version, **kwargs}      return Event(          entity_type=EventEntityType.SCENARIO,          entity_id=scenario.id,          operation=operation,          attribute_name=attribute_name,          attribute_value=attribute_value,          metadata=metadata,      ) "}
{"text": "import datetime  from functools import partial  from typing import Any, Callable, List, Optional, Union    from taipy.config import Config    from .._entity._entity_ids import _EntityIds  from .._manager._manager import _Manager  from .._repository._abstract_repository import _AbstractRepository  from .._version._version_mixin import _VersionMixin  from ..common.warn_if_inputs_not_ready import _warn_if_inputs_not_ready  from ..config.scenario_config import ScenarioConfig  from ..cycle._cycle_manager_factory import _CycleManagerFactory  from ..cycle.cycle import Cycle  from ..data._data_manager_factory import _DataManagerFactory  from ..exceptions.exceptions import (      DeletingPrimaryScenario,      DifferentScenarioConfigs,      DoesNotBelongToACycle,      InsufficientScenarioToCompare,      InvalidSequence,      InvalidSscenario,      NonExistingComparator,      NonExistingScenario,      NonExistingScenarioConfig,      SequenceTaskConfigDoesNotExistInSameScenarioConfig,      UnauthorizedTagError,  )  from ..job._job_manager_factory import _JobManagerFactory  from ..job.job import Job  from ..notification import EventEntityType, EventOperation, Notifier, _make_event  from ..submission._submission_manager_factory import _SubmissionManagerFactory  from ..task._task_manager_factory import _TaskManagerFactory  from .scenario import Scenario  from .scenario_id import ScenarioId      class _ScenarioManager(_Manager[Scenario], _VersionMixin):      _AUTHORIZED_TAGS_KEY = \"authorized_tags\"      _ENTITY_NAME = Scenario.__name__      _EVENT_ENTITY_TYPE = EventEntityType.SCENARIO        _repository: _AbstractRepository        @classmethod      def _get_all(cls, version_number: Optional[str] = None) -> List[Scenario]:          \"\"\"          Returns all entities.          \"\"\"          filters = cls._build_filters_with_version(version_number)          return cls._repository._load_all(filters)        @classmethod      def _subscribe(          cls,          callback: Callable[[Scenario, Job], None],          params: Optional[List[Any]] = None,          scenario: Optional[Scenario] = None,      ):          if scenario is None:              scenarios = cls._get_all()              for scn in scenarios:                  cls.__add_subscriber(callback, params, scn)              return            cls.__add_subscriber(callback, params, scenario)        @classmethod      def _unsubscribe(          cls,          callback: Callable[[Scenario, Job], None],          params: Optional[List[Any]] = None,          scenario: Optional[Scenario] = None,      ):          if scenario is None:              scenarios = cls._get_all()              for scn in scenarios:                  cls.__remove_subscriber(callback, params, scn)              return            cls.__remove_subscriber(callback, params, scenario)        @classmethod      def __add_subscriber(cls, callback, params, scenario: Scenario):          scenario._add_subscriber(callback, params)          Notifier.publish(              _make_event(scenario, EventOperation.UPDATE, attribute_name=\"subscribers\", attribute_value=params)          )        @classmethod      def __remove_subscriber(cls, callback, params, scenario: Scenario):          scenario._remove_subscriber(callback, params)          Notifier.publish(              _make_event(scenario, EventOperation.UPDATE, attribute_name=\"subscribers\", attribute_value=params)          )        @classmethod      def _create(          cls,          config: ScenarioConfig,          creation_date: Optional[datetime.datetime] = None,          name: Optional[str] = None,      ) -> Scenario:          _task_manager = _TaskManagerFactory._build_manager()          _data_manager = _DataManagerFactory._build_manager()            scenario_id = Scenario._new_id(str(config.id))          cycle = (              _CycleManagerFactory._build_manager()._get_or_create(config.frequency, creation_date)              if config.frequency              else None          )          cycle_id = cycle.id if cycle else None          tasks = (              _task_manager._bulk_get_or_create(config.task_configs, cycle_id, scenario_id) if config.task_configs else []          )          additional_data_nodes = (              _data_manager._bulk_get_or_create(config.additional_data_node_configs, cycle_id, scenario_id)              if config.additional_data_node_configs              else {}          )            sequences = {}          tasks_and_config_id_maps = {task.config_id: task for task in tasks}          for sequence_name, sequence_task_configs in config.sequences.items():              sequence_tasks = []              non_existing_sequence_task_config_in_scenario_config = set()              for sequence_task_config in sequence_task_configs:                  if task := tasks_and_config_id_maps.get(sequence_task_config.id):                      sequence_tasks.append(task)                  else:                      non_existing_sequence_task_config_in_scenario_config.add(sequence_task_config.id)              if len(non_existing_sequence_task_config_in_scenario_config) > 0:                  raise SequenceTaskConfigDoesNotExistInSameScenarioConfig(                      list(non_existing_sequence_task_config_in_scenario_config), sequence_name, str(config.id)                  )              sequences[sequence_name] = {Scenario._SEQUENCE_TASKS_KEY: sequence_tasks}            is_primary_scenario = len(cls._get_all_by_cycle(cycle)) == 0 if cycle else False          props = config._properties.copy()          if name:              props[\"name\"] = name          version = cls._get_latest_version()            scenario = Scenario(              config_id=str(config.id),              tasks=set(tasks),              properties=props,              additional_data_nodes=set(additional_data_nodes.values()),              scenario_id=scenario_id,              creation_date=creation_date,              is_primary=is_primary_scenario,              cycle=cycle,              version=version,              sequences=sequences,          )            for task in tasks:              if scenario_id not in task._parent_ids:                  task._parent_ids.update([scenario_id])                  _task_manager._set(task)            for dn in additional_data_nodes.values():              if scenario_id not in dn._parent_ids:                  dn._parent_ids.update([scenario_id])                  _data_manager._set(dn)            cls._set(scenario)            if not scenario._is_consistent():              raise InvalidSscenario(scenario.id)            actual_sequences = scenario._get_sequences()          for sequence_name in sequences.keys():              if not actual_sequences[sequence_name]._is_consistent():                  raise InvalidSequence(actual_sequences[sequence_name].id)              Notifier.publish(_make_event(actual_sequences[sequence_name], EventOperation.CREATION))            Notifier.publish(_make_event(scenario, EventOperation.CREATION))          return scenario        @classmethod      def _is_submittable(cls, scenario: Union[Scenario, ScenarioId]) -> bool:          if isinstance(scenario, str):              scenario = cls._get(scenario)          return isinstance(scenario, Scenario) and scenario.is_ready_to_run()        @classmethod      def _submit(          cls,          scenario: Union[Scenario, ScenarioId],          callbacks: Optional[List[Callable]] = None,          force: bool = False,          wait: bool = False,          timeout: Optional[Union[float, int]] = None,          check_inputs_are_ready: bool = True,      ) -> List[Job]:          scenario_id = scenario.id if isinstance(scenario, Scenario) else scenario          scenario = cls._get(scenario_id)          if scenario is None:              raise NonExistingScenario(scenario_id)          callbacks = callbacks or []          scenario_subscription_callback = cls.__get_status_notifier_callbacks(scenario) + callbacks          if check_inputs_are_ready:              _warn_if_inputs_not_ready(scenario.get_inputs())            jobs = (              _TaskManagerFactory._build_manager()              ._orchestrator()              .submit(scenario, callbacks=scenario_subscription_callback, force=force, wait=wait, timeout=timeout)          )          Notifier.publish(_make_event(scenario, EventOperation.SUBMISSION))          return jobs        @classmethod      def __get_status_notifier_callbacks(cls, scenario: Scenario) -> List:          return [partial(c.callback, *c.params, scenario) for c in scenario.subscribers]        @classmethod      def _get_primary(cls, cycle: Cycle) -> Optional[Scenario]:          scenarios = cls._get_all_by_cycle(cycle)          for scenario in scenarios:              if scenario.is_primary:                  return scenario          return None        @classmethod      def _get_by_tag(cls, cycle: Cycle, tag: str) -> Optional[Scenario]:          scenarios = cls._get_all_by_cycle(cycle)          for scenario in scenarios:              if scenario.has_tag(tag):                  return scenario          return None        @classmethod      def _get_all_by_tag(cls, tag: str) -> List[Scenario]:          scenarios = []          for scenario in cls._get_all():              if scenario.has_tag(tag):                  scenarios.append(scenario)          return scenarios        @classmethod      def _get_all_by_cycle(cls, cycle: Cycle) -> List[Scenario]:          filters = cls._build_filters_with_version(\"all\")            if not filters:              filters = [{}]          for fil in filters:              fil.update({\"cycle\": cycle.id})          return cls._get_all_by(filters)        @classmethod      def _get_primary_scenarios(cls) -> List[Scenario]:          primary_scenarios = []          for scenario in cls._get_all():              if scenario.is_primary:                  primary_scenarios.append(scenario)          return primary_scenarios        @classmethod      def _is_promotable_to_primary(cls, scenario: Union[Scenario, ScenarioId]) -> bool:          if isinstance(scenario, str):              scenario = cls._get(scenario)          if scenario and not scenario.is_primary and scenario.cycle:              return True          return False        @classmethod      def _set_primary(cls, scenario: Scenario):          if scenario.cycle:              primary_scenario = cls._get_primary(scenario.cycle)              # To prevent SAME scenario updating out of Context Manager              if primary_scenario and primary_scenario != scenario:                  primary_scenario.is_primary = False  # type: ignore              scenario.is_primary = True  # type: ignore          else:              raise DoesNotBelongToACycle(                  f\"Can't set scenario {scenario.id} to primary because it doesn't belong to a cycle.\"              )        @classmethod      def _tag(cls, scenario: Scenario, tag: str):          tags = scenario.properties.get(cls._AUTHORIZED_TAGS_KEY, set())          if len(tags) > 0 and tag not in tags:              raise UnauthorizedTagError(f\"Tag `{tag}` not authorized by scenario configuration `{scenario.config_id}`\")          if scenario.cycle:              old_tagged_scenario = cls._get_by_tag(scenario.cycle, tag)              if old_tagged_scenario:                  old_tagged_scenario.remove_tag(tag)                  cls._set(old_tagged_scenario)          scenario._add_tag(tag)          cls._set(scenario)          Notifier.publish(              _make_event(scenario, EventOperation.UPDATE, attribute_name=\"tags\", attribute_value=scenario.tags)          )        @classmethod      def _untag(cls, scenario: Scenario, tag: str):          scenario._remove_tag(tag)          cls._set(scenario)          Notifier.publish(              _make_event(scenario, EventOperation.UPDATE, attribute_name=\"tags\", attribute_value=scenario.tags)          )        @classmethod      def _compare(cls, *scenarios: Scenario, data_node_config_id: Optional[str] = None):          if len(scenarios) < 2:              raise InsufficientScenarioToCompare(\"At least two scenarios are required to compare.\")            if not all(scenarios[0].config_id == scenario.config_id for scenario in scenarios):              raise DifferentScenarioConfigs(\"Scenarios to compare must have the same configuration.\")            if scenario_config := _ScenarioManager.__get_config(scenarios[0]):              results = {}              if data_node_config_id:                  if data_node_config_id in scenario_config.comparators.keys():                      dn_comparators = {data_node_config_id: scenario_config.comparators[data_node_config_id]}                  else:                      raise NonExistingComparator(f\"Data node config {data_node_config_id} has no comparator.\")              else:                  dn_comparators = scenario_config.comparators                for data_node_config_id, comparators in dn_comparators.items():                  data_nodes = [scenario.__getattr__(data_node_config_id).read() for scenario in scenarios]                  results[data_node_config_id] = {                      comparator.__name__: comparator(*data_nodes) for comparator in comparators                  }                return results            else:              raise NonExistingScenarioConfig(scenarios[0].config_id)        @staticmethod      def __get_config(scenario: Scenario):          return Config.scenarios.get(scenario.config_id, None)        @classmethod      def _is_deletable(cls, scenario: Union[Scenario, ScenarioId]) -> bool:          if isinstance(scenario, str):              scenario = cls._get(scenario)          if scenario.is_primary:              if len(cls._get_all_by_cycle(scenario.cycle)) > 1:                  return False          return True        @classmethod      def _delete(cls, scenario_id: ScenarioId):          scenario = cls._get(scenario_id)          if not cls._is_deletable(scenario):              raise DeletingPrimaryScenario(                  f\"Scenario {scenario.id}, which has config id {scenario.config_id}, is primary and there are \"                  f\"other scenarios in the same cycle. \"              )          if scenario.is_primary:              _CycleManagerFactory._build_manager()._delete(scenario.cycle.id)          super()._delete(scenario_id)        @classmethod      def _hard_delete(cls, scenario_id: ScenarioId):          scenario = cls._get(scenario_id)          if not cls._is_deletable(scenario):              raise DeletingPrimaryScenario(                  f\"Scenario {scenario.id}, which has config id {scenario.config_id}, is primary and there are \"                  f\"other scenarios in the same cycle. \"              )          if scenario.is_primary:              _CycleManagerFactory._build_manager()._hard_delete(scenario.cycle.id)          else:              entity_ids_to_delete = cls._get_children_entity_ids(scenario)              entity_ids_to_delete.scenario_ids.add(scenario.id)              cls._delete_entities_of_multiple_types(entity_ids_to_delete)        @classmethod      def _delete_by_version(cls, version_number: str):          \"\"\"          Deletes scenario by the version number.            Check if the cycle is only attached to this scenario, then delete it.          \"\"\"          for scenario in cls._repository._search(\"version\", version_number):              if scenario.cycle and len(cls._get_all_by_cycle(scenario.cycle)) == 1:                  _CycleManagerFactory._build_manager()._delete(scenario.cycle.id)              super()._delete(scenario.id)        @classmethod      def _get_children_entity_ids(cls, scenario: Scenario) -> _EntityIds:          entity_ids = _EntityIds()          for sequence in scenario.sequences.values():              if sequence.owner_id == scenario.id:                  entity_ids.sequence_ids.add(sequence.id)          for task in scenario.tasks.values():              if task.owner_id == scenario.id:                  entity_ids.task_ids.add(task.id)          for data_node in scenario.data_nodes.values():              if data_node.owner_id == scenario.id:                  entity_ids.data_node_ids.add(data_node.id)            jobs = _JobManagerFactory._build_manager()._get_all()          for job in jobs:              if job.task.id in entity_ids.task_ids:                  entity_ids.job_ids.add(job.id)            submissions = _SubmissionManagerFactory._build_manager()._get_all()          submitted_entity_ids = list(entity_ids.scenario_ids.union(entity_ids.sequence_ids, entity_ids.task_ids))          for submission in submissions:              if submission.entity_id in submitted_entity_ids:                  entity_ids.submission_ids.add(submission.id)            return entity_ids        @classmethod      def _get_by_config_id(cls, config_id: str, version_number: Optional[str] = None) -> List[Scenario]:          \"\"\"          Get all scenarios by its config id.          \"\"\"          filters = cls._build_filters_with_version(version_number)          if not filters:              filters = [{}]          for fil in filters:              fil.update({\"config_id\": config_id})          return cls._repository._load_all(filters) "}
{"text": "#  # Licensed under the Apache License, Version 2.0 (the \"License\"); you may not use this file except in compliance with  # the License. You may obtain a copy of the License at  #  #        http://www.apache.org/licenses/LICENSE-2.0  #  # Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on  # an \"AS IS\" BASIS, WITHOUT 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": "import itertools  from datetime import datetime  from multiprocessing import Lock  from queue import Queue  from time import sleep  from typing import Callable, Iterable, List, Optional, Set, Union    from taipy.config.config import Config  from taipy.logger._taipy_logger import _TaipyLogger    from .._entity.submittable import Submittable  from ..data._data_manager_factory import _DataManagerFactory  from ..job._job_manager_factory import _JobManagerFactory  from ..job.job import Job  from ..job.job_id import JobId  from ..submission._submission_manager_factory import _SubmissionManagerFactory  from ..task.task import Task  from ._abstract_orchestrator import _AbstractOrchestrator      class _Orchestrator(_AbstractOrchestrator):      \"\"\"      Handles the functional orchestrating.      \"\"\"        jobs_to_run: Queue = Queue()      blocked_jobs: List = []      lock = Lock()      __logger = _TaipyLogger._get_logger()        @classmethod      def initialize(cls):          pass        @classmethod      def submit(          cls,          submittable: Submittable,          callbacks: Optional[Iterable[Callable]] = None,          force: bool = False,          wait: bool = False,          timeout: Optional[Union[float, int]] = None,      ) -> List[Job]:          \"\"\"Submit the given `Scenario^` or `Sequence^` for an execution.            Parameters:               submittable (Union[SCenario^, Sequence^]): The scenario or sequence to submit for execution.               callbacks: The optional list of functions that should be executed on jobs status change.               force (bool) : Enforce execution of the scenario's or sequence's tasks even if their output data                  nodes are cached.               wait (bool): Wait for the orchestrated jobs created from the scenario or sequence submission to be                  finished in asynchronous mode.               timeout (Union[float, int]): The optional maximum number of seconds to wait for the jobs to be finished                  before returning.          Returns:              The created Jobs.          \"\"\"          submission = _SubmissionManagerFactory._build_manager()._create(              submittable.id, submittable._ID_PREFIX  # type: ignore          )            jobs = []          tasks = submittable._get_sorted_tasks()          with cls.lock:              for ts in tasks:                  for task in ts:                      jobs.append(                          cls._lock_dn_output_and_create_job(                              task,                              submission.id,                              submission.entity_id,                              callbacks=itertools.chain([submission._update_submission_status], callbacks or []),                              force=force,  # type: ignore                          )                      )            submission.jobs = jobs  # type: ignore            cls._orchestrate_job_to_run_or_block(jobs)            if Config.job_config.is_development:              cls._check_and_execute_jobs_if_development_mode()          else:              if wait:                  cls.__wait_until_job_finished(jobs, timeout=timeout)            return jobs        @classmethod      def submit_task(          cls,          task: Task,          callbacks: Optional[Iterable[Callable]] = None,          force: bool = False,          wait: bool = False,          timeout: Optional[Union[float, int]] = None,      ) -> Job:          \"\"\"Submit the given `Task^` for an execution.            Parameters:               task (Task^): The task to submit for execution.               submit_id (str): The optional id to differentiate each submission.               callbacks: The optional list of functions that should be executed on job status change.               force (bool): Enforce execution of the task even if its output data nodes are cached.               wait (bool): Wait for the orchestrated job created from the task submission to be finished                  in asynchronous mode.               timeout (Union[float, int]): The optional maximum number of seconds to wait for the job                  to be finished before returning.          Returns:              The created `Job^`.          \"\"\"          submission = _SubmissionManagerFactory._build_manager()._create(task.id, task._ID_PREFIX)          submit_id = submission.id          with cls.lock:              job = cls._lock_dn_output_and_create_job(                  task,                  submit_id,                  submission.entity_id,                  itertools.chain([submission._update_submission_status], callbacks or []),                  force,              )            jobs = [job]          submission.jobs = jobs  # type: ignore            cls._orchestrate_job_to_run_or_block(jobs)            if Config.job_config.is_development:              cls._check_and_execute_jobs_if_development_mode()          else:              if wait:                  cls.__wait_until_job_finished(job, timeout=timeout)            return job        @classmethod      def _lock_dn_output_and_create_job(          cls,          task: Task,          submit_id: str,          submit_entity_id: str,          callbacks: Optional[Iterable[Callable]] = None,          force: bool = False,      ) -> Job:          for dn in task.output.values():              dn.lock_edit()          job = _JobManagerFactory._build_manager()._create(              task, itertools.chain([cls._on_status_change], callbacks or []), submit_id, submit_entity_id, force=force          )            return job        @classmethod      def _orchestrate_job_to_run_or_block(cls, jobs: List[Job]):          blocked_jobs = []          pending_jobs = []            for job in jobs:              if cls._is_blocked(job):                  job.blocked()                  blocked_jobs.append(job)              else:                  job.pending()                  pending_jobs.append(job)            cls.blocked_jobs.extend(blocked_jobs)          for job in pending_jobs:              cls.jobs_to_run.put(job)        @classmethod      def __wait_until_job_finished(cls, jobs: Union[List[Job], Job], timeout: Optional[Union[float, int]] = None):          def __check_if_timeout(start, timeout):              if timeout:                  return (datetime.now() - start).seconds < timeout              return True            start = datetime.now()          jobs = jobs if isinstance(jobs, Iterable) else [jobs]          index = 0            while __check_if_timeout(start, timeout) and index < len(jobs):              try:                  if jobs[index]._is_finished():                      index = index + 1                  else:                      sleep(0.5)  # Limit CPU usage                except Exception:                  pass        @classmethod      def _is_blocked(cls, obj: Union[Task, Job]) -> bool:          \"\"\"Returns True if the execution of the `Job^` or the `Task^` is blocked by the execution of another `Job^`.            Parameters:               obj (Union[Task^, Job^]): The job or task entity to run.            Returns:               True if one of its input data nodes is blocked.          \"\"\"          input_data_nodes = obj.task.input.values() if isinstance(obj, Job) else obj.input.values()          data_manager = _DataManagerFactory._build_manager()          return any(not data_manager._get(dn.id).is_ready_for_reading for dn in input_data_nodes)        @staticmethod      def _unlock_edit_on_jobs_outputs(jobs: Union[Job, List[Job], Set[Job]]):          jobs = [jobs] if isinstance(jobs, Job) else jobs          for job in jobs:              job._unlock_edit_on_outputs()        @classmethod      def _on_status_change(cls, job: Job):          if job.is_completed() or job.is_skipped():              cls.__unblock_jobs()          elif job.is_failed():              cls._fail_subsequent_jobs(job)        @classmethod      def __unblock_jobs(cls):          for job in cls.blocked_jobs:              if not cls._is_blocked(job):                  with cls.lock:                      job.pending()                      cls.__remove_blocked_job(job)                      cls.jobs_to_run.put(job)        @classmethod      def __remove_blocked_job(cls, job):          try:  # In case the job has been removed from the list of blocked_jobs.              cls.blocked_jobs.remove(job)          except Exception:              cls.__logger.warning(f\"{job.id} is not in the blocked list anymore.\")        @classmethod      def cancel_job(cls, job: Job):          if job.is_canceled():              cls.__logger.info(f\"{job.id} has already been canceled.\")          elif job.is_abandoned():              cls.__logger.info(f\"{job.id} has already been abandoned and cannot be canceled.\")          elif job.is_failed():              cls.__logger.info(f\"{job.id} has already failed and cannot be canceled.\")          else:              with cls.lock:                  to_cancel_or_abandon_jobs = set([job])                  to_cancel_or_abandon_jobs.update(cls.__find_subsequent_jobs(job.submit_id, set(job.task.output.keys())))                  cls.__remove_blocked_jobs(to_cancel_or_abandon_jobs)                  cls.__remove_jobs_to_run(to_cancel_or_abandon_jobs)                  cls._cancel_jobs(job.id, to_cancel_or_abandon_jobs)                  cls._unlock_edit_on_jobs_outputs(to_cancel_or_abandon_jobs)        @classmethod      def __find_subsequent_jobs(cls, submit_id, output_dn_config_ids: Set) -> Set[Job]:          next_output_dn_config_ids = set()          subsequent_jobs = set()          for job in cls.blocked_jobs:              job_input_dn_config_ids = job.task.input.keys()              if job.submit_id == submit_id and len(output_dn_config_ids.intersection(job_input_dn_config_ids)) > 0:                  next_output_dn_config_ids.update(job.task.output.keys())                  subsequent_jobs.update([job])          if len(next_output_dn_config_ids) > 0:              subsequent_jobs.update(                  cls.__find_subsequent_jobs(submit_id, output_dn_config_ids=next_output_dn_config_ids)              )          return subsequent_jobs        @classmethod      def __remove_blocked_jobs(cls, jobs):          for job in jobs:              cls.__remove_blocked_job(job)        @classmethod      def __remove_jobs_to_run(cls, jobs):          new_jobs_to_run: Queue = Queue()          while not cls.jobs_to_run.empty():              current_job = cls.jobs_to_run.get()              if current_job not in jobs:                  new_jobs_to_run.put(current_job)          cls.jobs_to_run = new_jobs_to_run        @classmethod      def _fail_subsequent_jobs(cls, failed_job: Job):          with cls.lock:              to_fail_or_abandon_jobs = set()              to_fail_or_abandon_jobs.update(                  cls.__find_subsequent_jobs(failed_job.submit_id, set(failed_job.task.output.keys()))              )              for job in to_fail_or_abandon_jobs:                  job.abandoned()              to_fail_or_abandon_jobs.update([failed_job])              cls.__remove_blocked_jobs(to_fail_or_abandon_jobs)              cls.__remove_jobs_to_run(to_fail_or_abandon_jobs)              cls._unlock_edit_on_jobs_outputs(to_fail_or_abandon_jobs)        @classmethod      def _cancel_jobs(cls, job_id_to_cancel: JobId, jobs: Set[Job]):          from ._orchestrator_factory import _OrchestratorFactory            for job in jobs:              if job.id in _OrchestratorFactory._dispatcher._dispatched_processes.keys():  # type: ignore                  cls.__logger.info(f\"{job.id} is running and cannot be canceled.\")              elif job.is_completed():                  cls.__logger.info(f\"{job.id} has already been completed and cannot be canceled.\")              elif job.is_skipped():                  cls.__logger.info(f\"{job.id} has already been skipped and cannot be canceled.\")              else:                  if job_id_to_cancel == job.id:                      job.canceled()                  else:                      job.abandoned()        @staticmethod      def _check_and_execute_jobs_if_development_mode():          from ._orchestrator_factory import _OrchestratorFactory            if dispatcher := _OrchestratorFactory._dispatcher:              dispatcher._execute_jobs_synchronously() "}
{"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": "import uuid  from typing import TYPE_CHECKING, Any, Callable, Dict, Iterable, List, Optional, Set, Union    from taipy.config.common._template_handler import _TemplateHandler as _tpl  from taipy.config.common._validate_id import _validate_id  from taipy.config.common.scope import Scope    from .._entity._entity import _Entity  from .._entity._labeled import _Labeled  from .._entity._properties import _Properties  from .._entity._reload import _Reloader, _self_reload, _self_setter  from .._version._version_manager_factory import _VersionManagerFactory  from ..data._data_manager_factory import _DataManagerFactory  from ..data.data_node import DataNode  from ..exceptions.exceptions import NonExistingDataNode  from ..notification.event import Event, EventEntityType, EventOperation, _make_event  from .task_id import TaskId    if TYPE_CHECKING:      from ..job.job import Job      class Task(_Entity, _Labeled):      \"\"\"Hold a user function that will be executed, its parameters and the results.        A `Task` brings together the user code as function, the inputs and the outputs as data nodes      (instances of the `DataNode^` class).        Attributes:          config_id (str): The identifier of the `TaskConfig^`.          properties (dict[str, Any]): A dictionary of additional properties.          function (callable): The python function to execute. The _function_ must take as parameter the              data referenced by inputs data nodes, and must return the data referenced by outputs data nodes.          input (Union[DataNode^, List[DataNode^]]): The list of inputs.          output (Union[DataNode^, List[DataNode^]]): The list of outputs.          id (str): The unique identifier of the task.          owner_id (str):  The identifier of the owner (sequence_id, scenario_id, cycle_id) or None.          parent_ids (Optional[Set[str]]): The set of identifiers of the parent sequences.          version (str): The string indicates the application version of the task to instantiate. If not provided, the              latest version is used.          skippable (bool): If True, indicates that the task can be skipped if no change has been made on inputs. The              default value is _False_.        \"\"\"        _ID_PREFIX = \"TASK\"      __ID_SEPARATOR = \"_\"      _MANAGER_NAME = \"task\"        def __init__(          self,          config_id: str,          properties: Dict[str, Any],          function,          input: Optional[Iterable[DataNode]] = None,          output: Optional[Iterable[DataNode]] = None,          id: Optional[TaskId] = None,          owner_id: Optional[str] = None,          parent_ids: Optional[Set[str]] = None,          version: Optional[str] = None,          skippable: bool = False,      ):          self.config_id = _validate_id(config_id)          self.id = id or TaskId(self.__ID_SEPARATOR.join([self._ID_PREFIX, self.config_id, str(uuid.uuid4())]))          self.owner_id = owner_id          self._parent_ids = parent_ids or set()          self.__input = {dn.config_id: dn for dn in input or []}          self.__output = {dn.config_id: dn for dn in output or []}          self._function = function          self._version = version or _VersionManagerFactory._build_manager()._get_latest_version()          self._skippable = skippable          self._properties = _Properties(self, **properties)        def __hash__(self):          return hash(self.id)        def __eq__(self, other):          return self.id == other.id        def __getstate__(self):          return vars(self)        def __setstate__(self, state):          vars(self).update(state)        def __getattr__(self, attribute_name):          protected_attribute_name = _validate_id(attribute_name)          if protected_attribute_name in self._properties:              return _tpl._replace_templates(self._properties[protected_attribute_name])          if protected_attribute_name in self.input:              return self.input[protected_attribute_name]          if protected_attribute_name in self.output:              return self.output[protected_attribute_name]          raise AttributeError(f\"{attribute_name} is not an attribute of task {self.id}\")        @property      def properties(self):          self._properties = _Reloader()._reload(self._MANAGER_NAME, self)._properties          return self._properties        def get_parents(self):          \"\"\"Get parents of the task.\"\"\"          from ... import core as tp            return tp.get_parents(self)        @property  # type: ignore      @_self_reload(_MANAGER_NAME)      def parent_ids(self):          return self._parent_ids        @property      def input(self) -> Dict[str, DataNode]:          return self.__input        @property      def output(self) -> Dict[str, DataNode]:          return self.__output        @property      def data_nodes(self) -> Dict[str, DataNode]:          return {**self.input, **self.output}        @property  # type: ignore      @_self_reload(_MANAGER_NAME)      def function(self):          return self._function        @function.setter  # type: ignore      @_self_setter(_MANAGER_NAME)      def function(self, val):          self._function = val        @property  # type: ignore      @_self_reload(_MANAGER_NAME)      def skippable(self):          return self._skippable        @skippable.setter  # type: ignore      @_self_setter(_MANAGER_NAME)      def skippable(self, val):          self._skippable = val        @property      def scope(self) -> Scope:          \"\"\"Retrieve the lowest scope of the task based on its data nodes.            Returns:              The lowest scope present in input and output data nodes or GLOBAL if there are                  either no input or no output.          \"\"\"          data_nodes = list(self.__input.values()) + list(self.__output.values())          scope = Scope(min(dn.scope for dn in data_nodes)) if len(data_nodes) != 0 else Scope.GLOBAL          return scope        @property      def version(self):          return self._version        def submit(          self,          callbacks: Optional[List[Callable]] = None,          force: bool = False,          wait: bool = False,          timeout: Optional[Union[float, int]] = None,      ) -> \"Job\":  # noqa          \"\"\"Submit the task for execution.            Parameters:              callbacks (List[Callable]): The list of callable functions to be called on status                  change.              force (bool): Force execution even if the data nodes are in cache.              wait (bool): Wait for the orchestrated job created from the task submission to be finished in asynchronous                  mode.              timeout (Union[float, int]): The maximum number of seconds to wait for the job to be finished before                  returning.            Returns:              The created `Job^`.          \"\"\"          from ._task_manager_factory import _TaskManagerFactory            return _TaskManagerFactory._build_manager()._submit(self, callbacks, force, wait, timeout)        def get_label(self) -> str:          \"\"\"Returns the task simple label prefixed by its owner label.            Returns:              The label of the task as a string.          \"\"\"          return self._get_label()        def get_simple_label(self) -> str:          \"\"\"Returns the task simple label.            Returns:              The simple label of the task as a string.          \"\"\"          return self._get_simple_label()      @_make_event.register(Task)  def _make_event_for_task(      task: Task,      operation: EventOperation,      /,      attribute_name: Optional[str] = None,      attribute_value: Optional[Any] = None,      **kwargs,  ) -> Event:      metadata = {\"version\": task.version, \"config_id\": task.config_id, **kwargs}      return Event(          entity_type=EventEntityType.TASK,          entity_id=task.id,          operation=operation,          attribute_name=attribute_name,          attribute_value=attribute_value,          metadata=metadata,      ) "}
{"text": "from typing import Callable, List, Optional, Type, Union    from taipy.config import Config  from taipy.config.common.scope import Scope    from .._entity._entity_ids import _EntityIds  from .._manager._manager import _Manager  from .._orchestrator._abstract_orchestrator import _AbstractOrchestrator  from .._repository._abstract_repository import _AbstractRepository  from .._version._version_manager_factory import _VersionManagerFactory  from .._version._version_mixin import _VersionMixin  from ..common.warn_if_inputs_not_ready import _warn_if_inputs_not_ready  from ..config.task_config import TaskConfig  from ..cycle.cycle_id import CycleId  from ..data._data_manager_factory import _DataManagerFactory  from ..exceptions.exceptions import NonExistingTask  from ..notification import EventEntityType, EventOperation, Notifier, _make_event  from ..scenario.scenario_id import ScenarioId  from ..sequence.sequence_id import SequenceId  from ..task.task import Task  from .task_id import TaskId      class _TaskManager(_Manager[Task], _VersionMixin):      _ENTITY_NAME = Task.__name__      _repository: _AbstractRepository      _EVENT_ENTITY_TYPE = EventEntityType.TASK        @classmethod      def _orchestrator(cls) -> Type[_AbstractOrchestrator]:          from .._orchestrator._orchestrator_factory import _OrchestratorFactory            return _OrchestratorFactory._build_orchestrator()        @classmethod      def _set(cls, task: Task):          cls.__save_data_nodes(task.input.values())          cls.__save_data_nodes(task.output.values())          super()._set(task)        @classmethod      def _bulk_get_or_create(          cls,          task_configs: List[TaskConfig],          cycle_id: Optional[CycleId] = None,          scenario_id: Optional[ScenarioId] = None,      ) -> List[Task]:          data_node_configs = set()          for task_config in task_configs:              data_node_configs.update([Config.data_nodes[dnc.id] for dnc in task_config.input_configs])              data_node_configs.update([Config.data_nodes[dnc.id] for dnc in task_config.output_configs])            data_nodes = _DataManagerFactory._build_manager()._bulk_get_or_create(              list(data_node_configs), cycle_id, scenario_id          )          tasks_configs_and_owner_id = []          for task_config in task_configs:              task_dn_configs = [Config.data_nodes[dnc.id] for dnc in task_config.output_configs] + [                  Config.data_nodes[dnc.id] for dnc in task_config.input_configs              ]              task_config_data_nodes = [data_nodes[dn_config] for dn_config in task_dn_configs]              scope = min(dn.scope for dn in task_config_data_nodes) if len(task_config_data_nodes) != 0 else Scope.GLOBAL              owner_id: Union[Optional[SequenceId], Optional[ScenarioId], Optional[CycleId]]              if scope == Scope.SCENARIO:                  owner_id = scenario_id              elif scope == Scope.CYCLE:                  owner_id = cycle_id              else:                  owner_id = None                tasks_configs_and_owner_id.append((task_config, owner_id))            tasks_by_config = cls._repository._get_by_configs_and_owner_ids(  # type: ignore              tasks_configs_and_owner_id, cls._build_filters_with_version(None)          )            tasks = []          for task_config, owner_id in tasks_configs_and_owner_id:              if task := tasks_by_config.get((task_config, owner_id)):                  tasks.append(task)              else:                  version = _VersionManagerFactory._build_manager()._get_latest_version()                  inputs = [                      data_nodes[input_config]                      for input_config in [Config.data_nodes[dnc.id] for dnc in task_config.input_configs]                  ]                  outputs = [                      data_nodes[output_config]                      for output_config in [Config.data_nodes[dnc.id] for dnc in task_config.output_configs]                  ]                  skippable = task_config.skippable                  task = Task(                      str(task_config.id),                      dict(**task_config._properties),                      task_config.function,                      inputs,                      outputs,                      owner_id=owner_id,                      parent_ids=set(),                      version=version,                      skippable=skippable,                  )                  for dn in set(inputs + outputs):                      dn._parent_ids.update([task.id])                  cls._set(task)                  Notifier.publish(_make_event(task, EventOperation.CREATION))                  tasks.append(task)          return tasks        @classmethod      def _get_all(cls, version_number: Optional[str] = None) -> List[Task]:          \"\"\"          Returns all entities.          \"\"\"          filters = cls._build_filters_with_version(version_number)          return cls._repository._load_all(filters)        @classmethod      def __save_data_nodes(cls, data_nodes):          data_manager = _DataManagerFactory._build_manager()          for i in data_nodes:              data_manager._set(i)        @classmethod      def _hard_delete(cls, task_id: TaskId):          task = cls._get(task_id)          entity_ids_to_delete = cls._get_children_entity_ids(task)          entity_ids_to_delete.task_ids.add(task.id)          cls._delete_entities_of_multiple_types(entity_ids_to_delete)        @classmethod      def _get_children_entity_ids(cls, task: Task):          entity_ids = _EntityIds()            from ..job._job_manager_factory import _JobManagerFactory          from ..submission._submission_manager_factory import _SubmissionManagerFactory            jobs = _JobManagerFactory._build_manager()._get_all()            for job in jobs:              if job.task.id == task.id:                  entity_ids.job_ids.add(job.id)            submissions = _SubmissionManagerFactory._build_manager()._get_all()          submitted_entity_ids = list(entity_ids.task_ids)          for submission in submissions:              if submission.entity_id in submitted_entity_ids:                  entity_ids.submission_ids.add(submission.id)            return entity_ids        @classmethod      def _is_submittable(cls, task: Union[Task, TaskId]) -> bool:          if isinstance(task, str):              task = cls._get(task)          return isinstance(task, Task) and all(input_dn.is_ready_for_reading for input_dn in task.input.values())        @classmethod      def _submit(          cls,          task: Union[TaskId, Task],          callbacks: Optional[List[Callable]] = None,          force: bool = False,          wait: bool = False,          timeout: Optional[Union[float, int]] = None,          check_inputs_are_ready: bool = True,      ):          task_id = task.id if isinstance(task, Task) else task          task = cls._get(task_id)          if task is None:              raise NonExistingTask(task_id)          if check_inputs_are_ready:              _warn_if_inputs_not_ready(task.input.values())          job = cls._orchestrator().submit_task(task, callbacks=callbacks, force=force, wait=wait, timeout=timeout)          Notifier.publish(_make_event(task, EventOperation.SUBMISSION))          return job        @classmethod      def _get_by_config_id(cls, config_id: str, version_number: Optional[str] = None) -> List[Task]:          \"\"\"          Get all tasks by its config id.          \"\"\"          filters = cls._build_filters_with_version(version_number)          if not filters:              filters = [{}]          for fil in filters:              fil.update({\"config_id\": config_id})          return cls._repository._load_all(filters) "}
{"text": "#  # Licensed under the Apache License, Version 2.0 (the \"License\"); you may not use this file except in compliance with  # the License. You may obtain a copy of the License at  #  #        http://www.apache.org/licenses/LICENSE-2.0  #  # Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on  # an \"AS IS\" BASIS, WITHOUT 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": "__all__ = [\"Job\"]    import traceback  from datetime import datetime  from typing import Any, Callable, List, Optional    from taipy.logger._taipy_logger import _TaipyLogger    from .._entity._entity import _Entity  from .._entity._labeled import _Labeled  from .._entity._reload import _self_reload, _self_setter  from .._version._version_manager_factory import _VersionManagerFactory  from ..common._utils import _fcts_to_dict  from ..notification.event import Event, EventEntityType, EventOperation, _make_event  from ..task.task import Task  from .job_id import JobId  from .status import Status      def _run_callbacks(fn):      def __run_callbacks(job):          fn(job)          for fct in job._subscribers:              fct(job)        return __run_callbacks      class Job(_Entity, _Labeled):      \"\"\"Execution of a `Task^`.        A job handles the status of the execution, contains the stacktrace of exceptions that were      raised during the execution, and notifies subscribers on status change.        Attributes:          id (str): The identifier of this job.          task (Task^): The task of this job.          force (bool): Enforce the job's execution whatever the output data nodes are in cache or              not.          status (Status^): The current status of this job.          creation_date (datetime): The date of this job's creation.          stacktrace (List[str]): The list of stacktraces of the exceptions raised during the execution.          version (str): The string indicates the application version of the job to instantiate. If not provided,              the latest version is used.      \"\"\"        _MANAGER_NAME = \"job\"      _ID_PREFIX = \"JOB\"        def __init__(self, id: JobId, task: Task, submit_id: str, submit_entity_id: str, force=False, version=None):          self.id = id          self._task = task          self._force = force          self._status = Status.SUBMITTED          self._creation_date = datetime.now()          self._submit_id: str = submit_id          self._submit_entity_id: str = submit_entity_id          self._subscribers: List[Callable] = []          self._stacktrace: List[str] = []          self.__logger = _TaipyLogger._get_logger()          self._version = version or _VersionManagerFactory._build_manager()._get_latest_version()        def get_event_context(self):          return {\"task_config_id\": self._task.config_id}        @property  # type: ignore      @_self_reload(_MANAGER_NAME)      def task(self):          return self._task        @task.setter  # type: ignore      @_self_setter(_MANAGER_NAME)      def task(self, val):          self._task = val        @property      def owner_id(self) -> str:          return self.task.id        @property  # type: ignore      @_self_reload(_MANAGER_NAME)      def force(self):          return self._force        @force.setter  # type: ignore      @_self_setter(_MANAGER_NAME)      def force(self, val):          self._force = val        @property      def submit_id(self):          return self._submit_id        @property      def submit_entity_id(self):          return self._submit_entity_id        @property  # type: ignore      def submit_entity(self):          from ..taipy import get as tp_get            return tp_get(self._submit_entity_id)        @property  # type: ignore      @_self_reload(_MANAGER_NAME)      def status(self):          return self._status        @status.setter  # type: ignore      @_self_setter(_MANAGER_NAME)      def status(self, val):          self._status = val        @property  # type: ignore      @_self_reload(_MANAGER_NAME)      def creation_date(self):          return self._creation_date        @creation_date.setter  # type: ignore      @_self_setter(_MANAGER_NAME)      def creation_date(self, val):          self._creation_date = val        @property      def stacktrace(self) -> List[str]:          return self._stacktrace        @property      def version(self):          return self._version        def __contains__(self, task: Task):          return self.task.id == task.id        def __lt__(self, other):          return self.creation_date.timestamp() < other.creation_date.timestamp()        def __le__(self, other):          return self.creation_date.timestamp() <= other.creation_date.timestamp()        def __gt__(self, other):          return self.creation_date.timestamp() > other.creation_date.timestamp()        def __ge__(self, other):          return self.creation_date.timestamp() >= other.creation_date.timestamp()        def __eq__(self, other):          return self.id == other.id        @_run_callbacks      def blocked(self):          \"\"\"Set the status to _blocked_ and notify subscribers.\"\"\"          self.status = Status.BLOCKED        @_run_callbacks      def pending(self):          \"\"\"Set the status to _pending_ and notify subscribers.\"\"\"          self.status = Status.PENDING        @_run_callbacks      def running(self):          \"\"\"Set the status to _running_ and notify subscribers.\"\"\"          self.status = Status.RUNNING        @_run_callbacks      def canceled(self):          \"\"\"Set the status to _canceled_ and notify subscribers.\"\"\"          self.status = Status.CANCELED        @_run_callbacks      def abandoned(self):          \"\"\"Set the status to _abandoned_ and notify subscribers.\"\"\"          self.status = Status.ABANDONED        @_run_callbacks      def failed(self):          \"\"\"Set the status to _failed_ and notify subscribers.\"\"\"          self.status = Status.FAILED        @_run_callbacks      def completed(self):          \"\"\"Set the status to _completed_ and notify subscribers.\"\"\"          self.status = Status.COMPLETED        @_run_callbacks      def skipped(self):          \"\"\"Set the status to _skipped_ and notify subscribers.\"\"\"          self.status = Status.SKIPPED        def is_failed(self) -> bool:          \"\"\"Indicate if the job has failed.            Returns:              True if the job has failed.          \"\"\"          return self.status == Status.FAILED        def is_blocked(self) -> bool:          \"\"\"Indicate if the job is blocked.            Returns:              True if the job is blocked.          \"\"\"          return self.status == Status.BLOCKED        def is_canceled(self) -> bool:          \"\"\"Indicate if the job was canceled.            Returns:              True if the job was canceled.          \"\"\"          return self.status == Status.CANCELED        def is_abandoned(self) -> bool:          \"\"\"Indicate if the job was abandoned.            Returns:              True if the job was abandoned.          \"\"\"          return self.status == Status.ABANDONED        def is_submitted(self) -> bool:          \"\"\"Indicate if the job is submitted.            Returns:              True if the job is submitted.          \"\"\"          return self.status == Status.SUBMITTED        def is_completed(self) -> bool:          \"\"\"Indicate if the job has completed.            Returns:              True if the job has completed.          \"\"\"          return self.status == Status.COMPLETED        def is_skipped(self) -> bool:          \"\"\"Indicate if the job was skipped.            Returns:              True if the job was skipped.          \"\"\"          return self.status == Status.SKIPPED        def is_running(self) -> bool:          \"\"\"Indicate if the job is running.            Returns:              True if the job is running.          \"\"\"          return self.status == Status.RUNNING        def is_pending(self) -> bool:          \"\"\"Indicate if the job is pending.            Returns:              True if the job is pending.          \"\"\"          return self.status == Status.PENDING        def is_finished(self) -> bool:          \"\"\"Indicate if the job is finished.            Returns:              True if the job is finished.          \"\"\"          return self.is_completed() or self.is_failed() or self.is_canceled() or self.is_skipped() or self.is_abandoned()        def _is_finished(self) -> bool:          \"\"\"Indicate if the job is finished. This function will not triggered the persistency feature like is_finished().            Returns:              True if the job is finished.          \"\"\"          return self._status in [Status.COMPLETED, Status.FAILED, Status.CANCELED, Status.SKIPPED, Status.ABANDONED]        def _on_status_change(self, *functions):          \"\"\"Get a notification when the status of the job changes.            Job are assigned different statuses (_submitted_, _pending_, etc.) before being finished.          You can be triggered on each change through this function except for the _submitted_          status.            Parameters:              functions: Callables that will be called on each status change.          \"\"\"          functions = list(functions)          function = functions.pop()          self._subscribers.append(function)            if self.status != Status.SUBMITTED:              function(self)            if functions:              self._on_status_change(*functions)        def update_status(self, exceptions):          \"\"\"Update the job status based on the success or the failure of its execution.\"\"\"          if exceptions:              self.failed()              self.__logger.error(f\" {len(exceptions)} errors occurred during execution of job {self.id}\")              for e in exceptions:                  st = \"\".join(traceback.format_exception(type(e), value=e, tb=e.__traceback__))                  self._stacktrace.append(st)                  self.__logger.error(st)          else:              self.completed()              self.__logger.info(f\"job {self.id} is completed.\")        def __hash__(self):          return hash(self.id)        def _unlock_edit_on_outputs(self):          for dn in self.task.output.values():              dn.unlock_edit()        @staticmethod      def _serialize_subscribers(subscribers: List) -> List:          return _fcts_to_dict(subscribers)        def get_label(self) -> str:          \"\"\"Returns the job simple label prefixed by its owner label.            Returns:              The label of the job as a string.          \"\"\"          return self._get_label()        def get_simple_label(self) -> str:          \"\"\"Returns the job simple label.            Returns:              The simple label of the job as a string.          \"\"\"          return self._get_simple_label()        def is_deletable(self) -> bool:          \"\"\"Indicate if the job can be deleted.            Returns:              True if the job can be deleted. False otherwise.          \"\"\"          from ... import core as tp            return tp.is_deletable(self)      @_make_event.register(Job)  def _make_event_for_job(      job: Job,      operation: EventOperation,      /,      attribute_name: Optional[str] = None,      attribute_value: Optional[Any] = None,      **kwargs,  ) -> Event:      metadata = {          \"creation_date\": job._creation_date,          \"task_config_id\": job._task.config_id,          \"version\": job._version,          **kwargs,      }      return Event(          entity_type=EventEntityType.JOB,          entity_id=job.id,          operation=operation,          attribute_name=attribute_name,          attribute_value=attribute_value,          metadata=metadata,      ) "}
{"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": "import json  import pathlib  from functools import partial  from typing import Any, Callable, Dict, Iterable, List, Optional, Tuple, Union    from .._entity._entity_ids import _EntityIds  from .._manager._manager import _Manager  from .._version._version_mixin import _VersionMixin  from ..common._utils import _Subscriber  from ..common.warn_if_inputs_not_ready import _warn_if_inputs_not_ready  from ..exceptions.exceptions import (      InvalidSequenceId,      ModelNotFound,      NonExistingSequence,      NonExistingTask,      SequenceBelongsToNonExistingScenario,  )  from ..job._job_manager_factory import _JobManagerFactory  from ..job.job import Job  from ..notification import Event, EventEntityType, EventOperation, Notifier  from ..notification.event import _make_event  from ..scenario._scenario_manager_factory import _ScenarioManagerFactory  from ..scenario.scenario import Scenario  from ..scenario.scenario_id import ScenarioId  from ..submission._submission_manager_factory import _SubmissionManagerFactory  from ..task._task_manager_factory import _TaskManagerFactory  from ..task.task import Task, TaskId  from .sequence import Sequence  from .sequence_id import SequenceId      class _SequenceManager(_Manager[Sequence], _VersionMixin):      _ENTITY_NAME = Sequence.__name__      _EVENT_ENTITY_TYPE = EventEntityType.SEQUENCE      _model_name = \"sequences\"        @classmethod      def _delete(cls, sequence_id: SequenceId):          \"\"\"          Deletes a Sequence by id.          \"\"\"          sequence_name, scenario_id = cls._breakdown_sequence_id(sequence_id)            if scenario := _ScenarioManagerFactory._build_manager()._get(scenario_id):              if sequence_name in scenario._sequences.keys():                  scenario.remove_sequences([sequence_name])                  if hasattr(cls, \"_EVENT_ENTITY_TYPE\"):                      Notifier.publish(Event(cls._EVENT_ENTITY_TYPE, EventOperation.DELETION, entity_id=sequence_id))                  return          raise ModelNotFound(cls._model_name, sequence_id)        @classmethod      def _delete_all(cls):          \"\"\"          Deletes all Sequences.          \"\"\"          scenarios = _ScenarioManagerFactory._build_manager()._get_all()          for scenario in scenarios:              scenario.sequences = {}          if hasattr(cls, \"_EVENT_ENTITY_TYPE\"):              Notifier.publish(Event(cls._EVENT_ENTITY_TYPE, EventOperation.DELETION, metadata={\"delete_all\": True}))        @classmethod      def _delete_many(cls, sequence_ids: Iterable[str]):          \"\"\"          Deletes Sequence entities by a list of Sequence ids.          \"\"\"          scenario_manager = _ScenarioManagerFactory._build_manager()            scenario_ids_and_sequence_names_map: Dict[str, List[str]] = {}          for sequence in sequence_ids:              sequence_id = sequence.id if isinstance(sequence, Sequence) else sequence              sequence_name, scenario_id = cls._breakdown_sequence_id(sequence_id)              sequences_names = scenario_ids_and_sequence_names_map.get(scenario_id, [])              sequences_names.append(sequence_name)              scenario_ids_and_sequence_names_map[scenario_id] = sequences_names            try:              for scenario_id, sequence_names in scenario_ids_and_sequence_names_map.items():                  scenario = scenario_manager._get(scenario_id)                  for sequence_name in sequence_names:                      del scenario._sequences[sequence_name]                  scenario_manager._set(scenario)                if hasattr(cls, \"_EVENT_ENTITY_TYPE\"):                  for sequence_id in sequence_ids:                      Notifier.publish(Event(cls._EVENT_ENTITY_TYPE, EventOperation.DELETION, entity_id=sequence_id))          except (ModelNotFound, KeyError):              cls.__log_error_entity_not_found(sequence_id)              raise ModelNotFound(cls._model_name, sequence_id)        @classmethod      def _delete_by_version(cls, version_number: str):          \"\"\"          Deletes Sequences by version number.          \"\"\"          for scenario in _ScenarioManagerFactory()._build_manager()._repository._search(\"version\", version_number):              cls._delete_many(scenario.sequences.values())        @classmethod      def _hard_delete(cls, sequence_id: SequenceId):          sequence = cls._get(sequence_id)          entity_ids_to_delete = cls._get_children_entity_ids(sequence)          entity_ids_to_delete.sequence_ids.add(sequence.id)          cls._delete_entities_of_multiple_types(entity_ids_to_delete)        @classmethod      def _set(cls, sequence: Sequence):          \"\"\"          Save or update a Sequence.          \"\"\"          sequence_name, scenario_id = cls._breakdown_sequence_id(sequence.id)          scenario_manager = _ScenarioManagerFactory._build_manager()            if scenario := scenario_manager._get(scenario_id):              sequence_data = {                  Scenario._SEQUENCE_TASKS_KEY: sequence._tasks,                  Scenario._SEQUENCE_SUBSCRIBERS_KEY: sequence._subscribers,                  Scenario._SEQUENCE_PROPERTIES_KEY: sequence._properties.data,              }              scenario._sequences[sequence_name] = sequence_data              scenario_manager._set(scenario)          else:              cls._logger.error(f\"Sequence {sequence.id} belongs to a non-existing Scenario {scenario_id}.\")              raise SequenceBelongsToNonExistingScenario(sequence.id, scenario_id)        @classmethod      def _create(          cls,          sequence_name: str,          tasks: Union[List[Task], List[TaskId]],          subscribers: Optional[List[_Subscriber]] = None,          properties: Optional[Dict] = None,          scenario_id: Optional[ScenarioId] = None,          version: Optional[str] = None,      ) -> Sequence:          sequence_id = Sequence._new_id(sequence_name, scenario_id)            task_manager = _TaskManagerFactory._build_manager()          _tasks: List[Task] = []          for task in tasks:              if not isinstance(task, Task):                  if _task := task_manager._get(task):                      _tasks.append(_task)                  else:                      raise NonExistingTask(task)              else:                  _tasks.append(task)            properties = properties if properties else {}          properties[\"name\"] = sequence_name          version = version if version else cls._get_latest_version()          sequence = Sequence(              properties=properties,              tasks=_tasks,              sequence_id=sequence_id,              owner_id=scenario_id,              parent_ids={scenario_id} if scenario_id else None,              subscribers=subscribers,              version=version,          )          for task in _tasks:              if sequence_id not in task._parent_ids:                  task._parent_ids.update([sequence_id])                  task_manager._set(task)          return sequence        @classmethod      def _breakdown_sequence_id(cls, sequence_id: str) -> Tuple[str, str]:          try:              sequence_name, scenario_id = sequence_id.split(Scenario._ID_PREFIX)              scenario_id = f\"{Scenario._ID_PREFIX}{scenario_id}\"              sequence_name = sequence_name.split(Sequence._ID_PREFIX)[1].strip(\"_\")              return sequence_name, scenario_id          except (ValueError, IndexError):              cls._logger.error(f\"SequenceId {sequence_id} is invalid.\")              raise InvalidSequenceId(sequence_id)        @classmethod      def _get(cls, sequence: Union[str, Sequence], default=None) -> Sequence:          \"\"\"          Returns a Sequence by id or reference.          \"\"\"          try:              sequence_id = sequence.id if isinstance(sequence, Sequence) else sequence              sequence_name, scenario_id = cls._breakdown_sequence_id(sequence_id)                scenario_manager = _ScenarioManagerFactory._build_manager()              if scenario := scenario_manager._get(scenario_id):                  if sequence_entity := scenario.sequences.get(sequence_name, None):                      return sequence_entity              cls.__log_error_entity_not_found(sequence_id)              return default          except (ModelNotFound, InvalidSequenceId):              cls.__log_error_entity_not_found(sequence_id)              return default        @classmethod      def _get_all(cls, version_number: Optional[str] = None) -> List[Sequence]:          \"\"\"          Returns all Sequence entities.          \"\"\"          sequences = []          scenarios = _ScenarioManagerFactory._build_manager()._get_all(version_number)          for scenario in scenarios:              sequences.extend(list(scenario.sequences.values()))          return sequences        @classmethod      def _get_all_by(cls, filters: Optional[List[Dict]] = None) -> List[Sequence]:          sequences = cls._get_all()            if not filters:              return sequences            filtered_sequences = []          for sequence in sequences:              for filter in filters:                  if all([getattr(sequence, key) == item for key, item in filter.items()]):                      filtered_sequences.append(sequence)          return filtered_sequences        @classmethod      def _get_children_entity_ids(cls, sequence: Sequence) -> _EntityIds:          entity_ids = _EntityIds()          for task in sequence.tasks.values():              if not isinstance(task, Task):                  task = _TaskManagerFactory._build_manager()._get(task)              if task.owner_id == sequence.id:                  entity_ids.task_ids.add(task.id)              for data_node in task.data_nodes.values():                  if data_node.owner_id == sequence.id:                      entity_ids.data_node_ids.add(data_node.id)            jobs = _JobManagerFactory._build_manager()._get_all()          for job in jobs:              if job.task.id in entity_ids.task_ids:                  entity_ids.job_ids.add(job.id)            submissions = _SubmissionManagerFactory._build_manager()._get_all()          submitted_entity_ids = list(entity_ids.sequence_ids.union(entity_ids.task_ids))          for submission in submissions:              if submission.entity_id in submitted_entity_ids:                  entity_ids.submission_ids.add(submission.id)            return entity_ids        @classmethod      def _subscribe(          cls,          callback: Callable[[Sequence, Job], None],          params: Optional[List[Any]] = None,          sequence: Optional[Sequence] = None,      ):          if sequence is None:              sequences = cls._get_all()              for pln in sequences:                  cls.__add_subscriber(callback, params, pln)              return          cls.__add_subscriber(callback, params, sequence)        @classmethod      def _unsubscribe(          cls,          callback: Callable[[Sequence, Job], None],          params: Optional[List[Any]] = None,          sequence: Optional[Sequence] = None,      ):          if sequence is None:              sequences = cls._get_all()              for pln in sequences:                  cls.__remove_subscriber(callback, params, pln)              return          cls.__remove_subscriber(callback, params, sequence)        @classmethod      def __add_subscriber(cls, callback, params, sequence):          sequence._add_subscriber(callback, params)          Notifier.publish(_make_event(sequence, EventOperation.UPDATE, attribute_name=\"subscribers\"))        @classmethod      def __remove_subscriber(cls, callback, params, sequence):          sequence._remove_subscriber(callback, params)          Notifier.publish(_make_event(sequence, EventOperation.UPDATE, attribute_name=\"subscribers\"))        @classmethod      def _is_submittable(cls, sequence: Union[Sequence, SequenceId]) -> bool:          if isinstance(sequence, str):              sequence = cls._get(sequence)          return isinstance(sequence, Sequence) and sequence.is_ready_to_run()        @classmethod      def _submit(          cls,          sequence: Union[SequenceId, Sequence],          callbacks: Optional[List[Callable]] = None,          force: bool = False,          wait: bool = False,          timeout: Optional[Union[float, int]] = None,          check_inputs_are_ready: bool = True,      ) -> List[Job]:          sequence_id = sequence.id if isinstance(sequence, Sequence) else sequence          sequence = cls._get(sequence_id)          if sequence is None:              raise NonExistingSequence(sequence_id)          callbacks = callbacks or []          sequence_subscription_callback = cls.__get_status_notifier_callbacks(sequence) + callbacks          if check_inputs_are_ready:              _warn_if_inputs_not_ready(sequence.get_inputs())            jobs = (              _TaskManagerFactory._build_manager()              ._orchestrator()              .submit(sequence, callbacks=sequence_subscription_callback, force=force, wait=wait, timeout=timeout)          )          Notifier.publish(_make_event(sequence, EventOperation.SUBMISSION))          return jobs        @classmethod      def _exists(cls, entity_id: str) -> bool:          \"\"\"          Returns True if the entity id exists.          \"\"\"          return True if cls._get(entity_id) else False        @classmethod      def _export(cls, id: str, folder_path: Union[str, pathlib.Path]):          \"\"\"          Export a Sequence entity.          \"\"\"          if isinstance(folder_path, str):              folder: pathlib.Path = pathlib.Path(folder_path)          else:              folder = folder_path            export_dir = folder / cls._model_name          if not export_dir.exists():              export_dir.mkdir(parents=True)            export_path = export_dir / f\"{id}.json\"          sequence_name, scenario_id = cls._breakdown_sequence_id(id)          sequence = {\"id\": id, \"owner_id\": scenario_id, \"parent_ids\": [scenario_id], \"name\": sequence_name}            scenario = _ScenarioManagerFactory._build_manager()._get(scenario_id)          if sequence_data := scenario._sequences.get(sequence_name, None):              sequence.update(sequence_data)              with open(export_path, \"w\", encoding=\"utf-8\") as export_file:                  export_file.write(json.dumps(sequence))          else:              raise ModelNotFound(cls._model_name, id)        @classmethod      def __log_error_entity_not_found(cls, sequence_id: Union[SequenceId, str]):          cls._logger.error(f\"{cls._ENTITY_NAME} not found: {str(sequence_id)}\")        @staticmethod      def __get_status_notifier_callbacks(sequence: Sequence) -> List:          return [partial(c.callback, *c.params, sequence) for c in sequence.subscribers] "}
{"text": "from typing import NewType    SequenceId = NewType(\"SequenceId\", str)  SequenceId.__doc__ = \"\"\"Type that holds a `Sequence^` identifier.\"\"\" "}
{"text": "from __future__ import annotations    from typing import Any, Callable, Dict, List, Optional, Set, Union    import networkx as nx    from taipy.config.common._template_handler import _TemplateHandler as _tpl  from taipy.config.common._validate_id import _validate_id    from .._entity._entity import _Entity  from .._entity._labeled import _Labeled  from .._entity._properties import _Properties  from .._entity._reload import _Reloader, _self_reload, _self_setter  from .._entity.submittable import Submittable  from .._version._version_manager_factory import _VersionManagerFactory  from ..common._listattributes import _ListAttributes  from ..common._utils import _Subscriber  from ..data.data_node import DataNode  from ..exceptions.exceptions import NonExistingTask  from ..job.job import Job  from ..notification.event import Event, EventEntityType, EventOperation, _make_event  from ..task.task import Task  from ..task.task_id import TaskId  from .sequence_id import SequenceId      class Sequence(_Entity, Submittable, _Labeled):      \"\"\"List of `Task^`s and additional attributes representing a set of data processing      elements connected as a direct acyclic graph.        Attributes:          properties (dict[str, Any]): A dictionary of additional properties.          tasks (List[Task^]): The list of `Task`s.          sequence_id (str): The Unique identifier of the sequence.          owner_id (str):  The identifier of the owner (scenario_id, cycle_id) or None.          parent_ids (Optional[Set[str]]): The set of identifiers of the parent scenarios.          version (str): The string indicates the application version of the sequence to instantiate. If not provided,              the latest version is used.      \"\"\"        _ID_PREFIX = \"SEQUENCE\"      _SEPARATOR = \"_\"      _MANAGER_NAME = \"sequence\"        def __init__(          self,          properties: Dict[str, Any],          tasks: Union[List[TaskId], List[Task], List[Union[TaskId, Task]]],          sequence_id: SequenceId,          owner_id: Optional[str] = None,          parent_ids: Optional[Set[str]] = None,          subscribers: Optional[List[_Subscriber]] = None,          version: Optional[str] = None,      ):          super().__init__(subscribers)          self.id: SequenceId = sequence_id          self._tasks = tasks          self.owner_id = owner_id          self._parent_ids = parent_ids or set()          self._properties = _Properties(self, **properties)          self._version = version or _VersionManagerFactory._build_manager()._get_latest_version()        @staticmethod      def _new_id(sequence_name: str, scenario_id) -> SequenceId:          return SequenceId(Sequence._SEPARATOR.join([Sequence._ID_PREFIX, _validate_id(sequence_name), scenario_id]))        def __hash__(self):          return hash(self.id)        def __eq__(self, other):          return self.id == other.id        def __getattr__(self, attribute_name):          protected_attribute_name = _validate_id(attribute_name)          if protected_attribute_name in self._properties:              return _tpl._replace_templates(self._properties[protected_attribute_name])          tasks = self._get_tasks()          if protected_attribute_name in tasks:              return tasks[protected_attribute_name]          for task in tasks.values():              if protected_attribute_name in task.input:                  return task.input[protected_attribute_name]              if protected_attribute_name in task.output:                  return task.output[protected_attribute_name]          raise AttributeError(f\"{attribute_name} is not an attribute of sequence {self.id}\")        @property  # type: ignore      @_self_reload(_MANAGER_NAME)      def tasks(self) -> Dict[str, Task]:          return self._get_tasks()        @tasks.setter  # type: ignore      @_self_setter(_MANAGER_NAME)      def tasks(self, tasks: Union[List[TaskId], List[Task]]):          self._tasks = tasks        @property      def data_nodes(self) -> Dict[str, DataNode]:          data_nodes = {}          list_data_nodes = [task.data_nodes for task in self._get_tasks().values()]          for data_node in list_data_nodes:              for k, v in data_node.items():                  data_nodes[k] = v          return data_nodes        @property      def parent_ids(self):          return self._parent_ids        @property      def version(self):          return self._version        @property      def properties(self):          self._properties = _Reloader()._reload(\"sequence\", self)._properties          return self._properties        def _is_consistent(self) -> bool:          dag = self._build_dag()          if dag.number_of_nodes() == 0:              return True          if not nx.is_directed_acyclic_graph(dag):              return False          if not nx.is_weakly_connected(dag):              return False          for left_node, right_node in dag.edges:              if (isinstance(left_node, DataNode) and isinstance(right_node, Task)) or (                  isinstance(left_node, Task) and isinstance(right_node, DataNode)              ):                  continue              return False          return True        def _get_tasks(self) -> Dict[str, Task]:          from ..task._task_manager_factory import _TaskManagerFactory            tasks = {}          task_manager = _TaskManagerFactory._build_manager()          for task_or_id in self._tasks:              t = task_manager._get(task_or_id, task_or_id)              if not isinstance(t, Task):                  raise NonExistingTask(task_or_id)              tasks[t.config_id] = t          return tasks        def _get_set_of_tasks(self) -> Set[Task]:          from ..task._task_manager_factory import _TaskManagerFactory            tasks = set()          task_manager = _TaskManagerFactory._build_manager()          for task_or_id in self._tasks:              task = task_manager._get(task_or_id, task_or_id)              if not isinstance(task, Task):                  raise NonExistingTask(task_or_id)              tasks.add(task)          return tasks        @property  # type: ignore      @_self_reload(_MANAGER_NAME)      def subscribers(self):          return self._subscribers        @subscribers.setter  # type: ignore      @_self_setter(_MANAGER_NAME)      def subscribers(self, val):          self._subscribers = _ListAttributes(self, val)        def get_parents(self):          \"\"\"Get parents of the sequence entity\"\"\"          from ... import core as tp            return tp.get_parents(self)        def subscribe(          self,          callback: Callable[[Sequence, Job], None],          params: Optional[List[Any]] = None,      ):          \"\"\"Subscribe a function to be called on `Job^` status change.          The subscription is applied to all jobs created from the sequence's execution.            Parameters:              callback (Callable[[Sequence^, Job^], None]): The callable function to be called on                  status change.              params (Optional[List[Any]]): The parameters to be passed to the _callback_.          Note:              Notification will be available only for jobs created after this subscription.          \"\"\"          from ... import core as tp            return tp.subscribe_sequence(callback, params, self)        def unsubscribe(self, callback: Callable[[Sequence, Job], None], params: Optional[List[Any]] = None):          \"\"\"Unsubscribe a function that is called when the status of a `Job^` changes.            Parameters:              callback (Callable[[Sequence^, Job^], None]): The callable function to unsubscribe.              params (Optional[List[Any]]): The parameters to be passed to the _callback_.          Note:              The function will continue to be called for ongoing jobs.          \"\"\"          from ... import core as tp            return tp.unsubscribe_sequence(callback, params, self)        def submit(          self,          callbacks: Optional[List[Callable]] = None,          force: bool = False,          wait: bool = False,          timeout: Optional[Union[float, int]] = None,      ) -> List[Job]:          \"\"\"Submit the sequence for execution.            All the `Task^`s of the sequence will be submitted for execution.            Parameters:              callbacks (List[Callable]): The list of callable functions to be called on status                  change.              force (bool): Force execution even if the data nodes are in cache.              wait (bool): Wait for the orchestrated jobs created from the sequence submission to be finished                  in asynchronous mode.              timeout (Union[float, int]): The maximum number of seconds to wait for the jobs to be finished before                  returning.          Returns:              A list of created `Job^`s.          \"\"\"          from ._sequence_manager_factory import _SequenceManagerFactory            return _SequenceManagerFactory._build_manager()._submit(self, callbacks, force, wait, timeout)        def get_label(self) -> str:          \"\"\"Returns the sequence simple label prefixed by its owner label.            Returns:              The label of the sequence as a string.          \"\"\"          return self._get_label()        def get_simple_label(self) -> str:          \"\"\"Returns the sequence simple label.            Returns:              The simple label of the sequence as a string.          \"\"\"          return self._get_simple_label()      @_make_event.register(Sequence)  def _make_event_for_sequence(      sequence: Sequence,      operation: EventOperation,      /,      attribute_name: Optional[str] = None,      attribute_value: Optional[Any] = None,      **kwargs,  ) -> Event:      metadata = {**kwargs}      return Event(          entity_type=EventEntityType.SEQUENCE,          entity_id=sequence.id,          operation=operation,          attribute_name=attribute_name,          attribute_value=attribute_value,          metadata=metadata,      ) "}
{"text": "#  # Licensed under the Apache License, Version 2.0 (the \"License\"); you may not use this file except in compliance with  # the License. You may obtain a copy of the License at  #  #        http://www.apache.org/licenses/LICENSE-2.0  #  # Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on  # an \"AS IS\" BASIS, WITHOUT 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 copy import copy  from datetime import datetime, timedelta  from pydoc import locate    from .._repository._abstract_converter import _AbstractConverter  from .._version._utils import _migrate_entity  from ..common._utils import _load_fct  from ..data._data_model import _DataNodeModel  from ..data.data_node import DataNode  from . import GenericDataNode, JSONDataNode, MongoCollectionDataNode, SQLDataNode      class _DataNodeConverter(_AbstractConverter):      _READ_FCT_NAME_KEY = \"read_fct_name\"      _READ_FCT_MODULE_KEY = \"read_fct_module\"      _WRITE_FCT_NAME_KEY = \"write_fct_name\"      _WRITE_FCT_MODULE_KEY = \"write_fct_module\"      _JSON_ENCODER_NAME_KEY = \"encoder_name\"      _JSON_ENCODER_MODULE_KEY = \"encoder_module\"      _JSON_DECODER_NAME_KEY = \"decoder_name\"      _JSON_DECODER_MODULE_KEY = \"decoder_module\"      _EXPOSED_TYPE_KEY = \"exposed_type\"      __WRITE_QUERY_BUILDER_NAME_KEY = \"write_query_builder_name\"      __WRITE_QUERY_BUILDER_MODULE_KEY = \"write_query_builder_module\"      __APPEND_QUERY_BUILDER_NAME_KEY = \"append_query_builder_name\"      __APPEND_QUERY_BUILDER_MODULE_KEY = \"append_query_builder_module\"      # TODO: This limits the valid string to only the ones provided by the Converter.      # While in practice, each data nodes might have different exposed type possibilities.      # The previous implementation used tabular datanode but it's no longer suitable so      # new proposal is needed.      _VALID_STRING_EXPOSED_TYPES = [\"numpy\", \"pandas\", \"modin\"]        @classmethod      def __serialize_generic_dn_properties(cls, datanode_properties: dict):          read_fct = datanode_properties.get(GenericDataNode._OPTIONAL_READ_FUNCTION_PROPERTY, None)          datanode_properties[cls._READ_FCT_NAME_KEY] = read_fct.__name__ if read_fct else None          datanode_properties[cls._READ_FCT_MODULE_KEY] = read_fct.__module__ if read_fct else None            write_fct = datanode_properties.get(GenericDataNode._OPTIONAL_WRITE_FUNCTION_PROPERTY, None)          datanode_properties[cls._WRITE_FCT_NAME_KEY] = write_fct.__name__ if write_fct else None          datanode_properties[cls._WRITE_FCT_MODULE_KEY] = write_fct.__module__ if write_fct else None            del (              datanode_properties[GenericDataNode._OPTIONAL_READ_FUNCTION_PROPERTY],              datanode_properties[GenericDataNode._OPTIONAL_WRITE_FUNCTION_PROPERTY],          )          return datanode_properties        @classmethod      def __serialize_json_dn_properties(cls, datanode_properties: dict):          encoder = datanode_properties.get(JSONDataNode._ENCODER_KEY)          datanode_properties[cls._JSON_ENCODER_NAME_KEY] = encoder.__name__ if encoder else None          datanode_properties[cls._JSON_ENCODER_MODULE_KEY] = encoder.__module__ if encoder else None          datanode_properties.pop(JSONDataNode._ENCODER_KEY, None)            decoder = datanode_properties.get(JSONDataNode._DECODER_KEY)          datanode_properties[cls._JSON_DECODER_NAME_KEY] = decoder.__name__ if decoder else None          datanode_properties[cls._JSON_DECODER_MODULE_KEY] = decoder.__module__ if decoder else None          datanode_properties.pop(JSONDataNode._DECODER_KEY, None)            return datanode_properties        @classmethod      def __serialize_sql_dn_properties(cls, datanode_properties: dict) -> dict:          write_qb = datanode_properties.get(SQLDataNode._WRITE_QUERY_BUILDER_KEY)          datanode_properties[cls.__WRITE_QUERY_BUILDER_NAME_KEY] = write_qb.__name__ if write_qb else None          datanode_properties[cls.__WRITE_QUERY_BUILDER_MODULE_KEY] = write_qb.__module__ if write_qb else None          datanode_properties.pop(SQLDataNode._WRITE_QUERY_BUILDER_KEY, None)            append_qb = datanode_properties.get(SQLDataNode._APPEND_QUERY_BUILDER_KEY)          datanode_properties[cls.__APPEND_QUERY_BUILDER_NAME_KEY] = append_qb.__name__ if append_qb else None          datanode_properties[cls.__APPEND_QUERY_BUILDER_MODULE_KEY] = append_qb.__module__ if append_qb else None          datanode_properties.pop(SQLDataNode._APPEND_QUERY_BUILDER_KEY, None)            return datanode_properties        @classmethod      def __serialize_mongo_collection_dn_model_properties(cls, datanode_properties: dict) -> dict:          if MongoCollectionDataNode._CUSTOM_DOCUMENT_PROPERTY in datanode_properties.keys():              datanode_properties[MongoCollectionDataNode._CUSTOM_DOCUMENT_PROPERTY] = (                  f\"{datanode_properties[MongoCollectionDataNode._CUSTOM_DOCUMENT_PROPERTY].__module__}.\"                  f\"{datanode_properties[MongoCollectionDataNode._CUSTOM_DOCUMENT_PROPERTY].__qualname__}\"              )            return datanode_properties        @classmethod      def __serialize_edits(cls, edits):          new_edits = []          for edit in edits:              new_edit = edit.copy()              if timestamp := new_edit.get(\"timestamp\", None):                  new_edit[\"timestamp\"] = timestamp.isoformat()              else:                  new_edit[\"timestamp\"] = datetime.now().isoformat()              new_edits.append(new_edit)          return new_edits        @staticmethod      def __serialize_exposed_type(properties: dict, exposed_type_key: str, valid_str_exposed_types) -> dict:          if not isinstance(properties[exposed_type_key], str):              if isinstance(properties[exposed_type_key], dict):                  properties[exposed_type_key] = {                      k: v if v in valid_str_exposed_types else f\"{v.__module__}.{v.__qualname__}\"                      for k, v in properties[exposed_type_key].items()                  }              elif isinstance(properties[exposed_type_key], list):                  properties[exposed_type_key] = [                      v if v in valid_str_exposed_types else f\"{v.__module__}.{v.__qualname__}\"                      for v in properties[exposed_type_key]                  ]              else:                  properties[                      exposed_type_key                  ] = f\"{properties[exposed_type_key].__module__}.{properties[exposed_type_key].__qualname__}\"          return properties        @classmethod      def _entity_to_model(cls, data_node: DataNode) -> _DataNodeModel:          properties = data_node._properties.data.copy()          if data_node.storage_type() == GenericDataNode.storage_type():              properties = cls.__serialize_generic_dn_properties(properties)            if data_node.storage_type() == JSONDataNode.storage_type():              properties = cls.__serialize_json_dn_properties(properties)            if data_node.storage_type() == SQLDataNode.storage_type():              properties = cls.__serialize_sql_dn_properties(properties)            if data_node.storage_type() == MongoCollectionDataNode.storage_type():              properties = cls.__serialize_mongo_collection_dn_model_properties(properties)            if cls._EXPOSED_TYPE_KEY in properties.keys():              properties = cls.__serialize_exposed_type(                  properties, cls._EXPOSED_TYPE_KEY, cls._VALID_STRING_EXPOSED_TYPES              )            return _DataNodeModel(              data_node.id,              data_node.config_id,              data_node._scope,              data_node.storage_type(),              data_node.owner_id,              list(data_node._parent_ids),              data_node._last_edit_date.isoformat() if data_node._last_edit_date else None,              cls.__serialize_edits(data_node._edits),              data_node._version,              data_node._validity_period.days if data_node._validity_period else None,              data_node._validity_period.seconds if data_node._validity_period else None,              data_node._edit_in_progress,              data_node._editor_id,              data_node._editor_expiration_date.isoformat() if data_node._editor_expiration_date else None,              properties,          )        @classmethod      def __deserialize_generic_dn_properties(cls, datanode_model_properties):          if datanode_model_properties[cls._READ_FCT_MODULE_KEY]:              datanode_model_properties[GenericDataNode._OPTIONAL_READ_FUNCTION_PROPERTY] = _load_fct(                  datanode_model_properties[cls._READ_FCT_MODULE_KEY],                  datanode_model_properties[cls._READ_FCT_NAME_KEY],              )          else:              datanode_model_properties[GenericDataNode._OPTIONAL_READ_FUNCTION_PROPERTY] = None            if datanode_model_properties[cls._WRITE_FCT_MODULE_KEY]:              datanode_model_properties[GenericDataNode._OPTIONAL_WRITE_FUNCTION_PROPERTY] = _load_fct(                  datanode_model_properties[cls._WRITE_FCT_MODULE_KEY],                  datanode_model_properties[cls._WRITE_FCT_NAME_KEY],              )          else:              datanode_model_properties[GenericDataNode._OPTIONAL_WRITE_FUNCTION_PROPERTY] = None            del datanode_model_properties[cls._READ_FCT_NAME_KEY]          del datanode_model_properties[cls._READ_FCT_MODULE_KEY]          del datanode_model_properties[cls._WRITE_FCT_NAME_KEY]          del datanode_model_properties[cls._WRITE_FCT_MODULE_KEY]            return datanode_model_properties        @classmethod      def __deserialize_json_dn_properties(cls, datanode_model_properties: dict) -> dict:          if datanode_model_properties[cls._JSON_ENCODER_MODULE_KEY]:              datanode_model_properties[JSONDataNode._ENCODER_KEY] = _load_fct(                  datanode_model_properties[cls._JSON_ENCODER_MODULE_KEY],                  datanode_model_properties[cls._JSON_ENCODER_NAME_KEY],              )          else:              datanode_model_properties[JSONDataNode._ENCODER_KEY] = None            if datanode_model_properties[cls._JSON_DECODER_MODULE_KEY]:              datanode_model_properties[JSONDataNode._DECODER_KEY] = _load_fct(                  datanode_model_properties[cls._JSON_DECODER_MODULE_KEY],                  datanode_model_properties[cls._JSON_DECODER_NAME_KEY],              )          else:              datanode_model_properties[JSONDataNode._DECODER_KEY] = None            del datanode_model_properties[cls._JSON_ENCODER_NAME_KEY]          del datanode_model_properties[cls._JSON_ENCODER_MODULE_KEY]          del datanode_model_properties[cls._JSON_DECODER_NAME_KEY]          del datanode_model_properties[cls._JSON_DECODER_MODULE_KEY]            return datanode_model_properties        @classmethod      def __deserialize_sql_dn_model_properties(cls, datanode_model_properties: dict) -> dict:          if datanode_model_properties[cls.__WRITE_QUERY_BUILDER_MODULE_KEY]:              datanode_model_properties[SQLDataNode._WRITE_QUERY_BUILDER_KEY] = _load_fct(                  datanode_model_properties[cls.__WRITE_QUERY_BUILDER_MODULE_KEY],                  datanode_model_properties[cls.__WRITE_QUERY_BUILDER_NAME_KEY],              )          else:              datanode_model_properties[SQLDataNode._WRITE_QUERY_BUILDER_KEY] = None            del datanode_model_properties[cls.__WRITE_QUERY_BUILDER_NAME_KEY]          del datanode_model_properties[cls.__WRITE_QUERY_BUILDER_MODULE_KEY]            if datanode_model_properties[cls.__APPEND_QUERY_BUILDER_MODULE_KEY]:              datanode_model_properties[SQLDataNode._APPEND_QUERY_BUILDER_KEY] = _load_fct(                  datanode_model_properties[cls.__APPEND_QUERY_BUILDER_MODULE_KEY],                  datanode_model_properties[cls.__APPEND_QUERY_BUILDER_NAME_KEY],              )          else:              datanode_model_properties[SQLDataNode._APPEND_QUERY_BUILDER_KEY] = None            del datanode_model_properties[cls.__APPEND_QUERY_BUILDER_NAME_KEY]          del datanode_model_properties[cls.__APPEND_QUERY_BUILDER_MODULE_KEY]            return datanode_model_properties        @classmethod      def __deserialize_mongo_collection_dn_model_properties(cls, datanode_model_properties: dict) -> dict:          if MongoCollectionDataNode._CUSTOM_DOCUMENT_PROPERTY in datanode_model_properties.keys():              if isinstance(datanode_model_properties[MongoCollectionDataNode._CUSTOM_DOCUMENT_PROPERTY], str):                  datanode_model_properties[MongoCollectionDataNode._CUSTOM_DOCUMENT_PROPERTY] = locate(                      datanode_model_properties[MongoCollectionDataNode._CUSTOM_DOCUMENT_PROPERTY]                  )          return datanode_model_properties        @classmethod      def __deserialize_edits(cls, edits):          for edit in edits:              if timestamp := edit.get(\"timestamp\", None):                  edit[\"timestamp\"] = datetime.fromisoformat(timestamp)              else:                  edit[\"timestamp\"] = datetime.now()          return edits        @staticmethod      def __deserialize_exposed_type(properties: dict, exposed_type_key: str, valid_str_exposed_types) -> dict:          if properties[exposed_type_key] not in valid_str_exposed_types:              if isinstance(properties[exposed_type_key], str):                  properties[exposed_type_key] = locate(properties[exposed_type_key])              elif isinstance(properties[exposed_type_key], dict):                  properties[exposed_type_key] = {                      k: v if v in valid_str_exposed_types else locate(v) for k, v in properties[exposed_type_key].items()                  }              elif isinstance(properties[exposed_type_key], list):                  properties[exposed_type_key] = [                      v if v in valid_str_exposed_types else locate(v) for v in properties[exposed_type_key]                  ]          return properties        @classmethod      def _model_to_entity(cls, model: _DataNodeModel) -> DataNode:          data_node_properties = model.data_node_properties.copy()            if model.storage_type == GenericDataNode.storage_type():              data_node_properties = cls.__deserialize_generic_dn_properties(data_node_properties)            if model.storage_type == JSONDataNode.storage_type():              data_node_properties = cls.__deserialize_json_dn_properties(data_node_properties)            if model.storage_type == SQLDataNode.storage_type():              data_node_properties = cls.__deserialize_sql_dn_model_properties(data_node_properties)            if model.storage_type == MongoCollectionDataNode.storage_type():              data_node_properties = cls.__deserialize_mongo_collection_dn_model_properties(data_node_properties)            if cls._EXPOSED_TYPE_KEY in data_node_properties.keys():              data_node_properties = cls.__deserialize_exposed_type(                  data_node_properties, cls._EXPOSED_TYPE_KEY, cls._VALID_STRING_EXPOSED_TYPES              )            validity_period = None          if model.validity_seconds is not None and model.validity_days is not None:              validity_period = timedelta(days=model.validity_days, seconds=model.validity_seconds)            exp_date = datetime.fromisoformat(model.editor_expiration_date) if model.editor_expiration_date else None          datanode = DataNode._class_map()[model.storage_type](              config_id=model.config_id,              scope=model.scope,              id=model.id,              owner_id=model.owner_id,              parent_ids=set(model.parent_ids),              last_edit_date=datetime.fromisoformat(model.last_edit_date) if model.last_edit_date else None,              edits=cls.__deserialize_edits(copy(model.edits)),              version=model.version,              validity_period=validity_period,              edit_in_progress=model.edit_in_progress,              editor_id=model.editor_id,              editor_expiration_date=exp_date,              properties=data_node_properties,          )          return _migrate_entity(datanode) "}
{"text": "import os  import re  import urllib.parse  from abc import abstractmethod  from datetime import datetime, timedelta  from typing import Dict, List, Optional, Set, Tuple, Union    import modin.pandas as modin_pd  import numpy as np  import pandas as pd  from sqlalchemy import create_engine, text    from taipy.config.common.scope import Scope    from .._version._version_manager_factory import _VersionManagerFactory  from ..data.operator import JoinOperator, Operator  from ..exceptions.exceptions import MissingRequiredProperty, UnknownDatabaseEngine  from ._abstract_tabular import _AbstractTabularDataNode  from .data_node import DataNode  from .data_node_id import DataNodeId, Edit      class _AbstractSQLDataNode(DataNode, _AbstractTabularDataNode):      \"\"\"Abstract base class for data node implementations (SQLDataNode and SQLTableDataNode) that use SQL.\"\"\"        __STORAGE_TYPE = \"NOT_IMPLEMENTED\"        __EXPOSED_TYPE_PROPERTY = \"exposed_type\"      __EXPOSED_TYPE_NUMPY = \"numpy\"      __EXPOSED_TYPE_PANDAS = \"pandas\"      __EXPOSED_TYPE_MODIN = \"modin\"      __VALID_STRING_EXPOSED_TYPES = [__EXPOSED_TYPE_PANDAS, __EXPOSED_TYPE_NUMPY, __EXPOSED_TYPE_MODIN]        __DB_NAME_KEY = \"db_name\"      __DB_USERNAME_KEY = \"db_username\"      __DB_PASSWORD_KEY = \"db_password\"      __DB_HOST_KEY = \"db_host\"      __DB_PORT_KEY = \"db_port\"      __DB_ENGINE_KEY = \"db_engine\"      __DB_DRIVER_KEY = \"db_driver\"      __DB_EXTRA_ARGS_KEY = \"db_extra_args\"      __SQLITE_FOLDER_PATH = \"sqlite_folder_path\"      __SQLITE_FILE_EXTENSION = \"sqlite_file_extension\"        __ENGINE_PROPERTIES: List[str] = [          __DB_NAME_KEY,          __DB_USERNAME_KEY,          __DB_PASSWORD_KEY,          __DB_HOST_KEY,          __DB_PORT_KEY,          __DB_DRIVER_KEY,          __DB_EXTRA_ARGS_KEY,          __SQLITE_FOLDER_PATH,          __SQLITE_FILE_EXTENSION,      ]        __DB_HOST_DEFAULT = \"localhost\"      __DB_PORT_DEFAULT = 1433      __DB_DRIVER_DEFAULT = \"\"      __SQLITE_FOLDER_PATH_DEFAULT = \"\"      __SQLITE_FILE_EXTENSION_DEFAULT = \".db\"        __ENGINE_MSSQL = \"mssql\"      __ENGINE_SQLITE = \"sqlite\"      __ENGINE_MYSQL = \"mysql\"      __ENGINE_POSTGRESQL = \"postgresql\"        _ENGINE_REQUIRED_PROPERTIES: Dict[str, List[str]] = {          __ENGINE_MSSQL: [__DB_USERNAME_KEY, __DB_PASSWORD_KEY, __DB_NAME_KEY],          __ENGINE_MYSQL: [__DB_USERNAME_KEY, __DB_PASSWORD_KEY, __DB_NAME_KEY],          __ENGINE_POSTGRESQL: [__DB_USERNAME_KEY, __DB_PASSWORD_KEY, __DB_NAME_KEY],          __ENGINE_SQLITE: [__DB_NAME_KEY],      }        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: Optional[List[Edit]] = None,          version: Optional[str] = None,          validity_period: Optional[timedelta] = None,          edit_in_progress: bool = False,          editor_id: Optional[str] = None,          editor_expiration_date: Optional[datetime] = None,          properties: Optional[Dict] = None,      ):          if properties is None:              properties = {}          self._check_required_properties(properties)            if self.__EXPOSED_TYPE_PROPERTY not in properties.keys():              properties[self.__EXPOSED_TYPE_PROPERTY] = self.__EXPOSED_TYPE_PANDAS          self._check_exposed_type(properties[self.__EXPOSED_TYPE_PROPERTY], self.__VALID_STRING_EXPOSED_TYPES)            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,          )          self._engine = None          if not self._last_edit_date:              self._last_edit_date = datetime.now()            self._TAIPY_PROPERTIES.update(              {                  self.__DB_NAME_KEY,                  self.__DB_USERNAME_KEY,                  self.__DB_PASSWORD_KEY,                  self.__DB_HOST_KEY,                  self.__DB_PORT_KEY,                  self.__DB_ENGINE_KEY,                  self.__DB_DRIVER_KEY,                  self.__DB_EXTRA_ARGS_KEY,                  self.__SQLITE_FOLDER_PATH,                  self.__SQLITE_FILE_EXTENSION,                  self.__EXPOSED_TYPE_PROPERTY,              }          )        def _check_required_properties(self, properties: Dict):          db_engine = properties.get(self.__DB_ENGINE_KEY)          if not db_engine:              raise MissingRequiredProperty(f\"{self.__DB_ENGINE_KEY} is required.\")          if db_engine not in self._ENGINE_REQUIRED_PROPERTIES.keys():              raise UnknownDatabaseEngine(f\"Unknown engine: {db_engine}\")          required = self._ENGINE_REQUIRED_PROPERTIES[db_engine]            if missing := set(required) - set(properties.keys()):              raise MissingRequiredProperty(                  f\"The following properties \" f\"{', '.join(x for x in missing)} were not informed and are required.\"              )        def _get_engine(self):          if self._engine is None:              self._engine = create_engine(self._conn_string())          return self._engine        def _conn_string(self) -> str:          engine = self.properties.get(self.__DB_ENGINE_KEY)            if self.__DB_USERNAME_KEY in self._ENGINE_REQUIRED_PROPERTIES[engine]:              username = self.properties.get(self.__DB_USERNAME_KEY)              username = urllib.parse.quote_plus(username)            if self.__DB_PASSWORD_KEY in self._ENGINE_REQUIRED_PROPERTIES[engine]:              password = self.properties.get(self.__DB_PASSWORD_KEY)              password = urllib.parse.quote_plus(password)            if self.__DB_NAME_KEY in self._ENGINE_REQUIRED_PROPERTIES[engine]:              db_name = self.properties.get(self.__DB_NAME_KEY)              db_name = urllib.parse.quote_plus(db_name)            host = self.properties.get(self.__DB_HOST_KEY, self.__DB_HOST_DEFAULT)          port = self.properties.get(self.__DB_PORT_KEY, self.__DB_PORT_DEFAULT)          driver = self.properties.get(self.__DB_DRIVER_KEY, self.__DB_DRIVER_DEFAULT)          extra_args = self.properties.get(self.__DB_EXTRA_ARGS_KEY, {})            if driver:              extra_args = {**extra_args, \"driver\": driver}          for k, v in extra_args.items():              extra_args[k] = re.sub(r\"\\s+\", \"+\", v)          extra_args_str = \"&\".join(f\"{k}={str(v)}\" for k, v in extra_args.items())            if engine == self.__ENGINE_MSSQL:              return f\"mssql+pyodbc://{username}:{password}@{host}:{port}/{db_name}?{extra_args_str}\"          elif engine == self.__ENGINE_MYSQL:              return f\"mysql+pymysql://{username}:{password}@{host}:{port}/{db_name}?{extra_args_str}\"          elif engine == self.__ENGINE_POSTGRESQL:              return f\"postgresql+psycopg2://{username}:{password}@{host}:{port}/{db_name}?{extra_args_str}\"          elif engine == self.__ENGINE_SQLITE:              folder_path = self.properties.get(self.__SQLITE_FOLDER_PATH, self.__SQLITE_FOLDER_PATH_DEFAULT)              file_extension = self.properties.get(self.__SQLITE_FILE_EXTENSION, self.__SQLITE_FILE_EXTENSION_DEFAULT)              return \"sqlite:///\" + os.path.join(folder_path, f\"{db_name}{file_extension}\")            raise UnknownDatabaseEngine(f\"Unknown engine: {engine}\")        def filter(self, operators: Optional[Union[List, Tuple]] = None, join_operator=JoinOperator.AND):          if self.properties[self.__EXPOSED_TYPE_PROPERTY] == self.__EXPOSED_TYPE_PANDAS:              return self._read_as_pandas_dataframe(operators=operators, join_operator=join_operator)          if self.properties[self.__EXPOSED_TYPE_PROPERTY] == self.__EXPOSED_TYPE_MODIN:              return self._read_as_modin_dataframe(operators=operators, join_operator=join_operator)          if self.properties[self.__EXPOSED_TYPE_PROPERTY] == self.__EXPOSED_TYPE_NUMPY:              return self._read_as_numpy(operators=operators, join_operator=join_operator)          return self._read_as(operators=operators, join_operator=join_operator)        def _read(self):          if self.properties[self.__EXPOSED_TYPE_PROPERTY] == self.__EXPOSED_TYPE_PANDAS:              return self._read_as_pandas_dataframe()          if self.properties[self.__EXPOSED_TYPE_PROPERTY] == self.__EXPOSED_TYPE_MODIN:              return self._read_as_modin_dataframe()          if self.properties[self.__EXPOSED_TYPE_PROPERTY] == self.__EXPOSED_TYPE_NUMPY:              return self._read_as_numpy()          return self._read_as()        def _read_as(self, operators: Optional[Union[List, Tuple]] = None, join_operator=JoinOperator.AND):          custom_class = self.properties[self.__EXPOSED_TYPE_PROPERTY]          with self._get_engine().connect() as connection:              query_result = connection.execute(text(self._get_read_query(operators, join_operator)))          return list(map(lambda row: custom_class(**row), query_result))        def _read_as_numpy(          self, operators: Optional[Union[List, Tuple]] = None, join_operator=JoinOperator.AND      ) -> np.ndarray:          return self._read_as_pandas_dataframe(operators=operators, join_operator=join_operator).to_numpy()        def _read_as_pandas_dataframe(          self,          columns: Optional[List[str]] = None,          operators: Optional[Union[List, Tuple]] = None,          join_operator=JoinOperator.AND,      ):          with self._get_engine().connect() as conn:              if columns:                  return pd.DataFrame(conn.execute(text(self._get_read_query(operators, join_operator))))[columns]              return pd.DataFrame(conn.execute(text(self._get_read_query(operators, join_operator))))        def _read_as_modin_dataframe(          self,          columns: Optional[List[str]] = None,          operators: Optional[Union[List, Tuple]] = None,          join_operator=JoinOperator.AND,      ):          if columns:              return modin_pd.read_sql_query(self._get_read_query(operators, join_operator), con=self._get_engine())[                  columns              ]          return modin_pd.read_sql_query(self._get_read_query(operators, join_operator), con=self._get_engine())        @abstractmethod      def _get_read_query(self, operators: Optional[Union[List, Tuple]] = None, join_operator=JoinOperator.AND):          query = self._get_base_read_query()            if not operators:              return query            if not isinstance(operators, List):              operators = [operators]            conditions = []          for key, value, operator in operators:              if operator == Operator.EQUAL:                  conditions.append(f\"{key} = '{value}'\")              elif operator == Operator.NOT_EQUAL:                  conditions.append(f\"{key} <> '{value}'\")              elif operator == Operator.GREATER_THAN:                  conditions.append(f\"{key} > '{value}'\")              elif operator == Operator.GREATER_OR_EQUAL:                  conditions.append(f\"{key} >= '{value}'\")              elif operator == Operator.LESS_THAN:                  conditions.append(f\"{key} < '{value}'\")              elif operator == Operator.LESS_OR_EQUAL:                  conditions.append(f\"{key} <= '{value}'\")            if join_operator == JoinOperator.AND:              query += f\" WHERE {' AND '.join(conditions)}\"          elif join_operator == JoinOperator.OR:              query += f\" WHERE {' OR '.join(conditions)}\"          else:              raise NotImplementedError(f\"Join operator {join_operator} not implemented.\")            return query        @abstractmethod      def _get_base_read_query(self) -> str:          raise NotImplementedError        def _append(self, data) -> None:          engine = self._get_engine()          with engine.connect() as connection:              with connection.begin() as transaction:                  try:                      self._do_append(data, engine, connection)                  except Exception as e:                      transaction.rollback()                      raise e                  else:                      transaction.commit()        @abstractmethod      def _do_append(self, data, engine, connection) -> None:          raise NotImplementedError        def _write(self, data) -> None:          \"\"\"Check data against a collection of types to handle insertion on the database.\"\"\"          engine = self._get_engine()          with engine.connect() as connection:              with connection.begin() as transaction:                  try:                      self._do_write(data, engine, connection)                  except Exception as e:                      transaction.rollback()                      raise e                  else:                      transaction.commit()        @abstractmethod      def _do_write(self, data, engine, connection) -> None:          raise NotImplementedError        def __setattr__(self, key: str, value) -> None:          if key in self.__ENGINE_PROPERTIES:              self._engine = None          return super().__setattr__(key, value) "}
{"text": "import os  from datetime import datetime, timedelta  from os.path import isdir, isfile  from typing import Any, Dict, List, Optional, Set    import modin.pandas as modin_pd  import numpy as np  import pandas as pd    from taipy.config.common.scope import Scope    from .._backup._backup import _replace_in_backup_file  from .._entity._reload import _self_reload  from .._version._version_manager_factory import _VersionManagerFactory  from ..exceptions.exceptions import UnknownCompressionAlgorithm, UnknownParquetEngine  from ..job.job_id import JobId  from ._abstract_file import _AbstractFileDataNode  from ._abstract_tabular import _AbstractTabularDataNode  from .data_node import DataNode  from .data_node_id import DataNodeId, Edit      class ParquetDataNode(DataNode, _AbstractFileDataNode, _AbstractTabularDataNode):      \"\"\"Data Node stored as a Parquet file.        Attributes:          config_id (str): Identifier of the data node configuration. This string 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.          path (str): The path to the Parquet file.          properties (dict[str, Any]): A dictionary of additional properties. *properties*              must have a *\"default_path\"* or *\"path\"* entry with the path of the Parquet file:                - *\"default_path\"* (`str`): The default path of the Parquet file.              - *\"exposed_type\"*: The exposed type of the data read from Parquet file. The default                  value is `pandas`.              - *\"engine\"* (`Optional[str]`): Parquet library to use. Possible values are                  *\"fastparquet\"* or *\"pyarrow\"*.<br/>                  The default value is *\"pyarrow\"*.              - *\"compression\"* (`Optional[str]`): Name of the compression to use. Possible values                  are *\"snappy\"*, *\"gzip\"*, *\"brotli\"*, or *\"none\"* (no compression).<br/>                  The default value is *\"snappy\"*.              - *\"read_kwargs\"* (`Optional[dict]`): Additional parameters passed to the                  *pandas.read_parquet()* function.              - *\"write_kwargs\"* (`Optional[dict]`): Additional parameters passed to the                  *pandas.DataFrame.write_parquet()* fucntion.                  The parameters in *\"read_kwargs\"* and *\"write_kwargs\"* have a                  **higher precedence** than the top-level parameters which are also passed to                  Pandas.      \"\"\"        __STORAGE_TYPE = \"parquet\"      __EXPOSED_TYPE_PROPERTY = \"exposed_type\"      __EXPOSED_TYPE_NUMPY = \"numpy\"      __EXPOSED_TYPE_PANDAS = \"pandas\"      __EXPOSED_TYPE_MODIN = \"modin\"      __VALID_STRING_EXPOSED_TYPES = [__EXPOSED_TYPE_PANDAS, __EXPOSED_TYPE_MODIN, __EXPOSED_TYPE_NUMPY]      __PATH_KEY = \"path\"      __DEFAULT_DATA_KEY = \"default_data\"      __DEFAULT_PATH_KEY = \"default_path\"      __ENGINE_PROPERTY = \"engine\"      __VALID_PARQUET_ENGINES = [\"pyarrow\", \"fastparquet\"]      __COMPRESSION_PROPERTY = \"compression\"      __VALID_COMPRESSION_ALGORITHMS = [\"snappy\", \"gzip\", \"brotli\", \"none\"]      __READ_KWARGS_PROPERTY = \"read_kwargs\"      __WRITE_KWARGS_PROPERTY = \"write_kwargs\"      _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: Optional[List[Edit]] = None,          version: Optional[str] = None,          validity_period: Optional[timedelta] = None,          edit_in_progress: bool = False,          editor_id: Optional[str] = None,          editor_expiration_date: Optional[datetime] = None,          properties: Optional[Dict] = None,      ):          if properties is None:              properties = {}            default_value = properties.pop(self.__DEFAULT_DATA_KEY, None)            if self.__ENGINE_PROPERTY not in properties.keys():              properties[self.__ENGINE_PROPERTY] = \"pyarrow\"          if properties[self.__ENGINE_PROPERTY] not in self.__VALID_PARQUET_ENGINES:              raise UnknownParquetEngine(                  f\"Invalid parquet engine: {properties[self.__ENGINE_PROPERTY]}. \"                  f\"Supported engines are {', '.join(self.__VALID_PARQUET_ENGINES)}\"              )            if self.__COMPRESSION_PROPERTY not in properties.keys():              properties[self.__COMPRESSION_PROPERTY] = \"snappy\"          if properties[self.__COMPRESSION_PROPERTY] == \"none\":              properties[self.__COMPRESSION_PROPERTY] = None          if (              properties[self.__COMPRESSION_PROPERTY]              and properties[self.__COMPRESSION_PROPERTY] not in self.__VALID_COMPRESSION_ALGORITHMS          ):              raise UnknownCompressionAlgorithm(                  f\"Unsupported compression algorithm: {properties[self.__COMPRESSION_PROPERTY]}. \"                  f\"Supported algorithms are {', '.join(self.__VALID_COMPRESSION_ALGORITHMS)}\"              )            if self.__READ_KWARGS_PROPERTY not in properties.keys():              properties[self.__READ_KWARGS_PROPERTY] = {}            if self.__WRITE_KWARGS_PROPERTY not in properties.keys():              properties[self.__WRITE_KWARGS_PROPERTY] = {}            if self.__EXPOSED_TYPE_PROPERTY not in properties.keys():              properties[self.__EXPOSED_TYPE_PROPERTY] = self.__EXPOSED_TYPE_PANDAS          self._check_exposed_type(properties[self.__EXPOSED_TYPE_PROPERTY], self.__VALID_STRING_EXPOSED_TYPES)            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,          )          self._path = properties.get(self.__PATH_KEY, properties.get(self.__DEFAULT_PATH_KEY))          if not self._path:              self._path = self._build_path(self.storage_type())          properties[self.__PATH_KEY] = self._path            if default_value is not None and not os.path.exists(self._path):              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.\",                      }                  )              )            if not self._last_edit_date and (isfile(self._path) or isdir(self._path)):              self._last_edit_date = datetime.now()            self._TAIPY_PROPERTIES.update(              {                  self.__EXPOSED_TYPE_PROPERTY,                  self.__PATH_KEY,                  self.__DEFAULT_PATH_KEY,                  self.__DEFAULT_DATA_KEY,                  self.__ENGINE_PROPERTY,                  self.__COMPRESSION_PROPERTY,                  self.__READ_KWARGS_PROPERTY,                  self.__WRITE_KWARGS_PROPERTY,              }          )        @classmethod      def storage_type(cls) -> str:          return cls.__STORAGE_TYPE        @property  # type: ignore      @_self_reload(DataNode._MANAGER_NAME)      def path(self):          return self._path        @path.setter      def path(self, value):          tmp_old_path = self._path          self._path = value          self.properties[self.__PATH_KEY] = value          _replace_in_backup_file(old_file_path=tmp_old_path, new_file_path=self._path)        def _read(self):          return self.read_with_kwargs()        def _read_as(self, read_kwargs: Dict):          custom_class = self.properties[self.__EXPOSED_TYPE_PROPERTY]          list_of_dicts = self._read_as_pandas_dataframe(read_kwargs).to_dict(orient=\"records\")          return [custom_class(**dct) for dct in list_of_dicts]        def _read_as_numpy(self, read_kwargs: Dict) -> np.ndarray:          return self._read_as_pandas_dataframe(read_kwargs).to_numpy()        def _read_as_pandas_dataframe(self, read_kwargs: Dict) -> pd.DataFrame:          return pd.read_parquet(self._path, **read_kwargs)        def _read_as_modin_dataframe(self, read_kwargs: Dict) -> modin_pd.DataFrame:          return modin_pd.read_parquet(self._path, **read_kwargs)        def _append(self, data: Any):          self.write_with_kwargs(data, engine=\"fastparquet\", append=True)        def _write(self, data: Any):          self.write_with_kwargs(data)        def write_with_kwargs(self, data: Any, job_id: Optional[JobId] = None, **write_kwargs):          \"\"\"Write the data referenced by this data node.            Keyword arguments here which are also present in the Data Node config will overwrite them.            Parameters:              data (Any): The data to write.              job_id (JobId^): An optional identifier of the writer.              **write_kwargs (dict[str, any]): The keyword arguments passed to the function                  `pandas.DataFrame.to_parquet()`.          \"\"\"          kwargs = {              self.__ENGINE_PROPERTY: self.properties[self.__ENGINE_PROPERTY],              self.__COMPRESSION_PROPERTY: self.properties[self.__COMPRESSION_PROPERTY],          }          kwargs.update(self.properties[self.__WRITE_KWARGS_PROPERTY])          kwargs.update(write_kwargs)          if isinstance(data, (pd.DataFrame, modin_pd.DataFrame)):              data.to_parquet(self._path, **kwargs)          else:              pd.DataFrame(data).to_parquet(self._path, **kwargs)          self.track_edit(timestamp=datetime.now(), job_id=job_id)        def read_with_kwargs(self, **read_kwargs):          \"\"\"Read data from this data node.            Keyword arguments here which are also present in the Data Node config will overwrite them.            Parameters:              **read_kwargs (dict[str, any]): The keyword arguments passed to the function                  `pandas.read_parquet()`.          \"\"\"          # return None if data was never written          if not self.last_edit_date:              self._DataNode__logger.warning(                  f\"Data node {self.id} from config {self.config_id} is being read but has never been written.\"              )              return None            kwargs = self.properties[self.__READ_KWARGS_PROPERTY]          kwargs.update(              {                  self.__ENGINE_PROPERTY: self.properties[self.__ENGINE_PROPERTY],              }          )          kwargs.update(read_kwargs)            if self.properties[self.__EXPOSED_TYPE_PROPERTY] == self.__EXPOSED_TYPE_PANDAS:              return self._read_as_pandas_dataframe(kwargs)          if self.properties[self.__EXPOSED_TYPE_PROPERTY] == self.__EXPOSED_TYPE_MODIN:              return self._read_as_modin_dataframe(kwargs)          if self.properties[self.__EXPOSED_TYPE_PROPERTY] == self.__EXPOSED_TYPE_NUMPY:              return self._read_as_numpy(kwargs)          return self._read_as(kwargs) "}
{"text": "from datetime import datetime, timedelta  from inspect import isclass  from typing import Any, Dict, List, Optional, Set, Tuple, Union    from taipy.config.common.scope import Scope    from .._version._version_manager_factory import _VersionManagerFactory  from ..common._mongo_connector import _connect_mongodb  from ..data.operator import JoinOperator, Operator  from ..exceptions.exceptions import InvalidCustomDocument, MissingRequiredProperty  from .data_node import DataNode  from .data_node_id import DataNodeId, Edit      class MongoCollectionDataNode(DataNode):      \"\"\"Data Node stored in a Mongo collection.        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. Note that the              _properties_ parameter must at least contain an entry for _\"db_name\"_ and _\"collection_name\"_:                - _\"db_name\"_ `(str)`: The database name.\\n              - _\"collection_name\"_ `(str)`: The collection in the database to read from and to write the data to.\\n              - _\"custom_document\"_ `(Any)`: The custom document class to store, encode, and decode data when reading and                  writing to a Mongo collection.\\n              - _\"db_username\"_ `(str)`: The database username.\\n              - _\"db_password\"_ `(str)`: The database password.\\n              - _\"db_host\"_ `(str)`: The database host. The default value is _\"localhost\"_.\\n              - _\"db_port\"_ `(int)`: The database port. The default value is 27017.\\n              - _\"db_driver\"_ `(str)`: The database driver.\\n              - _\"db_extra_args\"_ `(Dict[str, Any])`: A dictionary of additional arguments to be passed into database                  connection string.\\n      \"\"\"        __STORAGE_TYPE = \"mongo_collection\"        __DB_NAME_KEY = \"db_name\"      __COLLECTION_KEY = \"collection_name\"      __DB_USERNAME_KEY = \"db_username\"      __DB_PASSWORD_KEY = \"db_password\"      __DB_HOST_KEY = \"db_host\"      __DB_PORT_KEY = \"db_port\"      __DB_EXTRA_ARGS_KEY = \"db_extra_args\"      __DB_DRIVER_KEY = \"db_driver\"        __DB_HOST_DEFAULT = \"localhost\"      __DB_PORT_DEFAULT = 27017        _CUSTOM_DOCUMENT_PROPERTY = \"custom_document\"      _REQUIRED_PROPERTIES: List[str] = [          __DB_NAME_KEY,          __COLLECTION_KEY,      ]        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: Dict = None,      ):          if properties is None:              properties = {}          required = self._REQUIRED_PROPERTIES          if missing := set(required) - set(properties.keys()):              raise MissingRequiredProperty(                  f\"The following properties \" f\"{', '.join(x for x in missing)} were not informed and are required.\"              )            self._check_custom_document(properties[self._CUSTOM_DOCUMENT_PROPERTY])            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,          )            mongo_client = _connect_mongodb(              db_host=properties.get(self.__DB_HOST_KEY, self.__DB_HOST_DEFAULT),              db_port=properties.get(self.__DB_PORT_KEY, self.__DB_PORT_DEFAULT),              db_username=properties.get(self.__DB_USERNAME_KEY, \"\"),              db_password=properties.get(self.__DB_PASSWORD_KEY, \"\"),              db_driver=properties.get(self.__DB_DRIVER_KEY, \"\"),              db_extra_args=frozenset(properties.get(self.__DB_EXTRA_ARGS_KEY, {}).items()),          )          self.collection = mongo_client[properties.get(self.__DB_NAME_KEY, \"\")][              properties.get(self.__COLLECTION_KEY, \"\")          ]            self.custom_document = properties[self._CUSTOM_DOCUMENT_PROPERTY]            self._decoder = self._default_decoder          custom_decoder = getattr(self.custom_document, \"decode\", None)          if callable(custom_decoder):              self._decoder = custom_decoder            self._encoder = self._default_encoder          custom_encoder = getattr(self.custom_document, \"encode\", None)          if callable(custom_encoder):              self._encoder = custom_encoder            if not self._last_edit_date:              self._last_edit_date = datetime.now()            self._TAIPY_PROPERTIES.update(              {                  self.__COLLECTION_KEY,                  self.__DB_NAME_KEY,                  self._CUSTOM_DOCUMENT_PROPERTY,                  self.__DB_USERNAME_KEY,                  self.__DB_PASSWORD_KEY,                  self.__DB_HOST_KEY,                  self.__DB_PORT_KEY,                  self.__DB_DRIVER_KEY,                  self.__DB_EXTRA_ARGS_KEY,              }          )        def _check_custom_document(self, custom_document):          if not isclass(custom_document):              raise InvalidCustomDocument(                  f\"Invalid custom document of {custom_document}. Only custom class are supported.\"              )        @classmethod      def storage_type(cls) -> str:          return cls.__STORAGE_TYPE        def filter(self, operators: Optional[Union[List, Tuple]] = None, join_operator=JoinOperator.AND):          cursor = self._read_by_query(operators, join_operator)          return list(map(lambda row: self._decoder(row), cursor))        def _read(self):          cursor = self._read_by_query()          return list(map(lambda row: self._decoder(row), cursor))        def _read_by_query(self, operators: Optional[Union[List, Tuple]] = None, join_operator=JoinOperator.AND):          \"\"\"Query from a Mongo collection, exclude the _id field\"\"\"          if not operators:              return self.collection.find()            if not isinstance(operators, List):              operators = [operators]            conditions = []          for key, value, operator in operators:              if operator == Operator.EQUAL:                  conditions.append({key: value})              elif operator == Operator.NOT_EQUAL:                  conditions.append({key: {\"$ne\": value}})              elif operator == Operator.GREATER_THAN:                  conditions.append({key: {\"$gt\": value}})              elif operator == Operator.GREATER_OR_EQUAL:                  conditions.append({key: {\"$gte\": value}})              elif operator == Operator.LESS_THAN:                  conditions.append({key: {\"$lt\": value}})              elif operator == Operator.LESS_OR_EQUAL:                  conditions.append({key: {\"$lte\": value}})            query = {}          if join_operator == JoinOperator.AND:              query = {\"$and\": conditions}          elif join_operator == JoinOperator.OR:              query = {\"$or\": conditions}          else:              raise NotImplementedError(f\"Join operator {join_operator} is not supported.\")            return self.collection.find(query)        def _append(self, data) -> None:          \"\"\"Append data to a Mongo collection.\"\"\"          if not isinstance(data, list):              data = [data]            if len(data) == 0:              return            if isinstance(data[0], dict):              self._insert_dicts(data)          else:              self._insert_dicts([self._encoder(row) for row in data])        def _write(self, data) -> None:          \"\"\"Check data against a collection of types to handle insertion on the database.            Parameters:              data (Any): the data to write to the database.          \"\"\"          if not isinstance(data, list):              data = [data]            if len(data) == 0:              self.collection.drop()              return            if isinstance(data[0], dict):              self._insert_dicts(data, drop=True)          else:              self._insert_dicts([self._encoder(row) for row in data], drop=True)        def _insert_dicts(self, data: List[Dict], drop=False) -> None:          \"\"\"          This method will insert data contained in a list of dictionaries into a collection.            Parameters:              data (List[Dict]): a list of dictionaries              drop (bool): drop the collection before inserting the data to overwrite the data in the collection.          \"\"\"          if drop:              self.collection.drop()            self.collection.insert_many(data)        def _default_decoder(self, document: Dict) -> Any:          \"\"\"Decode a Mongo dictionary to a custom document object for reading.            Parameters:              document (Dict): the document dictionary return by Mongo query.          Returns:              A custom document object.          \"\"\"          return self.custom_document(**document)        def _default_encoder(self, document_object: Any) -> Dict:          \"\"\"Encode a custom document object to a dictionary for writing to MongoDB.            Args:              document_object: the custom document class.            Returns:              The document dictionary.          \"\"\"          return document_object.__dict__ "}
{"text": "from collections.abc import Hashable  from functools import reduce  from itertools import chain  from operator import and_, or_  from typing import Dict, Iterable, List, Tuple, Union    import modin.pandas as modin_pd  import numpy as np  import pandas as pd  from pandas.core.common import is_bool_indexer    from .operator import JoinOperator, Operator      class _FilterDataNode:      @staticmethod      def __is_pandas_object(data) -> bool:          return isinstance(data, (pd.DataFrame, modin_pd.DataFrame)) or isinstance(data, (pd.Series, modin_pd.DataFrame))        @staticmethod      def __is_multi_sheet_excel(data) -> bool:          if isinstance(data, Dict):              has_df_children = all([isinstance(e, (pd.DataFrame, modin_pd.DataFrame)) for e in data.values()])              has_list_children = all([isinstance(e, List) for e in data.values()])              has_np_array_children = all([isinstance(e, np.ndarray) for e in data.values()])              return has_df_children or has_list_children or has_np_array_children          return False        @staticmethod      def __is_list_of_dict(data) -> bool:          return all(isinstance(x, Dict) for x in data)        @staticmethod      def _filter_by_key(data, key):          if isinstance(key, int):              return _FilterDataNode.__getitem_int(data, key)            if isinstance(key, slice) or (isinstance(key, tuple) and any(isinstance(e, slice) for e in key)):              return _FilterDataNode.__getitem_slice(data, key)            if isinstance(key, Hashable):              return _FilterDataNode.__getitem_hashable(data, key)            if isinstance(key, (pd.DataFrame, modin_pd.DataFrame)):              return _FilterDataNode.__getitem_dataframe(data, key)            if is_bool_indexer(key):              return _FilterDataNode.__getitem_bool_indexer(data, key)            if isinstance(key, Iterable):              return _FilterDataNode.__getitem_iterable(data, key)            return None        @staticmethod      def __getitem_int(data, key):          return data[key]        @staticmethod      def __getitem_hashable(data, key):          if _FilterDataNode.__is_pandas_object(data) or _FilterDataNode.__is_multi_sheet_excel(data):              return data.get(key)          return [getattr(entry, key, None) for entry in data]        @staticmethod      def __getitem_slice(data, key):          return data[key]        @staticmethod      def __getitem_dataframe(data, key: Union[pd.DataFrame, modin_pd.DataFrame]):          if _FilterDataNode.__is_pandas_object(data):              return data[key]          if _FilterDataNode.__is_list_of_dict(data):              filtered_data = list()              for i, row in key.iterrows():                  filtered_row = dict()                  for col in row.index:                      filtered_row[col] = data[i][col] if row[col] else None                  filtered_data.append(filtered_row)              return filtered_data          return None        @staticmethod      def __getitem_bool_indexer(data, key):          if _FilterDataNode.__is_pandas_object(data):              return data[key]          return [e for i, e in enumerate(data) if key[i]]        @staticmethod      def __getitem_iterable(data, keys):          if _FilterDataNode.__is_pandas_object(data):              return data[keys]          filtered_data = []          for entry in data:              filtered_data.append({k: getattr(entry, k) for k in keys if hasattr(entry, k)})          return filtered_data        @staticmethod      def _filter(data, operators: Union[List, Tuple], join_operator=JoinOperator.AND):          if len(operators) == 0:              return data            if isinstance(data, Dict):              return {k: _FilterDataNode._filter(v, operators, join_operator) for k, v in data.items()}            if not ((isinstance(operators[0], list)) or (isinstance(operators[0], tuple))):              if isinstance(data, (pd.DataFrame, modin_pd.DataFrame)):                  return _FilterDataNode.__filter_dataframe_per_key_value(data, operators[0], operators[1], operators[2])              if isinstance(data, np.ndarray):                  list_operators = [operators]                  return _FilterDataNode.__filter_numpy_array(data, list_operators)              if isinstance(data, List):                  return _FilterDataNode.__filter_list_per_key_value(data, operators[0], operators[1], operators[2])          else:              if isinstance(data, (pd.DataFrame, modin_pd.DataFrame)):                  return _FilterDataNode.__filter_dataframe(data, operators, join_operator=join_operator)              if isinstance(data, np.ndarray):                  return _FilterDataNode.__filter_numpy_array(data, operators, join_operator=join_operator)              if isinstance(data, List):                  return _FilterDataNode.__filter_list(data, operators, join_operator=join_operator)          raise NotImplementedError        @staticmethod      def __filter_dataframe(          df_data: Union[pd.DataFrame, modin_pd.DataFrame], operators: Union[List, Tuple], join_operator=JoinOperator.AND      ):          filtered_df_data = []          if join_operator == JoinOperator.AND:              how = \"inner\"          elif join_operator == JoinOperator.OR:              how = \"outer\"          else:              return NotImplementedError          for key, value, operator in operators:              filtered_df_data.append(_FilterDataNode.__filter_dataframe_per_key_value(df_data, key, value, operator))            if isinstance(df_data, modin_pd.DataFrame):              if filtered_df_data:                  return _FilterDataNode.__modin_dataframe_merge(filtered_df_data, how)              return modin_pd.DataFrame()            return _FilterDataNode.__dataframe_merge(filtered_df_data, how) if filtered_df_data else pd.DataFrame()        @staticmethod      def __filter_dataframe_per_key_value(          df_data: Union[pd.DataFrame, modin_pd.DataFrame], key: str, value, operator: Operator      ):          df_by_col = df_data[key]          if operator == Operator.EQUAL:              df_by_col = df_by_col == value          if operator == Operator.NOT_EQUAL:              df_by_col = df_by_col != value          if operator == Operator.LESS_THAN:              df_by_col = df_by_col < value          if operator == Operator.LESS_OR_EQUAL:              df_by_col = df_by_col <= value          if operator == Operator.GREATER_THAN:              df_by_col = df_by_col > value          if operator == Operator.GREATER_OR_EQUAL:              df_by_col = df_by_col >= value          return df_data[df_by_col]        @staticmethod      def __dataframe_merge(df_list: List, how=\"inner\"):          return reduce(lambda df1, df2: pd.merge(df1, df2, how=how), df_list)        @staticmethod      def __modin_dataframe_merge(df_list: List, how=\"inner\"):          return reduce(lambda df1, df2: modin_pd.merge(df1, df2, how=how), df_list)        @staticmethod      def __filter_numpy_array(data: np.ndarray, operators: Union[List, Tuple], join_operator=JoinOperator.AND):          conditions = []          for key, value, operator in operators:              conditions.append(_FilterDataNode.__get_filter_condition_per_key_value(data, key, value, operator))            if join_operator == JoinOperator.AND:              join_conditions = reduce(and_, conditions)          elif join_operator == JoinOperator.OR:              join_conditions = reduce(or_, conditions)          else:              return NotImplementedError            return data[join_conditions]        @staticmethod      def __get_filter_condition_per_key_value(array_data: np.ndarray, key, value, operator: Operator):          if not isinstance(key, int):              key = int(key)            if operator == Operator.EQUAL:              return array_data[:, key] == value          if operator == Operator.NOT_EQUAL:              return array_data[:, key] != value          if operator == Operator.LESS_THAN:              return array_data[:, key] < value          if operator == Operator.LESS_OR_EQUAL:              return array_data[:, key] <= value          if operator == Operator.GREATER_THAN:              return array_data[:, key] > value          if operator == Operator.GREATER_OR_EQUAL:              return array_data[:, key] >= value            return NotImplementedError        @staticmethod      def __filter_list(list_data: List, operators: Union[List, Tuple], join_operator=JoinOperator.AND):          filtered_list_data = []          for key, value, operator in operators:              filtered_list_data.append(_FilterDataNode.__filter_list_per_key_value(list_data, key, value, operator))          if len(filtered_list_data) == 0:              return filtered_list_data          if join_operator == JoinOperator.AND:              return _FilterDataNode.__list_intersect(filtered_list_data)          elif join_operator == JoinOperator.OR:              merged_list = list(chain.from_iterable(filtered_list_data))              if all(isinstance(e, Dict) for e in merged_list):                  return list({frozenset(item.items()) for item in merged_list})              return list(set(merged_list))          else:              return NotImplementedError        @staticmethod      def __filter_list_per_key_value(list_data: List, key: str, value, operator: Operator):          filtered_list = []          for row in list_data:              if isinstance(row, Dict):                  row_value = row.get(key, None)              else:                  row_value = getattr(row, key, None)                if operator == Operator.EQUAL and row_value == value:                  filtered_list.append(row)              if operator == Operator.NOT_EQUAL and row_value != value:                  filtered_list.append(row)              if operator == Operator.LESS_THAN and row_value < value:                  filtered_list.append(row)              if operator == Operator.LESS_OR_EQUAL and row_value <= value:                  filtered_list.append(row)              if operator == Operator.GREATER_THAN and row_value > value:                  filtered_list.append(row)              if operator == Operator.GREATER_OR_EQUAL and row_value >= value:                  filtered_list.append(row)          return filtered_list        @staticmethod      def __list_intersect(list_data):          return list(set(list_data.pop()).intersection(*map(set, list_data))) "}
{"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 ..exceptions.exceptions import MissingReadFunction, MissingRequiredProperty, MissingWriteFunction  from .data_node import DataNode  from .data_node_id import DataNodeId, Edit      class GenericDataNode(DataNode):      \"\"\"Generic Data Node that uses custom read and write functions.        The read and write function for this data node type can be implemented is Python.        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 the 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. Note that the              _properties_ parameter must at least contain an entry for either _\"read_fct\"_ or              _\"write_fct\"_ representing the read and write functions.              Entries for _\"read_fct_args\"_ and _\"write_fct_args\"_ respectively represent              potential parameters for the _\"read_fct\"_ and _\"write_fct\"_ functions.      \"\"\"        __STORAGE_TYPE = \"generic\"      _OPTIONAL_READ_FUNCTION_PROPERTY = \"read_fct\"      __READ_FUNCTION_ARGS_PROPERTY = \"read_fct_args\"      _OPTIONAL_WRITE_FUNCTION_PROPERTY = \"write_fct\"      __WRITE_FUNCTION_ARGS_PROPERTY = \"write_fct_args\"      _REQUIRED_PROPERTIES: List[str] = []      _REQUIRED_AT_LEAST_ONE_PROPERTY: List[str] = [_OPTIONAL_READ_FUNCTION_PROPERTY, _OPTIONAL_WRITE_FUNCTION_PROPERTY]        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: Dict = None,      ):          if properties is None:              properties = {}          if missing := set(self._REQUIRED_PROPERTIES) - set(properties.keys()):              raise MissingRequiredProperty(                  f\"The following properties \" f\"{', '.join(x for x in missing)} were not informed and are required.\"              )            missing_optional_fcts = set(self._REQUIRED_AT_LEAST_ONE_PROPERTY) - set(properties.keys())          if len(missing_optional_fcts) == len(self._REQUIRED_AT_LEAST_ONE_PROPERTY):              raise MissingRequiredProperty(                  f\"None of the following properties \"                  f\"{', '.join(x for x in missing)} were informed and at least one must be populated.\"              )          for missing_optional_fct in missing_optional_fcts:              properties[missing_optional_fct] = 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 not self._last_edit_date:              self._last_edit_date = datetime.now()            self._TAIPY_PROPERTIES.update(              {                  self.__READ_FUNCTION_ARGS_PROPERTY,                  self.__WRITE_FUNCTION_ARGS_PROPERTY,                  self._OPTIONAL_READ_FUNCTION_PROPERTY,                  self._OPTIONAL_WRITE_FUNCTION_PROPERTY,              }          )        @classmethod      def storage_type(cls) -> str:          return cls.__STORAGE_TYPE        def _read(self):          if read_fct := self.properties[self._OPTIONAL_READ_FUNCTION_PROPERTY]:              if read_fct_args := self.properties.get(self.__READ_FUNCTION_ARGS_PROPERTY, None):                  if not isinstance(read_fct_args, list):                      return read_fct(*[read_fct_args])                  return read_fct(*read_fct_args)              return read_fct()          raise MissingReadFunction(f\"The read function is not defined in data node config {self.config_id}.\")        def _write(self, data: Any):          if write_fct := self.properties[self._OPTIONAL_WRITE_FUNCTION_PROPERTY]:              if write_fct_args := self.properties.get(self.__WRITE_FUNCTION_ARGS_PROPERTY, None):                  if not isinstance(write_fct_args, list):                      return write_fct(data, *[write_fct_args])                  return write_fct(data, *write_fct_args)              return write_fct(data)          raise MissingWriteFunction(f\"The write function is not defined in data node config {self.config_id}.\") "}
{"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": "import os  from collections import defaultdict  from datetime import datetime, timedelta  from os.path import isfile  from typing import Any, Dict, List, Optional, Set, Tuple, Union    import modin.pandas as modin_pd  import numpy as np  import pandas as pd  from openpyxl import load_workbook    from taipy.config.common.scope import Scope    from .._backup._backup import _replace_in_backup_file  from .._entity._reload import _self_reload  from .._version._version_manager_factory import _VersionManagerFactory  from ..exceptions.exceptions import ExposedTypeLengthMismatch, NonExistingExcelSheet, SheetNameLengthMismatch  from ..job.job_id import JobId  from ._abstract_file import _AbstractFileDataNode  from ._abstract_tabular import _AbstractTabularDataNode  from .data_node import DataNode  from .data_node_id import DataNodeId, Edit      class ExcelDataNode(DataNode, _AbstractFileDataNode, _AbstractTabularDataNode):      \"\"\"Data Node stored as an Excel file.        The Excel file format is _xlsx_.        Attributes:          config_id (str): Identifier of this 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.          path (str): The path to the Excel file.          properties (dict[str, Any]): A dictionary of additional properties. The _properties_              must have a _\"default_path\"_ or _\"path\"_ entry with the path of the Excel file:                - _\"default_path\"_ `(str)`: The path of the Excel file.\\n              - _\"has_header\"_ `(bool)`: If True, indicates that the Excel file has a header.\\n              - _\"sheet_name\"_ `(Union[List[str], str])`: The list of sheet names to be used. This                  can be a unique name.\\n              - _\"exposed_type\"_: The exposed type of the data read from Excel file. The default value is `pandas`.\\n      \"\"\"        __STORAGE_TYPE = \"excel\"      __EXPOSED_TYPE_PROPERTY = \"exposed_type\"      __EXPOSED_TYPE_NUMPY = \"numpy\"      __EXPOSED_TYPE_PANDAS = \"pandas\"      __EXPOSED_TYPE_MODIN = \"modin\"      __VALID_STRING_EXPOSED_TYPES = [__EXPOSED_TYPE_PANDAS, __EXPOSED_TYPE_MODIN, __EXPOSED_TYPE_NUMPY]      __PATH_KEY = \"path\"      __DEFAULT_DATA_KEY = \"default_data\"      __DEFAULT_PATH_KEY = \"default_path\"      __HAS_HEADER_PROPERTY = \"has_header\"      __SHEET_NAME_PROPERTY = \"sheet_name\"      _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: Dict = None,      ):          if properties is None:              properties = {}            default_value = properties.pop(self.__DEFAULT_DATA_KEY, None)          self._path = properties.get(self.__PATH_KEY, properties.get(self.__DEFAULT_PATH_KEY))          properties[self.__PATH_KEY] = self._path            if self.__SHEET_NAME_PROPERTY not in properties.keys():              properties[self.__SHEET_NAME_PROPERTY] = None          if self.__HAS_HEADER_PROPERTY not in properties.keys():              properties[self.__HAS_HEADER_PROPERTY] = True          if self.__EXPOSED_TYPE_PROPERTY not in properties.keys():              properties[self.__EXPOSED_TYPE_PROPERTY] = self.__EXPOSED_TYPE_PANDAS          self._check_exposed_type(properties[self.__EXPOSED_TYPE_PROPERTY], self.__VALID_STRING_EXPOSED_TYPES)            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 not self._path:              self._path = self._build_path(self.storage_type())              properties[self.__PATH_KEY] = self._path            if default_value is not None and not os.path.exists(self._path):              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.\",                      }                  )              )            if not self._last_edit_date and isfile(self._path):              self._last_edit_date = datetime.now()            self._TAIPY_PROPERTIES.update(              {                  self.__EXPOSED_TYPE_PROPERTY,                  self.__PATH_KEY,                  self.__DEFAULT_PATH_KEY,                  self.__DEFAULT_DATA_KEY,                  self.__HAS_HEADER_PROPERTY,                  self.__SHEET_NAME_PROPERTY,              }          )        @property  # type: ignore      @_self_reload(DataNode._MANAGER_NAME)      def path(self):          return self._path        @path.setter      def path(self, value):          tmp_old_path = self._path          self._path = value          self.properties[self.__PATH_KEY] = value          _replace_in_backup_file(old_file_path=tmp_old_path, new_file_path=self._path)        @classmethod      def storage_type(cls) -> str:          return cls.__STORAGE_TYPE        @staticmethod      def _check_exposed_type(exposed_type, valid_string_exposed_types):          if isinstance(exposed_type, str):              _AbstractTabularDataNode._check_exposed_type(exposed_type, valid_string_exposed_types)          elif isinstance(exposed_type, list):              for t in exposed_type:                  _AbstractTabularDataNode._check_exposed_type(t, valid_string_exposed_types)          elif isinstance(exposed_type, dict):              for t in exposed_type.values():                  _AbstractTabularDataNode._check_exposed_type(t, valid_string_exposed_types)        def _read(self):          if self.properties[self.__EXPOSED_TYPE_PROPERTY] == self.__EXPOSED_TYPE_PANDAS:              return self._read_as_pandas_dataframe()          if self.properties[self.__EXPOSED_TYPE_PROPERTY] == self.__EXPOSED_TYPE_MODIN:              return self._read_as_modin_dataframe()          if self.properties[self.__EXPOSED_TYPE_PROPERTY] == self.__EXPOSED_TYPE_NUMPY:              return self._read_as_numpy()          return self._read_as()        def __sheet_name_to_list(self, properties):          if properties[self.__SHEET_NAME_PROPERTY]:              sheet_names = properties[self.__SHEET_NAME_PROPERTY]          else:              excel_file = load_workbook(properties[self.__PATH_KEY])              sheet_names = excel_file.sheetnames              excel_file.close()          return sheet_names if isinstance(sheet_names, (List, Set, Tuple)) else [sheet_names]        def _read_as(self):          excel_file = load_workbook(self._path)          exposed_type = self.properties[self.__EXPOSED_TYPE_PROPERTY]          work_books = defaultdict()          sheet_names = excel_file.sheetnames          provided_sheet_names = self.__sheet_name_to_list(self.properties)            for sheet_name in provided_sheet_names:              if sheet_name not in sheet_names:                  raise NonExistingExcelSheet(sheet_name, self._path)            if isinstance(exposed_type, List):              if len(provided_sheet_names) != len(self.properties[self.__EXPOSED_TYPE_PROPERTY]):                  raise ExposedTypeLengthMismatch(                      f\"Expected {len(provided_sheet_names)} exposed types, got \"                      f\"{len(self.properties[self.__EXPOSED_TYPE_PROPERTY])}\"                  )            for i, sheet_name in enumerate(provided_sheet_names):              work_sheet = excel_file[sheet_name]              sheet_exposed_type = exposed_type                if not isinstance(sheet_exposed_type, str):                  if isinstance(exposed_type, dict):                      sheet_exposed_type = exposed_type.get(sheet_name, self.__EXPOSED_TYPE_PANDAS)                  elif isinstance(exposed_type, List):                      sheet_exposed_type = exposed_type[i]                    if isinstance(sheet_exposed_type, str):                      if sheet_exposed_type == self.__EXPOSED_TYPE_NUMPY:                          work_books[sheet_name] = self._read_as_pandas_dataframe(sheet_name).to_numpy()                      elif sheet_exposed_type == self.__EXPOSED_TYPE_PANDAS:                          work_books[sheet_name] = self._read_as_pandas_dataframe(sheet_name)                      continue                res = list()              for row in work_sheet.rows:                  res.append([col.value for col in row])              if self.properties[self.__HAS_HEADER_PROPERTY] and res:                  header = res.pop(0)                  for i, row in enumerate(res):                      res[i] = sheet_exposed_type(**dict([[h, r] for h, r in zip(header, row)]))              else:                  for i, row in enumerate(res):                      res[i] = sheet_exposed_type(*row)              work_books[sheet_name] = res            excel_file.close()            if len(provided_sheet_names) == 1:              return work_books[provided_sheet_names[0]]          return work_books        def _read_as_numpy(self):          sheets = self._read_as_pandas_dataframe()          if isinstance(sheets, dict):              return {sheet_name: df.to_numpy() for sheet_name, df in sheets.items()}          return sheets.to_numpy()        def _do_read_excel(self, engine, sheet_names, kwargs) -> pd.DataFrame:          df = pd.read_excel(              self._path,              sheet_name=sheet_names,              **kwargs,          )          # We are using pandas to load modin dataframes because of a modin issue          # https://github.com/modin-project/modin/issues/4924          if engine == \"modin\":              if isinstance(df, dict):  # Check if it s a multiple sheet Excel file                  for key, value in df.items():                      df[key] = modin_pd.DataFrame(value)                  return df              return modin_pd.DataFrame(df)          return df        def __get_sheet_names_and_header(self, sheet_names):          kwargs: Dict[str, Any] = {}          if sheet_names is None:              sheet_names = self.properties[self.__SHEET_NAME_PROPERTY]          if not self.properties[self.__HAS_HEADER_PROPERTY]:              kwargs[\"header\"] = None          return sheet_names, kwargs        def _read_as_pandas_dataframe(self, sheet_names=None) -> Union[Dict[Union[int, str], pd.DataFrame], pd.DataFrame]:          sheet_names, kwargs = self.__get_sheet_names_and_header(sheet_names)          try:              return self._do_read_excel(\"pandas\", sheet_names, kwargs)          except pd.errors.EmptyDataError:              return pd.DataFrame()        def _read_as_modin_dataframe(          self, sheet_names=None      ) -> Union[Dict[Union[int, str], modin_pd.DataFrame], modin_pd.DataFrame]:          sheet_names, kwargs = self.__get_sheet_names_and_header(sheet_names)          try:              if kwargs.get(\"header\", None):                  return modin_pd.read_excel(                      self._path,                      sheet_name=sheet_names,                      **kwargs,                  )              else:                  return self._do_read_excel(\"modin\", sheet_names, kwargs)          except pd.errors.EmptyDataError:              return modin_pd.DataFrame()        def __append_excel_with_single_sheet(self, append_excel_fct, *args, **kwargs):          sheet_name = self.properties.get(self.__SHEET_NAME_PROPERTY)            with pd.ExcelWriter(self._path, mode=\"a\", engine=\"openpyxl\", if_sheet_exists=\"overlay\") as writer:              if sheet_name:                  if not isinstance(sheet_name, str):                      sheet_name = sheet_name[0]                  append_excel_fct(                      writer, *args, **kwargs, sheet_name=sheet_name, startrow=writer.sheets[sheet_name].max_row                  )              else:                  sheet_name = list(writer.sheets.keys())[0]                  append_excel_fct(writer, *args, **kwargs, startrow=writer.sheets[sheet_name].max_row)        def __append_excel_with_multiple_sheets(self, data: Any, columns: List[str] = None):          with pd.ExcelWriter(self._path, mode=\"a\", engine=\"openpyxl\", if_sheet_exists=\"overlay\") as writer:              # Each key stands for a sheet name              for sheet_name in data.keys():                  if isinstance(data[sheet_name], np.ndarray):                      df = pd.DataFrame(data[sheet_name])                  else:                      df = data[sheet_name]                    if columns:                      data[sheet_name].columns = columns                    df.to_excel(                      writer, sheet_name=sheet_name, index=False, header=False, startrow=writer.sheets[sheet_name].max_row                  )        def _append(self, data: Any):          if isinstance(data, Dict) and all(              [isinstance(x, (pd.DataFrame, modin_pd.DataFrame, np.ndarray)) for x in data.values()]          ):              self.__append_excel_with_multiple_sheets(data)          elif isinstance(data, (pd.DataFrame, modin_pd.DataFrame)):              self.__append_excel_with_single_sheet(data.to_excel, index=False, header=False)          else:              self.__append_excel_with_single_sheet(pd.DataFrame(data).to_excel, index=False, header=False)        def __write_excel_with_single_sheet(self, write_excel_fct, *args, **kwargs):          sheet_name = self.properties.get(self.__SHEET_NAME_PROPERTY)          if sheet_name:              if not isinstance(sheet_name, str):                  if len(sheet_name) > 1:                      raise SheetNameLengthMismatch                  else:                      sheet_name = sheet_name[0]              write_excel_fct(*args, **kwargs, sheet_name=sheet_name)          else:              write_excel_fct(*args, **kwargs)        def __write_excel_with_multiple_sheets(self, data: Any, columns: List[str] = None):          with pd.ExcelWriter(self._path) as writer:              # Each key stands for a sheet name              for key in data.keys():                  if isinstance(data[key], np.ndarray):                      df = pd.DataFrame(data[key])                  else:                      df = data[key]                    if columns:                      data[key].columns = columns                    df.to_excel(writer, key, index=False)        def _write(self, data: Any):          if isinstance(data, Dict) and all(              [isinstance(x, (pd.DataFrame, modin_pd.DataFrame, np.ndarray)) for x in data.values()]          ):              self.__write_excel_with_multiple_sheets(data)          elif isinstance(data, (pd.DataFrame, modin_pd.DataFrame)):              self.__write_excel_with_single_sheet(data.to_excel, self._path, index=False)          else:              self.__write_excel_with_single_sheet(pd.DataFrame(data).to_excel, self._path, index=False)        def write_with_column_names(self, data: Any, columns: List[str] = None, job_id: Optional[JobId] = None):          \"\"\"Write a set of columns.            Parameters:              data (Any): The data to write.              columns (List[str]): The list of column names to write.              job_id (JobId^): An optional identifier of the writer.          \"\"\"          if isinstance(data, Dict) and all(              [isinstance(x, (pd.DataFrame, modin_pd.DataFrame, np.ndarray)) for x in data.values()]          ):              self.__write_excel_with_multiple_sheets(data, columns=columns)          else:              df = pd.DataFrame(data)              if columns:                  df.columns = columns              self.__write_excel_with_single_sheet(df.to_excel, self.path, index=False)          self.track_edit(timestamp=datetime.now(), job_id=job_id) "}
{"text": "import os  from typing import Dict, Iterable, List, Optional, Set, Union    from taipy.config._config import _Config  from taipy.config.common.scope import Scope  from taipy.config.config import Config    from .._backup._backup import _append_to_backup_file, _remove_from_backup_file  from .._manager._manager import _Manager  from .._version._version_mixin import _VersionMixin  from ..config.data_node_config import DataNodeConfig  from ..cycle.cycle_id import CycleId  from ..exceptions.exceptions import InvalidDataNodeType  from ..notification import Event, EventEntityType, EventOperation, Notifier, _make_event  from ..scenario.scenario_id import ScenarioId  from ..sequence.sequence_id import SequenceId  from ._abstract_file import _AbstractFileDataNode  from ._data_fs_repository import _DataFSRepository  from .data_node import DataNode  from .data_node_id import DataNodeId  from .pickle import PickleDataNode      class _DataManager(_Manager[DataNode], _VersionMixin):      __DATA_NODE_CLASS_MAP = DataNode._class_map()  # type: ignore      _ENTITY_NAME = DataNode.__name__      _EVENT_ENTITY_TYPE = EventEntityType.DATA_NODE      _repository: _DataFSRepository      __NAME_KEY = \"name\"        @classmethod      def _bulk_get_or_create(          cls,          data_node_configs: List[DataNodeConfig],          cycle_id: Optional[CycleId] = None,          scenario_id: Optional[ScenarioId] = None,      ) -> Dict[DataNodeConfig, DataNode]:          data_node_configs = [Config.data_nodes[dnc.id] for dnc in data_node_configs]          dn_configs_and_owner_id = []          for dn_config in data_node_configs:              scope = dn_config.scope              owner_id: Union[Optional[SequenceId], Optional[ScenarioId], Optional[CycleId]]              if scope == Scope.SCENARIO:                  owner_id = scenario_id              elif scope == Scope.CYCLE:                  owner_id = cycle_id              else:                  owner_id = None              dn_configs_and_owner_id.append((dn_config, owner_id))            data_nodes = cls._repository._get_by_configs_and_owner_ids(              dn_configs_and_owner_id, cls._build_filters_with_version(None)          )            return {              dn_config: data_nodes.get((dn_config, owner_id)) or cls._create_and_set(dn_config, owner_id, None)              for dn_config, owner_id in dn_configs_and_owner_id          }        @classmethod      def _create_and_set(          cls, data_node_config: DataNodeConfig, owner_id: Optional[str], parent_ids: Optional[Set[str]]      ) -> DataNode:          data_node = cls.__create(data_node_config, owner_id, parent_ids)          cls._set(data_node)          if isinstance(data_node, _AbstractFileDataNode):              _append_to_backup_file(new_file_path=data_node._path)          Notifier.publish(_make_event(data_node, EventOperation.CREATION))          return data_node        @classmethod      def __create(          cls, data_node_config: DataNodeConfig, owner_id: Optional[str], parent_ids: Optional[Set[str]]      ) -> DataNode:          try:              version = cls._get_latest_version()              props = data_node_config._properties.copy()                if data_node_config.storage_type:                  storage_type = data_node_config.storage_type              else:                  storage_type = Config.sections[DataNodeConfig.name][_Config.DEFAULT_KEY].storage_type                return cls.__DATA_NODE_CLASS_MAP[storage_type](                  config_id=data_node_config.id,                  scope=data_node_config.scope or DataNodeConfig._DEFAULT_SCOPE,                  validity_period=data_node_config.validity_period,                  owner_id=owner_id,                  parent_ids=parent_ids,                  version=version,                  properties=props,              )          except KeyError:              raise InvalidDataNodeType(data_node_config.storage_type)        @classmethod      def _get_all(cls, version_number: Optional[str] = None) -> List[DataNode]:          \"\"\"          Returns all entities.          \"\"\"          filters = cls._build_filters_with_version(version_number)          return cls._repository._load_all(filters)        @classmethod      def _clean_pickle_file(cls, data_node: DataNode):          if not isinstance(data_node, PickleDataNode):              return          if data_node.is_generated and os.path.exists(data_node.path):              os.remove(data_node.path)        @classmethod      def _clean_pickle_files(cls, data_nodes: Iterable[DataNode]):          for data_node in data_nodes:              cls._clean_pickle_file(data_node)        @classmethod      def _remove_dn_file_path_in_backup_file(cls, data_node: DataNode):          if isinstance(data_node, _AbstractFileDataNode):              _remove_from_backup_file(to_remove_file_path=data_node.path)        @classmethod      def _remove_dn_file_paths_in_backup_file(cls, data_nodes: Iterable[DataNode]):          for data_node in data_nodes:              cls._remove_dn_file_path_in_backup_file(data_node)        @classmethod      def _delete(cls, data_node_id: DataNodeId):          data_node = cls._get(data_node_id, None)          if data_node:              cls._clean_pickle_file(data_node)              cls._remove_dn_file_path_in_backup_file(data_node)          super()._delete(data_node_id)        @classmethod      def _delete_many(cls, data_node_ids: Iterable[DataNodeId]):          data_nodes = []          for data_node_id in data_node_ids:              if data_node := cls._get(data_node_id):                  data_nodes.append(data_node)          cls._clean_pickle_files(data_nodes)          cls._remove_dn_file_paths_in_backup_file(data_nodes)          super()._delete_many(data_node_ids)        @classmethod      def _delete_all(cls):          data_nodes = cls._get_all()          cls._clean_pickle_files(data_nodes)          cls._remove_dn_file_paths_in_backup_file(data_nodes)          super()._delete_all()        @classmethod      def _delete_by_version(cls, version_number: str):          data_nodes = cls._get_all(version_number)          cls._clean_pickle_files(data_nodes)          cls._remove_dn_file_paths_in_backup_file(data_nodes)          cls._repository._delete_by(attribute=\"version\", value=version_number)          Notifier.publish(              Event(EventEntityType.DATA_NODE, EventOperation.DELETION, metadata={\"delete_by_version\": version_number})          )        @classmethod      def _get_by_config_id(cls, config_id: str, version_number: Optional[str] = None) -> List[DataNode]:          \"\"\"          Get all datanodes by its config id.          \"\"\"          filters = cls._build_filters_with_version(version_number)          if not filters:              filters = [{}]          for fil in filters:              fil.update({\"config_id\": config_id})          return cls._repository._load_all(filters) "}
{"text": "from datetime import datetime, timedelta  from typing import Any, Dict, List, Optional, Set, Tuple, Union    import modin.pandas as modin_pd  import numpy as np  import pandas as pd  from sqlalchemy import MetaData, Table    from taipy.config.common.scope import Scope    from .._version._version_manager_factory import _VersionManagerFactory  from ..exceptions.exceptions import MissingRequiredProperty  from ._abstract_sql import _AbstractSQLDataNode  from .data_node_id import DataNodeId, Edit      class SQLTableDataNode(_AbstractSQLDataNode):      \"\"\"Data Node stored in a SQL table.        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. Note that the              _properties_ parameter must at least contain an entry for _\"db_name\"_, _\"db_engine\"_, _\"table_name\"_:                - _\"db_name\"_ `(str)`: The database name, or the name of the SQLite database file.              - _\"db_engine\"_ `(str)`: The database engine. For now, the accepted values are _\"sqlite\"_, _\"mssql\"_,                  _\"mysql\"_, or _\"postgresql\"_.              - _\"table_name\"_ `(str)`: The name of the SQL table.              - _\"db_username\"_ `(str)`: The database username.              - _\"db_password\"_ `(str)`: The database password.              - _\"db_host\"_ `(str)`: The database host. The default value is _\"localhost\"_.              - _\"db_port\"_ `(int)`: The database port. The default value is 1433.              - _\"db_driver\"_ `(str)`: The database driver.              - _\"sqlite_folder_path\"_ (str): The path to the folder that contains SQLite file. The default value                  is the current working folder.              - _\"sqlite_file_extension\"_ (str): The filename extension of the SQLite file. The default value is \".db\".              - _\"db_extra_args\"_ `(Dict[str, Any])`: A dictionary of additional arguments to be passed into database                  connection string.              - _\"exposed_type\"_: The exposed type of the data read from SQL query. The default value is `pandas`.      \"\"\"        __STORAGE_TYPE = \"sql_table\"      __TABLE_KEY = \"table_name\"        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: Optional[List[Edit]] = None,          version: Optional[str] = None,          validity_period: Optional[timedelta] = None,          edit_in_progress: bool = False,          editor_id: Optional[str] = None,          editor_expiration_date: Optional[datetime] = None,          properties: Optional[Dict] = None,      ):          if properties is None:              properties = {}          if properties.get(self.__TABLE_KEY) is None:              raise MissingRequiredProperty(f\"Property {self.__TABLE_KEY} is not informed and is required.\")          super().__init__(              config_id,              scope,              id=id,              owner_id=owner_id,              parent_ids=parent_ids,              last_edit_date=last_edit_date,              edits=edits,              version=version or _VersionManagerFactory._build_manager()._get_latest_version(),              validity_period=validity_period,              edit_in_progress=edit_in_progress,              editor_id=editor_id,              editor_expiration_date=editor_expiration_date,              properties=properties,          )          self._TAIPY_PROPERTIES.update({self.__TABLE_KEY})        @classmethod      def storage_type(cls) -> str:          return cls.__STORAGE_TYPE        def _get_base_read_query(self) -> str:          return f\"SELECT * FROM {self.properties[self.__TABLE_KEY]}\"        def _do_append(self, data, engine, connection) -> None:          self.__insert_data(data, engine, connection)        def _do_write(self, data, engine, connection) -> None:          self.__insert_data(data, engine, connection, delete_table=True)        def __insert_data(self, data, engine, connection, delete_table: bool = False) -> None:          \"\"\"          Insert data into a SQL table.            Parameters:              data (List[Dict]): a list of dictionaries, where each dictionary represents a row of the table.              table: a SQLAlchemy object that represents a table.              connection: a SQLAlchemy connection to write the data.              delete_table (bool): indicates if the table should be deleted before inserting the data.          \"\"\"          table = self._create_table(engine)          if isinstance(data, (modin_pd.DataFrame, pd.DataFrame)):              self.__insert_dataframe(data, table, connection, delete_table)              return            if isinstance(data, np.ndarray):              data = data.tolist()          if not isinstance(data, list):              data = [data]            if len(data) == 0:              self.__delete_all_rows(table, connection, delete_table)              return            if isinstance(data[0], (tuple, list)):              self.__insert_tuples(data, table, connection, delete_table)          elif isinstance(data[0], dict):              self.__insert_dicts(data, table, connection, delete_table)          # If data is a primitive type, it will be inserted as a tuple of one element.          else:              self.__insert_tuples([(x,) for x in data], table, connection, delete_table)        def _create_table(self, engine) -> Table:          return Table(              self.properties[self.__TABLE_KEY],              MetaData(),              autoload_with=engine,          )        @classmethod      def __insert_dicts(cls, data: List[Dict], table: Any, connection: Any, delete_table: bool) -> None:          \"\"\"          This method will insert the data contained in a list of dictionaries into a table. The query itself is handled          by SQLAlchemy, so it's only needed to pass the correct data type.          \"\"\"          cls.__delete_all_rows(table, connection, delete_table)          connection.execute(table.insert(), data)        @classmethod      def __insert_dataframe(          cls, df: Union[modin_pd.DataFrame, pd.DataFrame], table: Any, connection: Any, delete_table: bool      ) -> None:          cls.__insert_dicts(df.to_dict(orient=\"records\"), table, connection, delete_table)        @classmethod      def __insert_tuples(cls, data: List[Union[Tuple, List]], table: Any, connection: Any, delete_table: bool) -> None:          \"\"\"          This method will look up the length of the first object of the list and build the insert through          creation of a string of '?' equivalent to the length of the element. The '?' character is used as          placeholder for a tuple of same size.          \"\"\"          cls.__delete_all_rows(table, connection, delete_table)          markers = \",\".join(\"?\" * len(data[0]))          ins = \"INSERT INTO {tablename} VALUES ({markers})\"          ins = ins.format(tablename=table.name, markers=markers)          connection.execute(ins, data)        @classmethod      def __delete_all_rows(cls, table: Any, connection: Any, delete_table: bool) -> None:          if delete_table:              connection.execute(table.delete()) "}
{"text": "import csv  import os  from datetime import datetime, timedelta  from os.path import isfile  from typing import Any, Dict, List, Optional, Set    import modin.pandas as modin_pd  import numpy as np  import pandas as pd    from taipy.config.common.scope import Scope    from .._backup._backup import _replace_in_backup_file  from .._entity._reload import _self_reload  from .._version._version_manager_factory import _VersionManagerFactory  from ..job.job_id import JobId  from ._abstract_file import _AbstractFileDataNode  from ._abstract_tabular import _AbstractTabularDataNode  from .data_node import DataNode  from .data_node_id import DataNodeId, Edit      class CSVDataNode(DataNode, _AbstractFileDataNode, _AbstractTabularDataNode):      \"\"\"Data Node stored as a CSV file.        Attributes:          config_id (str): Identifier of the data node configuration. This string 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.          path (str): The path to the CSV file.          properties (dict[str, Any]): A dictionary of additional properties. The _properties_              must have a _\"default_path\"_ or _\"path\"_ entry with the path of the CSV file:                - _\"default_path\"_ `(str)`: The default path of the CSV file.\\n              - _\"encoding\"_ `(str)`: The encoding of the CSV file. The default value is `utf-8`.\\n              - _\"default_data\"_: The default data of the data nodes instantiated from this csv data node.\\n              - _\"has_header\"_ `(bool)`: If True, indicates that the CSV file has a header.\\n              - _\"exposed_type\"_: The exposed type of the data read from CSV file. The default value is `pandas`.\\n      \"\"\"        __STORAGE_TYPE = \"csv\"      __EXPOSED_TYPE_PROPERTY = \"exposed_type\"      __EXPOSED_TYPE_NUMPY = \"numpy\"      __EXPOSED_TYPE_PANDAS = \"pandas\"      __EXPOSED_TYPE_MODIN = \"modin\"      __VALID_STRING_EXPOSED_TYPES = [__EXPOSED_TYPE_PANDAS, __EXPOSED_TYPE_MODIN, __EXPOSED_TYPE_NUMPY]      __PATH_KEY = \"path\"      __DEFAULT_PATH_KEY = \"default_path\"      __ENCODING_KEY = \"encoding\"      __DEFAULT_DATA_KEY = \"default_data\"      __HAS_HEADER_PROPERTY = \"has_header\"      _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: Optional[List[Edit]] = None,          version: Optional[str] = None,          validity_period: Optional[timedelta] = None,          edit_in_progress: bool = False,          editor_id: Optional[str] = None,          editor_expiration_date: Optional[datetime] = None,          properties: Optional[Dict] = None,      ):          if properties is None:              properties = {}            default_value = properties.pop(self.__DEFAULT_DATA_KEY, None)            if self.__ENCODING_KEY not in properties.keys():              properties[self.__ENCODING_KEY] = \"utf-8\"            if self.__HAS_HEADER_PROPERTY not in properties.keys():              properties[self.__HAS_HEADER_PROPERTY] = True            if self.__EXPOSED_TYPE_PROPERTY not in properties.keys():              properties[self.__EXPOSED_TYPE_PROPERTY] = self.__EXPOSED_TYPE_PANDAS          self._check_exposed_type(properties[self.__EXPOSED_TYPE_PROPERTY], self.__VALID_STRING_EXPOSED_TYPES)            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,          )          self._path = properties.get(self.__PATH_KEY, properties.get(self.__DEFAULT_PATH_KEY))          if not self._path:              self._path = self._build_path(self.storage_type())          properties[self.__PATH_KEY] = self._path            if not self._last_edit_date and isfile(self._path):              self._last_edit_date = datetime.now()          if default_value is not None and not os.path.exists(self._path):              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.__EXPOSED_TYPE_PROPERTY,                  self.__PATH_KEY,                  self.__DEFAULT_PATH_KEY,                  self.__ENCODING_KEY,                  self.__DEFAULT_DATA_KEY,                  self.__HAS_HEADER_PROPERTY,              }          )        @classmethod      def storage_type(cls) -> str:          return cls.__STORAGE_TYPE        @property  # type: ignore      @_self_reload(DataNode._MANAGER_NAME)      def path(self):          return self._path        @path.setter      def path(self, value):          tmp_old_path = self._path          self._path = value          self.properties[self.__PATH_KEY] = value          _replace_in_backup_file(old_file_path=tmp_old_path, new_file_path=self._path)        def _read(self):          if self.properties[self.__EXPOSED_TYPE_PROPERTY] == self.__EXPOSED_TYPE_PANDAS:              return self._read_as_pandas_dataframe()          if self.properties[self.__EXPOSED_TYPE_PROPERTY] == self.__EXPOSED_TYPE_MODIN:              return self._read_as_modin_dataframe()          if self.properties[self.__EXPOSED_TYPE_PROPERTY] == self.__EXPOSED_TYPE_NUMPY:              return self._read_as_numpy()          return self._read_as()        def _read_as(self):          custom_class = self.properties[self.__EXPOSED_TYPE_PROPERTY]          with open(self._path, encoding=self.properties[self.__ENCODING_KEY]) as csvFile:              res = list()              if self.properties[self.__HAS_HEADER_PROPERTY]:                  reader = csv.DictReader(csvFile)                  for line in reader:                      res.append(custom_class(**line))              else:                  reader = csv.reader(                      csvFile,                  )                  for line in reader:                      res.append(custom_class(*line))              return res        def _read_as_numpy(self) -> np.ndarray:          return self._read_as_pandas_dataframe().to_numpy()        def _read_as_pandas_dataframe(          self, usecols: Optional[List[int]] = None, column_names: Optional[List[str]] = None      ) -> pd.DataFrame:          try:              if self.properties[self.__HAS_HEADER_PROPERTY]:                  if column_names:                      return pd.read_csv(self._path, encoding=self.properties[self.__ENCODING_KEY])[column_names]                  return pd.read_csv(self._path, encoding=self.properties[self.__ENCODING_KEY])              else:                  if usecols:                      return pd.read_csv(                          self._path, encoding=self.properties[self.__ENCODING_KEY], header=None, usecols=usecols                      )                  return pd.read_csv(self._path, encoding=self.properties[self.__ENCODING_KEY], header=None)          except pd.errors.EmptyDataError:              return pd.DataFrame()        def _read_as_modin_dataframe(          self, usecols: Optional[List[int]] = None, column_names: Optional[List[str]] = None      ) -> modin_pd.DataFrame:          try:              if self.properties[self.__HAS_HEADER_PROPERTY]:                  if column_names:                      return modin_pd.read_csv(self._path, encoding=self.properties[self.__ENCODING_KEY])[column_names]                  return modin_pd.read_csv(self._path, encoding=self.properties[self.__ENCODING_KEY])              else:                  if usecols:                      return modin_pd.read_csv(                          self._path, header=None, usecols=usecols, encoding=self.properties[self.__ENCODING_KEY]                      )                  return modin_pd.read_csv(self._path, header=None, encoding=self.properties[self.__ENCODING_KEY])          except pd.errors.EmptyDataError:              return modin_pd.DataFrame()        def _append(self, data: Any):          if isinstance(data, (pd.DataFrame, modin_pd.DataFrame)):              data.to_csv(self._path, mode=\"a\", index=False, encoding=self.properties[self.__ENCODING_KEY], header=False)          else:              pd.DataFrame(data).to_csv(                  self._path, mode=\"a\", index=False, encoding=self.properties[self.__ENCODING_KEY], header=False              )        def _write(self, data: Any):          if isinstance(data, (pd.DataFrame, modin_pd.DataFrame)):              data.to_csv(self._path, index=False, encoding=self.properties[self.__ENCODING_KEY])          else:              pd.DataFrame(data).to_csv(self._path, index=False, encoding=self.properties[self.__ENCODING_KEY])        def write_with_column_names(self, data: Any, columns: Optional[List[str]] = None, job_id: Optional[JobId] = None):          \"\"\"Write a selection of columns.            Parameters:              data (Any): The data to write.              columns (Optional[List[str]]): The list of column names to write.              job_id (JobId^): An optional identifier of the writer.          \"\"\"          if not columns:              df = pd.DataFrame(data)          else:              df = pd.DataFrame(data, columns=columns)          df.to_csv(self._path, index=False, encoding=self.properties[self.__ENCODING_KEY])          self.track_edit(timestamp=datetime.now(), job_id=job_id) "}
{"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": "import os  import pickle  from datetime import datetime, timedelta  from typing import Any, List, Optional, Set    import modin.pandas as pd    from taipy.config.common.scope import Scope    from .._backup._backup import _replace_in_backup_file  from .._entity._reload import _self_reload  from .._version._version_manager_factory import _VersionManagerFactory  from ._abstract_file import _AbstractFileDataNode  from .data_node import DataNode  from .data_node_id import DataNodeId, Edit      class PickleDataNode(DataNode, _AbstractFileDataNode):      \"\"\"Data Node stored as a pickle file.        Attributes:          config_id (str): Identifier of the data node configuration. It must be a valid Python              identifer.          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 a pickle data node, if the _properties_ dictionary contains a              _\"default_data\"_ entry, the data node is automatically written with the corresponding              _\"default_data\"_ value.              If the _properties_ dictionary contains a _\"default_path\"_ or _\"path\"_ entry, the data will be stored              using the corresponding value as the name of the pickle file.      \"\"\"        __STORAGE_TYPE = \"pickle\"      __PATH_KEY = \"path\"      __DEFAULT_PATH_KEY = \"default_path\"      __DEFAULT_DATA_KEY = \"default_data\"      __IS_GENERATED_KEY = \"is_generated\"      _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: Optional[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_KEY, None)          self._path = properties.get(self.__PATH_KEY, properties.get(self.__DEFAULT_PATH_KEY))          if self._path is not None:              properties[self.__PATH_KEY] = self._path          self._is_generated = properties.get(self.__IS_GENERATED_KEY, self._path is None)          properties[self.__IS_GENERATED_KEY] = self._is_generated          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 self._path is None:              self._path = self._build_path(self.storage_type())          if not self._last_edit_date and os.path.exists(self._path):              self._last_edit_date = datetime.now()          if default_value is not None and not os.path.exists(self._path):              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.__PATH_KEY,                  self.__DEFAULT_PATH_KEY,                  self.__DEFAULT_DATA_KEY,                  self.__IS_GENERATED_KEY,              }          )        @classmethod      def storage_type(cls) -> str:          return cls.__STORAGE_TYPE        @property  # type: ignore      @_self_reload(DataNode._MANAGER_NAME)      def path(self) -> Any:          return self._path        @path.setter      def path(self, value):          tmp_old_path = self._path          self._path = value          self.properties[self.__PATH_KEY] = value          self.properties[self.__IS_GENERATED_KEY] = False          _replace_in_backup_file(old_file_path=tmp_old_path, new_file_path=self._path)        @property  # type: ignore      @_self_reload(DataNode._MANAGER_NAME)      def is_generated(self) -> bool:          return self._is_generated        def _read(self):          os.environ[\"MODIN_PERSISTENT_PICKLE\"] = \"True\"          with open(self._path, \"rb\") as pf:              return pickle.load(pf)        def _write(self, data):          if isinstance(data, (pd.DataFrame, pd.Series)):              os.environ[\"MODIN_PERSISTENT_PICKLE\"] = \"True\"          with open(self._path, \"wb\") as pf:              pickle.dump(data, pf) "}
{"text": "from datetime import datetime, timedelta  from typing import Dict, List, Optional, Set    from sqlalchemy import text    from taipy.config.common.scope import Scope    from .._version._version_manager_factory import _VersionManagerFactory  from ..exceptions.exceptions import MissingAppendQueryBuilder, MissingRequiredProperty  from ._abstract_sql import _AbstractSQLDataNode  from .data_node_id import DataNodeId, Edit      class SQLDataNode(_AbstractSQLDataNode):      \"\"\"Data Node stored in a SQL database.        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. Note that the              _properties_ parameter must at least contain an entry for _\"db_name\"_, _\"db_engine\"_, _\"read_query\"_,              and _\"write_query_builder\"_:                - _\"db_name\"_ `(str)`: The database name, or the name of the SQLite database file.              - _\"db_engine\"_ `(str)`: The database engine. Possible values are _\"sqlite\"_, _\"mssql\"_, _\"mysql\"_, or                  _\"postgresql\"_.              - _\"read_query\"_ `(str)`: The SQL query string used to read the data from the database.              - _\"write_query_builder\"_ `(Callable)`: A callback function that takes the data as an input parameter and                  returns a list of SQL queries to be executed when writing data to the data node.              - _\"append_query_builder\"_ `(Callable)`: A callback function that takes the data as an input parameter and                  returns a list of SQL queries to be executed when appending data to the data node.              - _\"db_username\"_ `(str)`: The database username.              - _\"db_password\"_ `(str)`: The database password.              - _\"db_host\"_ `(str)`: The database host. The default value is _\"localhost\"_.              - _\"db_port\"_ `(int)`: The database port. The default value is 1433.              - _\"db_driver\"_ `(str)`: The database driver.              - _\"sqlite_folder_path\"_ (str): The path to the folder that contains SQLite file. The default value                  is the current working folder.              - _\"sqlite_file_extension\"_ (str): The filename extension of the SQLite file. The default value is \".db\".              - _\"db_extra_args\"_ `(Dict[str, Any])`: A dictionary of additional arguments to be passed into database                  connection string.              - _\"exposed_type\"_: The exposed type of the data read from SQL query. The default value is `pandas`.      \"\"\"        __STORAGE_TYPE = \"sql\"      __READ_QUERY_KEY = \"read_query\"      _WRITE_QUERY_BUILDER_KEY = \"write_query_builder\"      _APPEND_QUERY_BUILDER_KEY = \"append_query_builder\"        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: Optional[List[Edit]] = None,          version: Optional[str] = None,          validity_period: Optional[timedelta] = None,          edit_in_progress: bool = False,          editor_id: Optional[str] = None,          editor_expiration_date: Optional[datetime] = None,          properties: Optional[Dict] = None,      ):          if properties is None:              properties = {}          if properties.get(self.__READ_QUERY_KEY) is None:              raise MissingRequiredProperty(f\"Property {self.__READ_QUERY_KEY} is not informed and is required.\")          if properties.get(self._WRITE_QUERY_BUILDER_KEY) is None:              raise MissingRequiredProperty(f\"Property {self._WRITE_QUERY_BUILDER_KEY} is not informed and is required.\")            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=properties,          )            self._TAIPY_PROPERTIES.update(              {                  self.__READ_QUERY_KEY,                  self._WRITE_QUERY_BUILDER_KEY,                  self._APPEND_QUERY_BUILDER_KEY,              }          )        @classmethod      def storage_type(cls) -> str:          return cls.__STORAGE_TYPE        def _get_base_read_query(self) -> str:          return self.properties.get(self.__READ_QUERY_KEY)        def _do_append(self, data, engine, connection) -> None:          if not self.properties.get(self._APPEND_QUERY_BUILDER_KEY):              raise MissingAppendQueryBuilder            queries = self.properties.get(self._APPEND_QUERY_BUILDER_KEY)(data)          self.__execute_queries(queries, connection)        def _do_write(self, data, engine, connection) -> None:          queries = self.properties.get(self._WRITE_QUERY_BUILDER_KEY)(data)          self.__execute_queries(queries, connection)        def __execute_queries(self, queries, connection) -> None:          if not isinstance(queries, List):              queries = [queries]          for query in queries:              if isinstance(query, str):                  connection.execute(text(query))              else:                  statement = query[0]                  parameters = query[1]                  connection.execute(text(statement), parameters) "}
{"text": "#  # Licensed under the Apache License, Version 2.0 (the \"License\"); you may not use this file except in compliance with  # the License. You may obtain a copy of the License at  #  #        http://www.apache.org/licenses/LICENSE-2.0  #  # Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on  # an \"AS IS\" BASIS, WITHOUT 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": "import os  import uuid  from abc import abstractmethod  from datetime import datetime, timedelta  from typing import Any, Dict, List, Optional, Set, Tuple, Union    import networkx as nx    from taipy.config.common._validate_id import _validate_id  from taipy.config.common.scope import Scope  from taipy.logger._taipy_logger import _TaipyLogger    from .._entity._entity import _Entity  from .._entity._labeled import _Labeled  from .._entity._properties import _Properties  from .._entity._reload import _Reloader, _self_reload, _self_setter  from .._version._version_manager_factory import _VersionManagerFactory  from ..common._warnings import _warn_deprecated  from ..exceptions.exceptions import DataNodeIsBeingEdited, NoData  from ..job.job_id import JobId  from ..notification.event import Event, EventEntityType, EventOperation, _make_event  from ._filter import _FilterDataNode  from .data_node_id import DataNodeId, Edit  from .operator import JoinOperator      class DataNode(_Entity, _Labeled):      \"\"\"Reference to a dataset.        A Data Node is an abstract class that holds metadata related to the dataset it refers to.      In particular, a data node holds the name, the scope, the owner identifier, the last      edit date, and some additional properties of the data.<br/>      A Data Node also contains information and methods needed to access the dataset. This      information depends on the type of storage, and it is held by subclasses (such as      SQL Data Node, CSV Data Node, ...).        !!! note          It is recommended not to instantiate subclasses of `DataNode` directly.        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.          name (str): A user-readable name 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 set of identifiers of the parent tasks.          last_edit_date (datetime): The date and time of the last modification.          edits (List[Edit^]): The list of Edits (an alias for dict) containing metadata about each              data edition including but not limited to timestamp, comments, job_id:              timestamp: The time instant of the writing              comments: Representation of a free text to explain or comment on a data change              job_id: Only populated when the data node is written by a task execution and corresponds to the job's id.              Additional metadata related to the edition made to the data node can also be provided in Edits.          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 the data node is locked for modification. 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.          kwargs: A dictionary of additional properties.      \"\"\"        _ID_PREFIX = \"DATANODE\"      __ID_SEPARATOR = \"_\"      __logger = _TaipyLogger._get_logger()      _REQUIRED_PROPERTIES: List[str] = []      _MANAGER_NAME = \"data\"      __PATH_KEY = \"path\"      __EDIT_TIMEOUT = 30        _TAIPY_PROPERTIES: Set[str] = set()        def __init__(          self,          config_id,          scope: Scope = Scope(Scope.SCENARIO),          id: Optional[DataNodeId] = None,          owner_id: Optional[str] = None,          parent_ids: Optional[Set[str]] = None,          last_edit_date: Optional[datetime] = None,          edits: Optional[List[Edit]] = None,          version: Optional[str] = None,          validity_period: Optional[timedelta] = None,          edit_in_progress: bool = False,          editor_id: Optional[str] = None,          editor_expiration_date: Optional[datetime] = None,          **kwargs,      ):          self.config_id = _validate_id(config_id)          self.id = id or DataNodeId(self.__ID_SEPARATOR.join([self._ID_PREFIX, self.config_id, str(uuid.uuid4())]))          self.owner_id = owner_id          self._parent_ids = parent_ids or set()          self._scope = scope          self._last_edit_date = last_edit_date          self._edit_in_progress = edit_in_progress          self._version = version or _VersionManagerFactory._build_manager()._get_latest_version()          self._validity_period = validity_period          self._editor_id: Optional[str] = editor_id          self._editor_expiration_date: Optional[datetime] = editor_expiration_date            # Track edits          self._edits = edits or list()            self._properties = _Properties(self, **kwargs)        def get_parents(self):          \"\"\"Get all parents of this data node.\"\"\"          from ... import core as tp            return tp.get_parents(self)        @property  # type: ignore      @_self_reload(_MANAGER_NAME)      def parent_ids(self):          \"\"\"List of parent ids of this data node.\"\"\"          return self._parent_ids        @property  # type: ignore      @_self_reload(_MANAGER_NAME)      def edits(self):          \"\"\"Get all `Edit^`s of this data node.\"\"\"          return self._edits        def get_last_edit(self) -> Optional[Edit]:          \"\"\"Get last `Edit^` of this data node.            Returns:              None if there has been no `Edit^` on this data node.          \"\"\"          if self._edits:              return self._edits[-1]          return None        @property  # type: ignore      @_self_reload(_MANAGER_NAME)      def last_edit_date(self):          last_modified_datetime = self.__get_last_modified_datetime()          if last_modified_datetime and last_modified_datetime > self._last_edit_date:              return last_modified_datetime          else:              return self._last_edit_date        @last_edit_date.setter  # type: ignore      @_self_setter(_MANAGER_NAME)      def last_edit_date(self, val):          self._last_edit_date = val        @property  # type: ignore      @_self_reload(_MANAGER_NAME)      def scope(self):          return self._scope        @scope.setter  # type: ignore      @_self_setter(_MANAGER_NAME)      def scope(self, val):          self._scope = val        @property  # type: ignore      @_self_reload(_MANAGER_NAME)      def validity_period(self) -> Optional[timedelta]:          return self._validity_period if self._validity_period else None        @validity_period.setter  # type: ignore      @_self_setter(_MANAGER_NAME)      def validity_period(self, val):          self._validity_period = val        @property  # type: ignore      @_self_reload(_MANAGER_NAME)      def expiration_date(self) -> datetime:          \"\"\"Datetime instant of the expiration date of this data node.\"\"\"          last_edit_date = self.last_edit_date          validity_period = self._validity_period            if not last_edit_date:              raise NoData(f\"Data node {self.id} from config {self.config_id} has not been written yet.\")            return last_edit_date + validity_period if validity_period else last_edit_date        @property  # type: ignore      def name(self) -> Optional[str]:          return self.properties.get(\"name\")        @name.setter  # type: ignore      def name(self, val):          self.properties[\"name\"] = val        @property      def version(self):          return self._version        @property      def cacheable(self):          \"\"\"Deprecated. Use `skippable` attribute of a `Task^` instead.\"\"\"          _warn_deprecated(\"cacheable\", suggest=\"the skippable feature\")          return self.properties.get(\"cacheable\", False)        @cacheable.setter      def cacheable(self, val):          _warn_deprecated(\"cacheable\", suggest=\"the skippable feature\")        @property  # type: ignore      @_self_reload(_MANAGER_NAME)      def edit_in_progress(self):          return self._edit_in_progress        @edit_in_progress.setter  # type: ignore      @_self_setter(_MANAGER_NAME)      def edit_in_progress(self, val):          self._edit_in_progress = val        @property  # type: ignore      @_self_reload(_MANAGER_NAME)      def editor_id(self):          return self._editor_id        @editor_id.setter  # type: ignore      @_self_setter(_MANAGER_NAME)      def editor_id(self, val):          self._editor_id = val        @property  # type: ignore      @_self_reload(_MANAGER_NAME)      def editor_expiration_date(self):          return self._editor_expiration_date        @editor_expiration_date.setter  # type: ignore      @_self_setter(_MANAGER_NAME)      def editor_expiration_date(self, val):          self._editor_expiration_date = val        @property  # type: ignore      @_self_reload(_MANAGER_NAME)      def job_ids(self):          \"\"\"List of the jobs having edited this data node.\"\"\"          return [edit.get(\"job_id\") for edit in self.edits if edit.get(\"job_id\")]        @property      def properties(self):          \"\"\"Dictionary of custom properties.\"\"\"          self._properties = _Reloader()._reload(self._MANAGER_NAME, self)._properties          return self._properties        def _get_user_properties(self) -> Dict[str, Any]:          \"\"\"Get user properties.\"\"\"          return {key: value for key, value in self.properties.items() if key not in self._TAIPY_PROPERTIES}        def __eq__(self, other):          return self.id == other.id        def __ne__(self, other):          return not self == other        def __hash__(self):          return hash(self.id)        def __getstate__(self):          return vars(self)        def __setstate__(self, state):          vars(self).update(state)        def __getattr__(self, attribute_name):          protected_attribute_name = _validate_id(attribute_name)          if protected_attribute_name in self._properties:              return self._properties[protected_attribute_name]          raise AttributeError(f\"{attribute_name} is not an attribute of data node {self.id}\")        def __get_last_modified_datetime(self) -> Optional[datetime]:          path = self._properties.get(self.__PATH_KEY, None)          if path and os.path.isfile(path):              return datetime.fromtimestamp(os.path.getmtime(path))            last_modified_datetime = None          if path and os.path.isdir(path):              for filename in os.listdir(path):                  filepath = os.path.join(path, filename)                  if os.path.isfile(filepath):                      file_mtime = datetime.fromtimestamp(os.path.getmtime(filepath))                        if last_modified_datetime is None or file_mtime > last_modified_datetime:                          last_modified_datetime = file_mtime            return last_modified_datetime        @classmethod      @abstractmethod      def storage_type(cls) -> str:          raise NotImplementedError        def read_or_raise(self) -> Any:          \"\"\"Read the data referenced by this data node.            Returns:              The data referenced by this data node.            Raises:              NoData^: If the data has not been written yet.          \"\"\"          if not self.last_edit_date:              raise NoData(f\"Data node {self.id} from config {self.config_id} has not been written yet.\")          return self._read()        def read(self) -> Any:          \"\"\"Read the data referenced by this data node.            Returns:              The data referenced by this data node. None if the data has not been written yet.          \"\"\"          try:              return self.read_or_raise()          except NoData:              self.__logger.warning(                  f\"Data node {self.id} from config {self.config_id} is being read but has never been \" f\"written.\"              )              return None        def append(self, data, job_id: Optional[JobId] = None, **kwargs: Dict[str, Any]):          \"\"\"Append some data to this data node.            Parameters:              data (Any): The data to write to this data node.              job_id (JobId^): An optional identifier of the writer.              **kwargs (dict[str, any]): Extra information to attach to the edit document                  corresponding to this write.          \"\"\"          from ._data_manager_factory import _DataManagerFactory            self._append(data)          self.track_edit(job_id=job_id, **kwargs)          self.unlock_edit()          _DataManagerFactory._build_manager()._set(self)        def write(self, data, job_id: Optional[JobId] = None, **kwargs: Dict[str, Any]):          \"\"\"Write some data to this data node.            Parameters:              data (Any): The data to write to this data node.              job_id (JobId^): An optional identifier of the writer.              **kwargs (dict[str, any]): Extra information to attach to the edit document                  corresponding to this write.          \"\"\"          from ._data_manager_factory import _DataManagerFactory            self._write(data)          self.track_edit(job_id=job_id, **kwargs)          self.unlock_edit()          _DataManagerFactory._build_manager()._set(self)        def track_edit(self, **options):          \"\"\"Creates and adds a new entry in the edits attribute without writing the data.            Parameters:              options (dict[str, any)): track `timestamp`, `comments`, `job_id`. The others are user-custom, users can                  use options to attach any information to an external edit of a data node.          \"\"\"          edit = {}          for k, v in options.items():              if v is not None:                  edit[k] = v          if \"timestamp\" not in edit:              edit[\"timestamp\"] = datetime.now()          self.last_edit_date = edit.get(\"timestamp\")          self._edits.append(edit)        def lock_edit(self, editor_id: Optional[str] = None):          \"\"\"Lock the data node modification.            Note:              The data node can be unlocked with the method `(DataNode.)unlock_edit()^`.            Parameters:              editor_id (Optional[str]): The editor's identifier.          \"\"\"          if editor_id:              if (                  self.edit_in_progress                  and self.editor_id != editor_id                  and self.editor_expiration_date                  and self.editor_expiration_date > datetime.now()              ):                  raise DataNodeIsBeingEdited(self.id, self._editor_id)              self.editor_id = editor_id  # type: ignore              self.editor_expiration_date = datetime.now() + timedelta(minutes=self.__EDIT_TIMEOUT)  # type: ignore          else:              self.editor_id = None  # type: ignore              self.editor_expiration_date = None  # type: ignore          self.edit_in_progress = True  # type: ignore        def unlock_edit(self, editor_id: Optional[str] = None):          \"\"\"Unlocks the data node modification.            Note:              The data node can be locked with the method `(DataNode.)lock_edit()^`.            Parameters:              editor_id (Optional[str]): The editor's identifier.          \"\"\"          if (              editor_id              and self.editor_id != editor_id              and self.editor_expiration_date              and self.editor_expiration_date > datetime.now()          ):              raise DataNodeIsBeingEdited(self.id, self._editor_id)          else:              self.editor_id = None  # type: ignore              self.editor_expiration_date = None  # type: ignore              self.edit_in_progress = False  # type: ignore        def filter(self, operators: Union[List, Tuple], join_operator=JoinOperator.AND):          \"\"\"Read and filter the data referenced by this data node.            The data is filtered by the provided list of 3-tuples (key, value, `Operator^`).            If multiple filter operators are provided, filtered data will be joined based on the          join operator (*AND* or *OR*).            Parameters:              operators (Union[List[Tuple], Tuple]): A 3-element tuple or a list of 3-element tuples,                  each is in the form of (key, value, `Operator^`).              join_operator (JoinOperator^): The operator used to join the multiple filter                  3-tuples.          Returns:              The filtered data.          Raises:              NotImplementedError: If the data type is not supported.          \"\"\"          data = self._read()          return _FilterDataNode._filter(data, operators, join_operator)        def __getitem__(self, item):          data = self._read()          return _FilterDataNode._filter_by_key(data, item)        @abstractmethod      def _read(self):          raise NotImplementedError        @abstractmethod      def _append(self, data):          raise NotImplementedError        @abstractmethod      def _write(self, data):          raise NotImplementedError        @property  # type: ignore      @_self_reload(_MANAGER_NAME)      def is_ready_for_reading(self) -> bool:          \"\"\"Indicate if this data node is ready for reading.            Returns:              False if the data is locked for modification or if the data has never been written.                  True otherwise.          \"\"\"          if self._edit_in_progress:              return False          if not self._last_edit_date:              # Never been written so it is not up-to-date              return False          return True        @property  # type: ignore      @_self_reload(_MANAGER_NAME)      def is_valid(self) -> bool:          \"\"\"Indicate if this data node is valid.            Returns:              False if the data ever been written or the expiration date has passed.<br/>              True otherwise.          \"\"\"          if not self._last_edit_date:              # Never been written so it is not valid              return False          if not self._validity_period:              # No validity period and has already been written, so it is valid              return True          if datetime.now() > self.expiration_date:              # expiration_date has been passed              return False          return True        @property      def is_up_to_date(self) -> bool:          \"\"\"Indicate if this data node is up-to-date.            Returns:              False if a preceding data node has been updated before the selected data node              or the selected data is invalid.<br/>              True otherwise.          \"\"\"            from ..scenario.scenario import Scenario          from ..taipy import get_parents            parent_scenarios: Set[Scenario] = get_parents(self)[\"scenario\"]  # type: ignore          for parent_scenario in parent_scenarios:              for ancestor_node in nx.ancestors(parent_scenario._build_dag(), self):                  if (                      isinstance(ancestor_node, DataNode)                      and ancestor_node.last_edit_date                      and ancestor_node.last_edit_date > self.last_edit_date                  ):                      return False          return self.is_valid        @staticmethod      def _class_map():          def all_subclasses(cls):              subclasses = set(cls.__subclasses__())              for s in cls.__subclasses__():                  subclasses.update(all_subclasses(s))              return subclasses            class_map = {}          for c in all_subclasses(DataNode):              try:                  if c.storage_type() is not None:                      class_map[c.storage_type()] = c              except NotImplementedError:                  pass            return class_map        def get_label(self) -> str:          \"\"\"Returns the data node simple label prefixed by its owner label.            Returns:              The label of the data node as a string.          \"\"\"          return self._get_label()        def get_simple_label(self) -> str:          \"\"\"Returns the data node simple label.            Returns:              The simple label of the data node as a string.          \"\"\"          return self._get_simple_label()      @_make_event.register(DataNode)  def make_event_for_datanode(      data_node: DataNode,      operation: EventOperation,      /,      attribute_name: Optional[str] = None,      attribute_value: Optional[Any] = None,      **kwargs,  ) -> Event:      metadata = {\"config_id\": data_node.config_id, \"version\": data_node._version, **kwargs}      return Event(          entity_type=EventEntityType.DATA_NODE,          entity_id=data_node.id,          operation=operation,          attribute_name=attribute_name,          attribute_value=attribute_value,          metadata=metadata,      ) "}
{"text": "import dataclasses  import json  import os  from datetime import date, datetime, timedelta  from enum import Enum  from os.path import isfile  from pydoc import locate  from typing import Any, Dict, List, Optional, Set    from taipy.config.common.scope import Scope    from .._backup._backup import _replace_in_backup_file  from .._entity._reload import _self_reload  from .._version._version_manager_factory import _VersionManagerFactory  from ._abstract_file import _AbstractFileDataNode  from .data_node import DataNode  from .data_node_id import DataNodeId, Edit      class JSONDataNode(DataNode, _AbstractFileDataNode):      \"\"\"Data Node stored as a JSON file.        Attributes:          config_id (str): Identifier of the data node configuration. This string 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.          path (str): The path to the JSON file.          encoder (json.JSONEncoder): The JSON encoder that is used to write into the JSON file.          decoder (json.JSONDecoder): The JSON decoder that is used to read from the JSON file.          properties (dict[str, Any]): A dictionary of additional properties. The _properties_              must have a _\"default_path\"_ or _\"path\"_ entry with the path of the JSON file:                - _\"default_path\"_ `(str)`: The default path of the CSV file.\\n              - _\"encoding\"_ `(str)`: The encoding of the CSV file. The default value is `utf-8`.\\n              - _\"default_data\"_: The default data of the data nodes instantiated from this json data node.\\n      \"\"\"        __STORAGE_TYPE = \"json\"      __DEFAULT_DATA_KEY = \"default_data\"      __DEFAULT_PATH_KEY = \"default_path\"      __PATH_KEY = \"path\"      __ENCODING_KEY = \"encoding\"      _ENCODER_KEY = \"encoder\"      _DECODER_KEY = \"decoder\"      _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: Optional[List[Edit]] = None,          version: Optional[str] = None,          validity_period: Optional[timedelta] = None,          edit_in_progress: bool = False,          editor_id: Optional[str] = None,          editor_expiration_date: Optional[datetime] = None,          properties: Optional[Dict] = None,      ):          if properties is None:              properties = {}            default_value = properties.pop(self.__DEFAULT_DATA_KEY, None)            if self.__ENCODING_KEY not in properties.keys():              properties[self.__ENCODING_KEY] = \"utf-8\"            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,          )          self._path = properties.get(self.__PATH_KEY, properties.get(self.__DEFAULT_PATH_KEY))          if not self._path:              self._path = self._build_path(self.storage_type())          properties[self.__PATH_KEY] = self._path            self._decoder = self._properties.get(self._DECODER_KEY, _DefaultJSONDecoder)          self._encoder = self._properties.get(self._ENCODER_KEY, _DefaultJSONEncoder)            if default_value is not None and not os.path.exists(self._path):              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.\",                      }                  )              )            if not self._last_edit_date and isfile(self._path):  # type: ignore              self._last_edit_date = datetime.now()            self._TAIPY_PROPERTIES.update(              {                  self.__PATH_KEY,                  self.__DEFAULT_PATH_KEY,                  self.__ENCODING_KEY,                  self.__DEFAULT_DATA_KEY,                  self._ENCODER_KEY,                  self._DECODER_KEY,              }          )        @classmethod      def storage_type(cls) -> str:          return cls.__STORAGE_TYPE        @property  # type: ignore      @_self_reload(DataNode._MANAGER_NAME)      def path(self):          return self._path        @path.setter      def path(self, value):          tmp_old_path = self._path          self._path = value          self.properties[self.__PATH_KEY] = value          _replace_in_backup_file(old_file_path=tmp_old_path, new_file_path=self._path)        @property  # type: ignore      @_self_reload(DataNode._MANAGER_NAME)      def encoder(self):          return self._encoder        @encoder.setter      def encoder(self, encoder: json.JSONEncoder):          self.properties[self._ENCODER_KEY] = encoder        @property  # type: ignore      @_self_reload(DataNode._MANAGER_NAME)      def decoder(self):          return self._decoder        @decoder.setter      def decoder(self, decoder: json.JSONDecoder):          self.properties[self._DECODER_KEY] = decoder        def _read(self):          with open(self._path, \"r\", encoding=self.properties[self.__ENCODING_KEY]) as f:              return json.load(f, cls=self._decoder)        def _append(self, data: Any):          with open(self._path, \"r+\", encoding=self.properties[self.__ENCODING_KEY]) as f:              file_data = json.load(f, cls=self._decoder)              if isinstance(file_data, List):                  if isinstance(data, List):                      file_data.extend(data)                  else:                      file_data.append(data)              elif isinstance(data, Dict):                  file_data.update(data)                f.seek(0)              json.dump(file_data, f, indent=4, cls=self._encoder)        def _write(self, data: Any):          with open(self._path, \"w\", encoding=self.properties[self.__ENCODING_KEY]) as f:  # type: ignore              json.dump(data, f, indent=4, cls=self._encoder)      class _DefaultJSONEncoder(json.JSONEncoder):      def default(self, o):          if isinstance(o, Enum):              return {                  \"__type__\": f\"Enum-{o.__class__.__module__}-{o.__class__.__qualname__}-{o.name}\",                  \"__value__\": o.value,              }            if isinstance(o, (datetime, date)):              return {\"__type__\": \"Datetime\", \"__value__\": o.isoformat()}            if dataclasses.is_dataclass(o):              return {                  \"__type__\": f\"dataclass-{o.__class__.__module__}-{o.__class__.__qualname__}\",                  \"__value__\": dataclasses.asdict(o),              }            return super().default(o)      class _DefaultJSONDecoder(json.JSONDecoder):      def __init__(self, *args, **kwargs):          json.JSONDecoder.__init__(self, object_hook=self.object_hook, *args, **kwargs)        def object_hook(self, source):          if _type := source.get(\"__type__\"):              if _type.startswith(\"Enum\"):                  _, module, classname, name = _type.split(\"-\")                  _enum_class = locate(f\"{module}.{classname}\")                  return _enum_class[name]                if _type == \"Datetime\":                  return datetime.fromisoformat(source.get(\"__value__\"))                if _type.startswith(\"dataclass\"):                  _, module, classname = _type.split(\"-\")                  _data_class = locate(f\"{module}.{classname}\")                  return _data_class(**source.get(\"__value__\"))            return source "}
{"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": "import threading  import uuid  from collections.abc import MutableSet  from datetime import datetime  from typing import Any, List, Optional, Union    from .._entity._entity import _Entity  from .._entity._labeled import _Labeled  from .._entity._reload import _self_reload, _self_setter  from .._version._version_manager_factory import _VersionManagerFactory  from ..job._job_manager_factory import _JobManagerFactory  from ..job.job import Job, JobId, Status  from ..notification.event import Event, EventEntityType, EventOperation, _make_event  from .submission_id import SubmissionId  from .submission_status import SubmissionStatus      class Submission(_Entity, _Labeled):      \"\"\"Hold the jobs and submission status when a Scenario^, Sequence^ or Task^ is submitted.        Attributes:          entity_id (str): The identifier of the entity that was submitted.          id (str): The identifier of the `Submission^` entity.          jobs (Optional[Union[List[Job], List[JobId]]]): A list of jobs.          creation_date (Optional[datetime]): The date of this submission's creation.          submission_status (Optional[SubmissionStatus]): The current status of this submission.          version (Optional[str]): The string indicates the application version of the submission to instantiate.              If not provided, the latest version is used.      \"\"\"        _ID_PREFIX = \"SUBMISSION\"      _MANAGER_NAME = \"submission\"      __SEPARATOR = \"_\"      lock = threading.Lock()        def __init__(          self,          entity_id: str,          entity_type: str,          id: Optional[str] = None,          jobs: Optional[Union[List[Job], List[JobId]]] = None,          creation_date: Optional[datetime] = None,          submission_status: Optional[SubmissionStatus] = None,          version: Optional[str] = None,      ):          self._entity_id = entity_id          self._entity_type = entity_type          self.id = id or self.__new_id()          self._jobs: Union[List[Job], List[JobId], List] = jobs or []          self._creation_date = creation_date or datetime.now()          self._submission_status = submission_status or SubmissionStatus.SUBMITTED          self._version = version or _VersionManagerFactory._build_manager()._get_latest_version()            self.__abandoned = False          self.__completed = False            self.__is_canceled = False          self.__running_jobs: MutableSet[str] = set()          self.__blocked_jobs: MutableSet[str] = set()          self.__pending_jobs: MutableSet[str] = set()        @staticmethod      def __new_id() -> str:          \"\"\"Generate a unique Submission identifier.\"\"\"          return SubmissionId(Submission.__SEPARATOR.join([Submission._ID_PREFIX, str(uuid.uuid4())]))        @property      def entity_id(self) -> str:          return self._entity_id        @property      def entity_type(self) -> str:          return self._entity_type        @property      def creation_date(self):          return self._creation_date        def get_label(self) -> str:          \"\"\"Returns the submission simple label prefixed by its owner label.            Returns:              The label of the submission as a string.          \"\"\"          return self._get_label()        def get_simple_label(self) -> str:          \"\"\"Returns the submission simple label.            Returns:              The simple label of the submission as a string.          \"\"\"          return self._get_simple_label()        @property  # type: ignore      @_self_reload(_MANAGER_NAME)      def jobs(self) -> List[Job]:          jobs = []          job_manager = _JobManagerFactory._build_manager()            for job in self._jobs:              jobs.append(job_manager._get(job))            return jobs        @jobs.setter  # type: ignore      @_self_setter(_MANAGER_NAME)      def jobs(self, jobs: Union[List[Job], List[JobId]]):          self._jobs = jobs        def __hash__(self):          return hash(self.id)        def __eq__(self, other):          return self.id == other.id        @property  # type: ignore      @_self_reload(_MANAGER_NAME)      def submission_status(self):          return self._submission_status        @submission_status.setter  # type: ignore      @_self_setter(_MANAGER_NAME)      def submission_status(self, submission_status):          self._submission_status = submission_status        def __lt__(self, other):          return self.creation_date.timestamp() < other.creation_date.timestamp()        def __le__(self, other):          return self.creation_date.timestamp() <= other.creation_date.timestamp()        def __gt__(self, other):          return self.creation_date.timestamp() > other.creation_date.timestamp()        def __ge__(self, other):          return self.creation_date.timestamp() >= other.creation_date.timestamp()        def _update_submission_status(self, job: Job):          if self._submission_status == SubmissionStatus.FAILED:              return            job_status = job.status            if job_status == Status.FAILED:              self.submission_status = SubmissionStatus.FAILED  # type: ignore              return            with self.lock:              if job_status == Status.CANCELED:                  self.__is_canceled = True              elif job_status == Status.BLOCKED:                  self.__blocked_jobs.add(job.id)                  self.__pending_jobs.discard(job.id)              elif job_status == Status.PENDING or job_status == Status.SUBMITTED:                  self.__pending_jobs.add(job.id)                  self.__blocked_jobs.discard(job.id)              elif job_status == Status.RUNNING:                  self.__running_jobs.add(job.id)                  self.__pending_jobs.discard(job.id)              elif job_status == Status.COMPLETED or job_status == Status.SKIPPED:                  self.__completed = True                  self.__blocked_jobs.discard(job.id)                  self.__pending_jobs.discard(job.id)                  self.__running_jobs.discard(job.id)              elif job_status == Status.ABANDONED:                  self.__abandoned = True                  self.__running_jobs.discard(job.id)                  self.__blocked_jobs.discard(job.id)                  self.__pending_jobs.discard(job.id)            if self.__is_canceled:              self.submission_status = SubmissionStatus.CANCELED  # type: ignore          elif self.__abandoned:              self.submission_status = SubmissionStatus.UNDEFINED  # type: ignore          elif self.__running_jobs:              self.submission_status = SubmissionStatus.RUNNING  # type: ignore          elif self.__pending_jobs:              self.submission_status = SubmissionStatus.PENDING  # type: ignore          elif self.__blocked_jobs:              self.submission_status = SubmissionStatus.BLOCKED  # type: ignore          elif self.__completed:              self.submission_status = SubmissionStatus.COMPLETED  # type: ignore          else:              self.submission_status = SubmissionStatus.UNDEFINED  # type: ignore      @_make_event.register(Submission)  def _make_event_for_submission(      submission: Submission,      operation: EventOperation,      /,      attribute_name: Optional[str] = None,      attribute_value: Optional[Any] = None,      **kwargs,  ) -> Event:      metadata = {\"creation_date\": submission.creation_date, \"version\": submission._version, **kwargs}      return Event(          entity_type=EventEntityType.SUBMISSION,          entity_id=submission.id,          operation=operation,          attribute_name=attribute_name,          attribute_value=attribute_value,          metadata=metadata,      ) "}
{"text": "#  # Licensed under the Apache License, Version 2.0 (the \"License\"); you may not use this file except in compliance with  # the License. You may obtain a copy of the License at  #  #        http://www.apache.org/licenses/LICENSE-2.0  #  # Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on  # an \"AS IS\" BASIS, WITHOUT 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 os  from typing import Dict    from ..logger._taipy_logger import _TaipyLogger  from ._config import _Config  from ._config_comparator._config_comparator import _ConfigComparator  from ._serializer._json_serializer import _JsonSerializer  from ._serializer._toml_serializer import _TomlSerializer  from .checker._checker import _Checker  from .checker.issue_collector import IssueCollector  from .common._classproperty import _Classproperty  from .common._config_blocker import _ConfigBlocker  from .global_app.global_app_config import GlobalAppConfig  from .section import Section  from .unique_section import UniqueSection      class Config:      \"\"\"Configuration singleton.\"\"\"        _ENVIRONMENT_VARIABLE_NAME_WITH_CONFIG_PATH = \"TAIPY_CONFIG_PATH\"      __logger = _TaipyLogger._get_logger()      _default_config = _Config._default_config()      _python_config = _Config()      _file_config = _Config()      _env_file_config = _Config()      _applied_config = _Config()      _collector = IssueCollector()      _serializer = _TomlSerializer()      __json_serializer = _JsonSerializer()      _comparator: _ConfigComparator = _ConfigComparator()        @_Classproperty      def unique_sections(cls) -> Dict[str, UniqueSection]:          \"\"\"Return all unique sections.\"\"\"          return cls._applied_config._unique_sections        @_Classproperty      def sections(cls) -> Dict[str, Dict[str, Section]]:          \"\"\"Return all non unique sections.\"\"\"          return cls._applied_config._sections        @_Classproperty      def global_config(cls) -> GlobalAppConfig:          \"\"\"Return configuration values related to the global application as a `GlobalAppConfig^`.\"\"\"          return cls._applied_config._global_config        @classmethod      @_ConfigBlocker._check()      def load(cls, filename):          \"\"\"Load a configuration file.            The current Python configuration is replaced and the Config compilation is triggered.            Parameters:              filename (Union[str, Path]): The path of the toml configuration file to load.          \"\"\"          cls.__logger.info(f\"Loading configuration. Filename: '{filename}'\")          cls._python_config = cls._serializer._read(filename)          cls._compile_configs()          cls.__logger.info(f\"Configuration '{filename}' successfully loaded.\")        @classmethod      def export(cls, filename):          \"\"\"Export a configuration.            The export is done in a toml file.            The exported configuration is taken from the Python code configuration.            Parameters:              filename (Union[str, Path]): The path of the file to export.          Note:              If *filename* already exists, it is overwritten.          \"\"\"          cls._serializer._write(cls._python_config, filename)        @classmethod      def backup(cls, filename):          \"\"\"Backup a configuration.            The backup is done in a toml file.            The backed up configuration is a compilation from the three possible methods to configure          the application: the Python code configuration, the file configuration and the environment          configuration.            Parameters:              filename (Union[str, Path]): The path of the file to export.          Note:              If *filename* already exists, it is overwritten.          \"\"\"          cls._serializer._write(cls._applied_config, filename)        @classmethod      @_ConfigBlocker._check()      def restore(cls, filename):          \"\"\"Restore a configuration file and replace the current applied configuration.            Parameters:              filename (Union[str, Path]): The path of the toml configuration file to load.          \"\"\"          cls.__logger.info(f\"Restoring configuration. Filename: '{filename}'\")          cls._applied_config = cls._serializer._read(filename)          cls.__logger.info(f\"Configuration '{filename}' successfully restored.\")        @classmethod      @_ConfigBlocker._check()      def override(cls, filename):          \"\"\"Load a configuration from a file and overrides the current config.            Parameters:              filename (Union[str, Path]): The path of the toml configuration file to load.          \"\"\"          cls.__logger.info(f\"Loading configuration. Filename: '{filename}'\")          cls._file_config = cls._serializer._read(filename)          cls.__logger.info(\"Overriding configuration.'\")          cls._compile_configs()          cls.__logger.info(f\"Configuration '{filename}' successfully loaded.\")        @classmethod      def block_update(cls):          \"\"\"Block update on the configuration signgleton.\"\"\"          _ConfigBlocker._block()        @classmethod      def unblock_update(cls):          \"\"\"Unblock update on the configuration signgleton.\"\"\"          _ConfigBlocker._unblock()        @classmethod      @_ConfigBlocker._check()      def configure_global_app(cls, **properties) -> GlobalAppConfig:          \"\"\"Configure the global application.            Parameters:              **properties (Dict[str, Any]): A dictionary of additional properties.          Returns:              The global application configuration.          \"\"\"          glob_cfg = GlobalAppConfig(**properties)          if cls._python_config._global_config is None:              cls._python_config._global_config = glob_cfg          else:              cls._python_config._global_config._update(glob_cfg._to_dict())          cls._compile_configs()          return cls._applied_config._global_config        @classmethod      def check(cls) -> IssueCollector:          \"\"\"Check configuration.            This method logs issue messages and returns an issue collector.            Returns:              Collector containing the info, warning and error issues.          \"\"\"          cls._collector = _Checker._check(cls._applied_config)          cls.__log_message(cls)          return cls._collector        @classmethod      @_ConfigBlocker._check()      def _register_default(cls, default_section: Section):          if isinstance(default_section, UniqueSection):              if cls._default_config._unique_sections.get(default_section.name, None):                  cls._default_config._unique_sections[default_section.name]._update(default_section._to_dict())              else:                  cls._default_config._unique_sections[default_section.name] = default_section          else:              if def_sections := cls._default_config._sections.get(default_section.name, None):                  def_sections[default_section.id] = default_section              else:                  cls._default_config._sections[default_section.name] = {default_section.id: default_section}          cls._serializer._section_class[default_section.name] = default_section.__class__  # type: ignore          cls.__json_serializer._section_class[default_section.name] = default_section.__class__  # type: ignore          cls._compile_configs()        @classmethod      @_ConfigBlocker._check()      def _register(cls, section):          if isinstance(section, UniqueSection):              if cls._python_config._unique_sections.get(section.name, None):                  cls._python_config._unique_sections[section.name]._update(section._to_dict())              else:                  cls._python_config._unique_sections[section.name] = section          else:              if sections := cls._python_config._sections.get(section.name, None):                  if sections.get(section.id, None):                      sections[section.id]._update(section._to_dict())                  else:                      sections[section.id] = section              else:                  cls._python_config._sections[section.name] = {section.id: section}          cls._serializer._section_class[section.name] = section.__class__          cls.__json_serializer._section_class[section.name] = section.__class__          cls._compile_configs()        @classmethod      def _override_env_file(cls):          if config_filename := os.environ.get(cls._ENVIRONMENT_VARIABLE_NAME_WITH_CONFIG_PATH):              cls.__logger.info(f\"Loading configuration provided by environment variable. Filename: '{config_filename}'\")              cls._env_file_config = cls._serializer._read(config_filename)              cls.__logger.info(f\"Configuration '{config_filename}' successfully loaded.\")        @classmethod      def _compile_configs(cls):          Config._override_env_file()          cls._applied_config._clean()          if cls._default_config:              cls._applied_config._update(cls._default_config)          if cls._python_config:              cls._applied_config._update(cls._python_config)          if cls._file_config:              cls._applied_config._update(cls._file_config)          if cls._env_file_config:              cls._applied_config._update(cls._env_file_config)        @classmethod      def __log_message(cls, config):          for issue in config._collector._warnings:              cls.__logger.warning(str(issue))          for issue in config._collector._infos:              cls.__logger.info(str(issue))          for issue in config._collector._errors:              cls.__logger.error(str(issue))          if len(config._collector._errors) != 0:              raise SystemExit(\"Configuration errors found. Please check the error log for more information.\")        @classmethod      def _to_json(cls, _config: _Config) -> str:          return cls.__json_serializer._serialize(_config)        @classmethod      def _from_json(cls, config_as_str: str) -> _Config:          return cls.__json_serializer._deserialize(config_as_str)      Config._override_env_file() "}
{"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 inspect  import re  import types  from abc import abstractmethod  from datetime import datetime, timedelta  from typing import Any, Dict, Optional    from .._config import _Config  from ..common._template_handler import _TemplateHandler  from ..common._validate_id import _validate_id  from ..common.frequency import Frequency  from ..common.scope import Scope  from ..exceptions.exceptions import LoadingError  from ..global_app.global_app_config import GlobalAppConfig  from ..section import Section  from ..unique_section import UniqueSection      class _BaseSerializer(object):      \"\"\"Base serializer class for taipy configuration.\"\"\"        _GLOBAL_NODE_NAME = \"TAIPY\"      _section_class = {_GLOBAL_NODE_NAME: GlobalAppConfig}        @classmethod      @abstractmethod      def _write(cls, configuration: _Config, filename: str):          raise NotImplementedError        @classmethod      def _str(cls, configuration: _Config):          config_as_dict = {cls._GLOBAL_NODE_NAME: configuration._global_config._to_dict()}          for u_sect_name, u_sect in configuration._unique_sections.items():              config_as_dict[u_sect_name] = u_sect._to_dict()          for sect_name, sections in configuration._sections.items():              config_as_dict[sect_name] = cls._to_dict(sections)          return cls._stringify(config_as_dict)        @classmethod      def _to_dict(cls, sections: Dict[str, Any]):          return {section_id: section._to_dict() for section_id, section in sections.items()}        @classmethod      def _stringify(cls, as_dict):          if as_dict is None:              return None          if isinstance(as_dict, Section):              return as_dict.id + \":SECTION\"          if isinstance(as_dict, Scope):              return as_dict.name + \":SCOPE\"          if isinstance(as_dict, Frequency):              return as_dict.name + \":FREQUENCY\"          if isinstance(as_dict, bool):              return str(as_dict) + \":bool\"          if isinstance(as_dict, int):              return str(as_dict) + \":int\"          if isinstance(as_dict, float):              return str(as_dict) + \":float\"          if isinstance(as_dict, datetime):              return as_dict.isoformat() + \":datetime\"          if isinstance(as_dict, timedelta):              return cls._timedelta_to_str(as_dict) + \":timedelta\"          if inspect.isfunction(as_dict) or isinstance(as_dict, types.BuiltinFunctionType):              return as_dict.__module__ + \".\" + as_dict.__name__ + \":function\"          if inspect.isclass(as_dict):              return as_dict.__module__ + \".\" + as_dict.__qualname__ + \":class\"          if isinstance(as_dict, dict):              return {str(key): cls._stringify(val) for key, val in as_dict.items()}          if isinstance(as_dict, list):              return [cls._stringify(val) for val in as_dict]          if isinstance(as_dict, tuple):              return [cls._stringify(val) for val in as_dict]          return as_dict        @staticmethod      def _extract_node(config_as_dict, cls_config, node, config: Optional[Any]) -> Dict[str, Section]:          res = {}          for key, value in config_as_dict.get(node, {}).items():  # my_task, {input=[], output=[my_data_node], ...}              key = _validate_id(key)              res[key] = cls_config._from_dict(value, key, config)  # if config is None else cls_config._from_dict(key,              # value, config)          return res        @classmethod      def _from_dict(cls, as_dict) -> _Config:          config = _Config()          config._global_config = GlobalAppConfig._from_dict(as_dict.get(cls._GLOBAL_NODE_NAME, {}))          for section_name, sect_as_dict in as_dict.items():              if section_class := cls._section_class.get(section_name, None):                  if issubclass(section_class, UniqueSection):                      config._unique_sections[section_name] = section_class._from_dict(                          sect_as_dict, None, None                      )  # type: ignore                  elif issubclass(section_class, Section):                      config._sections[section_name] = cls._extract_node(as_dict, section_class, section_name, config)          return config        @classmethod      def _pythonify(cls, val):          match = re.fullmatch(_TemplateHandler._PATTERN, str(val))          if not match:              if isinstance(val, str):                  TYPE_PATTERN = (                      r\"^(.+):(\\bbool\\b|\\bstr\\b|\\bint\\b|\\bfloat\\b|\\bdatetime\\b||\\btimedelta\\b|\"                      r\"\\bfunction\\b|\\bclass\\b|\\bSCOPE\\b|\\bFREQUENCY\\b|\\bSECTION\\b)?$\"                  )                  match = re.fullmatch(TYPE_PATTERN, str(val))                  if match:                      actual_val = match.group(1)                      dynamic_type = match.group(2)                      if dynamic_type == \"SECTION\":                          return actual_val                      if dynamic_type == \"FREQUENCY\":                          return Frequency[actual_val]                      if dynamic_type == \"SCOPE\":                          return Scope[actual_val]                      if dynamic_type == \"bool\":                          return _TemplateHandler._to_bool(actual_val)                      elif dynamic_type == \"int\":                          return _TemplateHandler._to_int(actual_val)                      elif dynamic_type == \"float\":                          return _TemplateHandler._to_float(actual_val)                      elif dynamic_type == \"datetime\":                          return _TemplateHandler._to_datetime(actual_val)                      elif dynamic_type == \"timedelta\":                          return _TemplateHandler._to_timedelta(actual_val)                      elif dynamic_type == \"function\":                          return _TemplateHandler._to_function(actual_val)                      elif dynamic_type == \"class\":                          return _TemplateHandler._to_class(actual_val)                      elif dynamic_type == \"str\":                          return actual_val                      else:                          error_msg = f\"Error loading toml configuration at {val}. {dynamic_type} type is not supported.\"                          raise LoadingError(error_msg)              if isinstance(val, dict):                  return {str(k): cls._pythonify(v) for k, v in val.items()}              if isinstance(val, list):                  return [cls._pythonify(v) for v in val]          return val        @classmethod      def _timedelta_to_str(cls, 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\"          ) "}
{"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": "import re  from typing import Dict, List, Set    from .._serializer._json_serializer import _JsonSerializer      class _ComparatorResult(dict):      ADDED_ITEMS_KEY = \"added_items\"      REMOVED_ITEMS_KEY = \"removed_items\"      MODIFIED_ITEMS_KEY = \"modified_items\"        CONFLICTED_SECTION_KEY = \"conflicted_sections\"      UNCONFLICTED_SECTION_KEY = \"unconflicted_sections\"        def __init__(self, unconflicted_sections: Set[str]):          super().__init__()            self._unconflicted_sections = unconflicted_sections        def _sort_by_section(self):          if self.get(self.CONFLICTED_SECTION_KEY):              for key in self[self.CONFLICTED_SECTION_KEY].keys():                  self[self.CONFLICTED_SECTION_KEY][key].sort(key=lambda x: x[0][0])            if self.get(self.UNCONFLICTED_SECTION_KEY):              for key in self[self.UNCONFLICTED_SECTION_KEY].keys():                  self[self.UNCONFLICTED_SECTION_KEY][key].sort(key=lambda x: x[0][0])        def _check_added_items(self, config_deepdiff, new_json_config):          if dictionary_item_added := config_deepdiff.get(\"dictionary_item_added\"):              for item_added in dictionary_item_added:                  section_name, config_id, attribute = self.__get_changed_entity_attribute(item_added)                  diff_sections = self.__get_section(section_name)                    if attribute:                      value_added = new_json_config[section_name][config_id][attribute]                  elif config_id:                      value_added = new_json_config[section_name][config_id]                  else:                      value_added = new_json_config[section_name]                    section_name = self.__rename_global_node_name(section_name)                  self.__create_or_append_list(                      diff_sections,                      self.ADDED_ITEMS_KEY,                      ((section_name, config_id, attribute), (value_added)),                  )        def _check_removed_items(self, config_deepdiff, old_json_config):          if dictionary_item_removed := config_deepdiff.get(\"dictionary_item_removed\"):              for item_removed in dictionary_item_removed:                  section_name, config_id, attribute = self.__get_changed_entity_attribute(item_removed)                  diff_sections = self.__get_section(section_name)                    if attribute:                      value_removed = old_json_config[section_name][config_id][attribute]                  elif config_id:                      value_removed = old_json_config[section_name][config_id]                  else:                      value_removed = old_json_config[section_name]                    section_name = self.__rename_global_node_name(section_name)                  self.__create_or_append_list(                      diff_sections,                      self.REMOVED_ITEMS_KEY,                      ((section_name, config_id, attribute), (value_removed)),                  )        def _check_modified_items(self, config_deepdiff, old_json_config, new_json_config):          if values_changed := config_deepdiff.get(\"values_changed\"):              for item_changed, value_changed in values_changed.items():                  section_name, config_id, attribute = self.__get_changed_entity_attribute(item_changed)                  diff_sections = self.__get_section(section_name)                    section_name = self.__rename_global_node_name(section_name)                  self.__create_or_append_list(                      diff_sections,                      self.MODIFIED_ITEMS_KEY,                      ((section_name, config_id, attribute), (value_changed[\"old_value\"], value_changed[\"new_value\"])),                  )            # Iterable item added will be considered a modified item          if iterable_item_added := config_deepdiff.get(\"iterable_item_added\"):              self.__check_modified_iterable(iterable_item_added, old_json_config, new_json_config)            # Iterable item removed will be considered a modified item          if iterable_item_removed := config_deepdiff.get(\"iterable_item_removed\"):              self.__check_modified_iterable(iterable_item_removed, old_json_config, new_json_config)        def __check_modified_iterable(self, iterable_items, old_json_config, new_json_config):          for item in iterable_items:              section_name, config_id, attribute = self.__get_changed_entity_attribute(item)              diff_sections = self.__get_section(section_name)                if attribute:                  new_value = new_json_config[section_name][config_id][attribute]                  old_value = old_json_config[section_name][config_id][attribute]              else:                  new_value = new_json_config[section_name][config_id]                  old_value = old_json_config[section_name][config_id]                section_name = self.__rename_global_node_name(section_name)              modified_value = ((section_name, config_id, attribute), (old_value, new_value))                if (                  not diff_sections.get(self.MODIFIED_ITEMS_KEY)                  or modified_value not in diff_sections[self.MODIFIED_ITEMS_KEY]              ):                  self.__create_or_append_list(                      diff_sections,                      self.MODIFIED_ITEMS_KEY,                      modified_value,                  )        def __get_section(self, section_name: str) -> Dict[str, List]:          if section_name in self._unconflicted_sections:              if not self.get(self.UNCONFLICTED_SECTION_KEY):                  self[self.UNCONFLICTED_SECTION_KEY] = {}              return self[self.UNCONFLICTED_SECTION_KEY]            if not self.get(self.CONFLICTED_SECTION_KEY):              self[self.CONFLICTED_SECTION_KEY] = {}          return self[self.CONFLICTED_SECTION_KEY]        def __create_or_append_list(self, diff_dict, key, value):          if diff_dict.get(key):              diff_dict[key].append(value)          else:              diff_dict[key] = [value]        def __get_changed_entity_attribute(self, attribute_bracket_notation):          \"\"\"Split the section name, the config id (if exists), and the attribute name (if exists)          from JSON bracket notation.          \"\"\"          try:              section_name, config_id, attribute = re.findall(r\"\\[\\'(.*?)\\'\\]\", attribute_bracket_notation)          except ValueError:              try:                  section_name, config_id = re.findall(r\"\\[\\'(.*?)\\'\\]\", attribute_bracket_notation)                  attribute = None              except ValueError:                  section_name = re.findall(r\"\\[\\'(.*?)\\'\\]\", attribute_bracket_notation)[0]                  config_id = None                  attribute = None            return section_name, config_id, attribute        def __rename_global_node_name(self, node_name):          if node_name == _JsonSerializer._GLOBAL_NODE_NAME:              return \"Global Configuration\"          return node_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 json  from copy import copy  from typing import Optional, Set, Union    from deepdiff import DeepDiff    from ...logger._taipy_logger import _TaipyLogger  from .._config import _Config  from .._serializer._json_serializer import _JsonSerializer  from ._comparator_result import _ComparatorResult      class _ConfigComparator:      def __init__(self):          self._unconflicted_sections: Set[str] = set()          self.__logger = _TaipyLogger._get_logger()        def _add_unconflicted_section(self, section_name: Union[str, Set[str]]):          if isinstance(section_name, str):              section_name = {section_name}            self._unconflicted_sections.update(section_name)        def _find_conflict_config(          self,          old_config: _Config,          new_config: _Config,          old_version_number: Optional[str] = None,          new_version_number: Optional[str] = None,      ):          \"\"\"Compare between 2 _Config object to check for compatibility.            Args:              old_config (_Config): The old _Config.              new_config (_Config): The new _Config.              old_version_number (str, optional): The old version number for logging. Defaults to None.              new_version_number (str, optional): The new version number for logging. Defaults to None.            Returns:              _ComparatorResult: Return a _ComparatorResult dictionary with the following format:          ```python          {              \"added_items\": [                  ((section_name_1, config_id_1, attribute_1), added_object_1),                  ((section_name_2, config_id_2, attribute_2), added_object_2),              ],              \"removed_items\": [                  ((section_name_1, config_id_1, attribute_1), removed_object_1),                  ((section_name_2, config_id_2, attribute_2), removed_object_2),              ],              \"modified_items\": [                  ((section_name_1, config_id_1, attribute_1), (old_value_1, new_value_1)),                  ((section_name_2, config_id_2, attribute_2), (old_value_2, new_value_2)),              ],          }          ```          \"\"\"          comparator_result = self.__get_config_diff(old_config, new_config)          self.__log_find_conflict_message(comparator_result, old_version_number, new_version_number)          return comparator_result        def _compare(          self,          config_1: _Config,          config_2: _Config,          version_number_1: str,          version_number_2: str,      ):          \"\"\"Compare between 2 _Config object to check for compatibility.            Args:              config_1 (_Config): The old _Config.              config_2 (_Config): The new _Config.              version_number_1 (str): The old version number for logging.              version_number_2 (str): The new version number for logging.          \"\"\"          comparator_result = self.__get_config_diff(config_1, config_2)          self.__log_comparison_message(comparator_result, version_number_1, version_number_2)            return comparator_result        def __get_config_diff(self, config_1, config_2):          json_config_1 = json.loads(_JsonSerializer._serialize(config_1))          json_config_2 = json.loads(_JsonSerializer._serialize(config_2))            config_deepdiff = DeepDiff(json_config_1, json_config_2, ignore_order=True)            comparator_result = _ComparatorResult(copy(self._unconflicted_sections))            comparator_result._check_added_items(config_deepdiff, json_config_2)          comparator_result._check_removed_items(config_deepdiff, json_config_1)          comparator_result._check_modified_items(config_deepdiff, json_config_1, json_config_2)          comparator_result._sort_by_section()            return comparator_result        def __log_comparison_message(          self,          comparator_result: _ComparatorResult,          version_number_1: str,          version_number_2: str,      ):          config_str_1 = f\"version {version_number_1} Configuration\"          config_str_2 = f\"version {version_number_2} Configuration\"            diff_messages = []          for _, sections in comparator_result.items():              diff_messages = self.__get_messages(sections)            if diff_messages:              self.__logger.info(                  f\"Differences between {config_str_1} and {config_str_2}:\\n\\t\" + \"\\n\\t\".join(diff_messages)              )          else:              self.__logger.info(f\"There is no difference between {config_str_1} and {config_str_2}.\")        def __log_find_conflict_message(          self,          comparator_result: _ComparatorResult,          old_version_number: Optional[str] = None,          new_version_number: Optional[str] = None,      ):          old_config_str = (              f\"configuration for version {old_version_number}\" if old_version_number else \"current configuration\"          )          new_config_str = (              f\"configuration for version {new_version_number}\" if new_version_number else \"current configuration\"          )            if unconflicted_sections := comparator_result.get(_ComparatorResult.UNCONFLICTED_SECTION_KEY):              unconflicted_messages = self.__get_messages(unconflicted_sections)              self.__logger.info(                  f\"There are non-conflicting changes between the {old_config_str}\"                  f\" and the {new_config_str}:\\n\\t\" + \"\\n\\t\".join(unconflicted_messages)              )            if conflicted_sections := comparator_result.get(_ComparatorResult.CONFLICTED_SECTION_KEY):              conflicted_messages = self.__get_messages(conflicted_sections)              self.__logger.error(                  f\"The {old_config_str} conflicts with the {new_config_str}:\\n\\t\" + \"\\n\\t\".join(conflicted_messages)              )        def __get_messages(self, diff_sections):          dq = '\"'          messages = []            if added_items := diff_sections.get(_ComparatorResult.ADDED_ITEMS_KEY):              for diff in added_items:                  ((section_name, config_id, attribute), added_object) = diff                  messages.append(                      f\"{section_name} {dq}{config_id}{dq} \"                      f\"{f'has attribute {dq}{attribute}{dq}' if attribute else 'was'} added: {added_object}\"                  )            if removed_items := diff_sections.get(_ComparatorResult.REMOVED_ITEMS_KEY):              for diff in removed_items:                  ((section_name, config_id, attribute), removed_object) = diff                  messages.append(                      f\"{section_name} {dq}{config_id}{dq} \"                      f\"{f'has attribute {dq}{attribute}{dq}' if attribute else 'was'} removed\"                  )            if modified_items := diff_sections.get(_ComparatorResult.MODIFIED_ITEMS_KEY):              for diff in modified_items:                  ((section_name, config_id, attribute), (old_value, new_value)) = diff                  messages.append(                      f\"{section_name} {dq}{config_id}{dq} \"                      f\"{f'has attribute {dq}{attribute}{dq}' if attribute else 'was'} modified: \"                      f\"{old_value} -> {new_value}\"                  )            return messages "}
{"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 __future__ import annotations    import contextlib  import logging  import os  import pathlib  import re  import sys  import time  import typing as t  import webbrowser  from importlib import util  from random import randint    import __main__  from flask import Blueprint, Flask, json, jsonify, render_template, send_from_directory  from flask_cors import CORS  from flask_socketio import SocketIO  from gitignore_parser import parse_gitignore  from kthread import KThread  from taipy.logger._taipy_logger import _TaipyLogger  from werkzeug.serving import is_running_from_reloader    from ._renderers.json import _TaipyJsonProvider  from .config import ServerConfig  from .utils import _is_in_notebook, _is_port_open, _RuntimeManager    if t.TYPE_CHECKING:      from .gui import Gui      class _Server:      __RE_OPENING_CURLY = re.compile(r\"([^\\\"])(\\{)\")      __RE_CLOSING_CURLY = re.compile(r\"(\\})([^\\\"])\")      __OPENING_CURLY = r\"\\1&#x7B;\"      __CLOSING_CURLY = r\"&#x7D;\\2\"        def __init__(          self,          gui: Gui,          flask: t.Optional[Flask] = None,          path_mapping: t.Optional[dict] = None,          async_mode: t.Optional[str] = None,          allow_upgrades: bool = True,          server_config: t.Optional[ServerConfig] = None,      ):          self._gui = gui          server_config = server_config or {}          self._flask = flask          if self._flask is None:              flask_config: t.Dict[str, t.Any] = {\"import_name\": \"Taipy\"}              if \"flask\" in server_config and isinstance(server_config[\"flask\"], dict):                  flask_config.update(server_config[\"flask\"])              self._flask = Flask(**flask_config)          if \"SECRET_KEY\" not in self._flask.config or not self._flask.config[\"SECRET_KEY\"]:              self._flask.config[\"SECRET_KEY\"] = \"TaIpY\"            # setup cors          if \"cors\" not in server_config or (              \"cors\" in server_config and (isinstance(server_config[\"cors\"], dict) or server_config[\"cors\"] is True)          ):              cors_config = (                  server_config[\"cors\"] if \"cors\" in server_config and isinstance(server_config[\"cors\"], dict) else {}              )              CORS(self._flask, **cors_config)            # setup socketio          socketio_config: t.Dict[str, t.Any] = {              \"cors_allowed_origins\": \"*\",              \"ping_timeout\": 10,              \"ping_interval\": 5,              \"json\": json,              \"async_mode\": async_mode,              \"allow_upgrades\": allow_upgrades,          }          if \"socketio\" in server_config and isinstance(server_config[\"socketio\"], dict):              socketio_config.update(server_config[\"socketio\"])          self._ws = SocketIO(self._flask, **socketio_config)            self._apply_patch()            # set json encoder (for Taipy specific types)          self._flask.json_provider_class = _TaipyJsonProvider          self._flask.json = self._flask.json_provider_class(self._flask)  # type: ignore            self.__path_mapping = path_mapping or {}          self.__ssl_context = server_config.get(\"ssl_context\", None)          self._is_running = False            # Websocket (handle json message)          # adding args for the one call with a server ack request          @self._ws.on(\"message\")          def handle_message(message, *args) -> None:              if \"status\" in message:                  _TaipyLogger._get_logger().info(message[\"status\"])              elif \"type\" in message:                  gui._manage_message(message[\"type\"], message)        def __is_ignored(self, file_path: str) -> bool:          if not hasattr(self, \"_ignore_matches\"):              __IGNORE_FILE = \".taipyignore\"              ignore_file = (                  (pathlib.Path(__main__.__file__).parent / __IGNORE_FILE) if hasattr(__main__, \"__file__\") else None              )              if not ignore_file or not ignore_file.is_file():                  ignore_file = pathlib.Path(self._gui._root_dir) / __IGNORE_FILE              self._ignore_matches = (                  parse_gitignore(ignore_file) if ignore_file.is_file() and os.access(ignore_file, os.R_OK) else None              )            if callable(self._ignore_matches):              return self._ignore_matches(file_path)          return False        def _get_default_blueprint(          self,          static_folder: str,          template_folder: str,          title: str,          favicon: str,          root_margin: str,          scripts: t.List[str],          styles: t.List[str],          version: str,          client_config: t.Dict[str, t.Any],          watermark: t.Optional[str],          css_vars: str,          base_url: str,      ) -> Blueprint:          taipy_bp = Blueprint(\"Taipy\", __name__, static_folder=static_folder, template_folder=template_folder)          # Serve static react build            @taipy_bp.route(\"/\", defaults={\"path\": \"\"})          @taipy_bp.route(\"/<path:path>\")          def my_index(path):              if path == \"\" or path == \"index.html\" or \".\" not in path:                  try:                      return render_template(                          \"index.html\",                          title=title,                          favicon=favicon,                          root_margin=root_margin,                          watermark=watermark,                          config=client_config,                          scripts=scripts,                          styles=styles,                          version=version,                          css_vars=css_vars,                          base_url=base_url,                      )                  except Exception:  # pragma: no cover                      raise RuntimeError(                          \"Something is wrong with the taipy-gui front-end installation. Check that the js bundle has been properly built (is Node.js installed?).\"  # noqa: E501                      )                if path == \"taipy.status.json\":                  return self._direct_render_json(self._gui._serve_status(pathlib.Path(template_folder) / path))              if str(os.path.normpath(file_path := ((base_path := static_folder + os.path.sep) + path))).startswith(                  base_path              ) and os.path.isfile(file_path):                  return send_from_directory(base_path, path)              # use the path mapping to detect and find resources              for k, v in self.__path_mapping.items():                  if (                      path.startswith(f\"{k}/\")                      and str(                          os.path.normpath(file_path := ((base_path := v + os.path.sep) + path[len(k) + 1 :]))                      ).startswith(base_path)                      and os.path.isfile(file_path)                  ):                      return send_from_directory(base_path, path[len(k) + 1 :])              if (                  hasattr(__main__, \"__file__\")                  and str(                      os.path.normpath(                          file_path := ((base_path := os.path.dirname(__main__.__file__) + os.path.sep) + path)                      )                  ).startswith(base_path)                  and os.path.isfile(file_path)                  and not self.__is_ignored(file_path)              ):                  return send_from_directory(base_path, path)              if (                  str(os.path.normpath(file_path := (base_path := self._gui._root_dir + os.path.sep) + path)).startswith(                      base_path                  )                  and os.path.isfile(file_path)                  and not self.__is_ignored(file_path)              ):                  return send_from_directory(base_path, path)              return (\"\", 404)            return taipy_bp        # Update to render as JSX      def _render(self, html_fragment, style, head, context):          template_str = _Server.__RE_OPENING_CURLY.sub(_Server.__OPENING_CURLY, html_fragment)          template_str = _Server.__RE_CLOSING_CURLY.sub(_Server.__CLOSING_CURLY, template_str)          template_str = template_str.replace('\"{!', \"{\")          template_str = template_str.replace('!}\"', \"}\")          return self._direct_render_json(              {                  \"jsx\": template_str,                  \"style\": (style + os.linesep) if style else \"\",                  \"head\": head or [],                  \"context\": context or self._gui._get_default_module_name(),              }          )        def _direct_render_json(self, data):          return jsonify(data)        def get_flask(self):          return self._flask        def test_client(self):          return self._flask.test_client()        def _run_notebook(self):          self._is_running = True          self._ws.run(self._flask, host=self._host, port=self._port, debug=False, use_reloader=False)        def _get_async_mode(self) -> str:          return self._ws.async_mode        def _apply_patch(self):          if self._get_async_mode() == \"gevent\" and util.find_spec(\"gevent\"):              from gevent import monkey                if not monkey.is_module_patched(\"time\"):                  monkey.patch_time()          if self._get_async_mode() == \"eventlet\" and util.find_spec(\"eventlet\"):              from eventlet import monkey_patch, patcher                if not patcher.is_monkey_patched(\"time\"):                  monkey_patch(time=True)        def _get_random_port(self):  # pragma: no cover          while True:              port = randint(49152, 65535)              if port not in _RuntimeManager().get_used_port() and not _is_port_open(self._host, port):                  return port        def run(self, host, port, debug, use_reloader, flask_log, run_in_thread, allow_unsafe_werkzeug, notebook_proxy):          host_value = host if host != \"0.0.0.0\" else \"localhost\"          self._host = host          self._port = port          if _is_in_notebook() and notebook_proxy:  # pragma: no cover              from .utils.proxy import NotebookProxy                # Start proxy if not already started              self._proxy = NotebookProxy(gui=self._gui, listening_port=port)              self._proxy.run()              self._port = self._get_random_port()          if _is_in_notebook() or run_in_thread:              runtime_manager = _RuntimeManager()              runtime_manager.add_gui(self._gui, port)          if debug and not is_running_from_reloader() and _is_port_open(host_value, port):              raise ConnectionError(                  f\"Port {port} is already opened on {host_value}. You have another server application running on the same port.\"  # noqa: E501              )          if not flask_log:              log = logging.getLogger(\"werkzeug\")              log.disabled = True              if not is_running_from_reloader():                  _TaipyLogger._get_logger().info(f\" * Server starting on http://{host_value}:{port}\")              else:                  _TaipyLogger._get_logger().info(f\" * Server reloaded on http://{host_value}:{port}\")          if not is_running_from_reloader() and self._gui._get_config(\"run_browser\", False):              webbrowser.open(f\"http://{host_value}{f':{port}' if port else ''}\", new=2)          if _is_in_notebook() or run_in_thread:              self._thread = KThread(target=self._run_notebook)              self._thread.start()              return          self._is_running = True          run_config = {              \"app\": self._flask,              \"host\": host,              \"port\": port,              \"debug\": debug,              \"use_reloader\": use_reloader,          }          if self.__ssl_context is not None:              run_config[\"ssl_context\"] = self.__ssl_context          # flask-socketio specific conditions for 'allow_unsafe_werkzeug' parameters to be popped out of kwargs          if self._get_async_mode() == \"threading\" and (not sys.stdin or not sys.stdin.isatty()):              run_config = {**run_config, \"allow_unsafe_werkzeug\": allow_unsafe_werkzeug}          self._ws.run(**run_config)        def stop_thread(self):          if hasattr(self, \"_thread\") and self._thread.is_alive() and self._is_running:              self._is_running = False              with contextlib.suppress(Exception):                  if self._get_async_mode() == \"gevent\":                      if self._ws.wsgi_server is not None:                          self._ws.wsgi_server.stop()                      else:                          self._thread.kill()                  else:                      self._thread.kill()              while _is_port_open(self._host, self._port):                  time.sleep(0.1)        def stop_proxy(self):          if hasattr(self, \"_proxy\"):              self._proxy.stop() "}
{"text": "import os  import re  import typing as t  from importlib.util import find_spec    import pytz  import tzlocal  from dotenv import dotenv_values  from taipy.logger._taipy_logger import _TaipyLogger  from werkzeug.serving import is_running_from_reloader    from ._gui_cli import _GuiCLI  from ._page import _Page  from ._warnings import _warn  from .partial import Partial  from .utils import _is_in_notebook    ConfigParameter = t.Literal[      \"allow_unsafe_werkzeug\",      \"async_mode\",      \"change_delay\",      \"chart_dark_template\",      \"base_url\",      \"dark_mode\",      \"dark_theme\",      \"data_url_max_size\",      \"debug\",      \"extended_status\",      \"favicon\",      \"flask_log\",      \"host\",      \"light_theme\",      \"margin\",      \"ngrok_token\",      \"notebook_proxy\",      \"notification_duration\",      \"propagate\",      \"run_browser\",      \"run_in_thread\",      \"run_server\",      \"server_config\",      \"single_client\",      \"system_notification\",      \"theme\",      \"time_zone\",      \"title\",      \"stylekit\",      \"upload_folder\",      \"use_arrow\",      \"use_reloader\",      \"watermark\",      \"webapp_path\",      \"port\",  ]    Stylekit = t.TypedDict(      \"Stylekit\",      {          \"color_primary\": str,          \"color_secondary\": str,          \"color_error\": str,          \"color_warning\": str,          \"color_success\": str,          \"color_background_light\": str,          \"color_paper_light\": str,          \"color_background_dark\": str,          \"color_paper_dark\": str,          \"font_family\": str,          \"root_margin\": str,          \"border_radius\": int,          \"input_button_height\": str,      },      total=False,  )    ServerConfig = t.TypedDict(      \"ServerConfig\",      {          \"cors\": t.Optional[t.Union[bool, t.Dict[str, t.Any]]],          \"socketio\": t.Optional[t.Dict[str, t.Any]],          \"ssl_context\": t.Optional[t.Union[str, t.Tuple[str, str]]],          \"flask\": t.Optional[t.Dict[str, t.Any]],      },      total=False,  )    Config = t.TypedDict(      \"Config\",      {          \"allow_unsafe_werkzeug\": bool,          \"async_mode\": str,          \"change_delay\": t.Optional[int],          \"chart_dark_template\": t.Optional[t.Dict[str, t.Any]],          \"base_url\": t.Optional[str],          \"dark_mode\": bool,          \"dark_theme\": t.Optional[t.Dict[str, t.Any]],          \"data_url_max_size\": t.Optional[int],          \"debug\": bool,          \"extended_status\": bool,          \"favicon\": t.Optional[str],          \"flask_log\": bool,          \"host\": str,          \"light_theme\": t.Optional[t.Dict[str, t.Any]],          \"margin\": t.Optional[str],          \"ngrok_token\": str,          \"notebook_proxy\": bool,          \"notification_duration\": int,          \"propagate\": bool,          \"run_browser\": bool,          \"run_in_thread\": bool,          \"run_server\": bool,          \"server_config\": t.Optional[ServerConfig],          \"single_client\": bool,          \"system_notification\": bool,          \"theme\": t.Optional[t.Dict[str, t.Any]],          \"time_zone\": t.Optional[str],          \"title\": t.Optional[str],          \"stylekit\": t.Union[bool, Stylekit],          \"upload_folder\": t.Optional[str],          \"use_arrow\": bool,          \"use_reloader\": bool,          \"watermark\": t.Optional[str],          \"webapp_path\": t.Optional[str],          \"port\": int,      },      total=False,  )      class _Config(object):      __RE_PORT_NUMBER = re.compile(          r\"^([0-9]{1,4}|[1-5][0-9]{4}|6[0-4][0-9]{3}|65[0-4][0-9]{2}|655[0-2][0-9]|6553[0-5])$\"      )        def __init__(self):          self.pages: t.List[_Page] = []          self.root_page: t.Optional[_Page] = None          self.routes: t.List[str] = []          self.partials: t.List[Partial] = []          self.partial_routes: t.List[str] = []          self.config: Config = {}        def _load(self, config: Config) -> None:          self.config.update(config)          # Check that the user timezone configuration setting is valid          self.get_time_zone()        def _get_config(self, name: ConfigParameter, default_value: t.Any) -> t.Any:  # pragma: no cover          if name in self.config and self.config[name] is not None:              if default_value is not None and not isinstance(self.config[name], type(default_value)):                  try:                      return type(default_value)(self.config[name])                  except Exception as e:                      _warn(f'app_config \"{name}\" value \"{self.config[name]}\" is not of type {type(default_value)}', e)                      return default_value              return self.config[name]          return default_value        def get_time_zone(self) -> t.Optional[str]:          tz = self.config.get(\"time_zone\")          if tz is None or tz == \"client\":              return tz          if tz == \"server\":              # return python tzlocal IANA Time Zone              return str(tzlocal.get_localzone())          # Verify user defined IANA Time Zone is valid          if tz not in pytz.all_timezones_set:              raise Exception(                  \"Time Zone configuration is not valid. Mistyped 'server', 'client' options or invalid IANA Time Zone\"              )          # return user defined IANA Time Zone (https://en.wikipedia.org/wiki/List_of_tz_database_time_zones)          return tz        def _handle_argparse(self):          _GuiCLI.create_parser()          args = _GuiCLI.parse_arguments()            config = self.config          if args.taipy_port:              if not _Config.__RE_PORT_NUMBER.match(args.taipy_port):                  _warn(\"Port value for --port option is not valid.\")              else:                  config[\"port\"] = int(args.taipy_port)          if args.taipy_host:              config[\"host\"] = args.taipy_host          if args.taipy_debug:              config[\"debug\"] = True          if args.taipy_no_debug:              config[\"debug\"] = False          if args.taipy_use_reloader:              config[\"use_reloader\"] = True          if args.taipy_no_reloader:              config[\"use_reloader\"] = False          if args.taipy_ngrok_token:              config[\"ngrok_token\"] = args.taipy_ngrok_token          if args.taipy_webapp_path:              config[\"webapp_path\"] = args.taipy_webapp_path          elif os.environ.get(\"TAIPY_GUI_WEBAPP_PATH\"):              config[\"webapp_path\"] = os.environ.get(\"TAIPY_GUI_WEBAPP_PATH\")        def _build_config(self, root_dir, env_filename, kwargs):  # pragma: no cover          config = self.config          env_file_abs_path = env_filename if os.path.isabs(env_filename) else os.path.join(root_dir, env_filename)          # Load keyword arguments          for key, value in kwargs.items():              key = key.lower()              if value is not None and key in config:                  # Special case for \"stylekit\" that can be a Boolean or a dict                  if key == \"stylekit\" and isinstance(value, bool):                      from ._default_config import _default_stylekit                        config[key] = _default_stylekit if value else {}                      continue                  try:                      if isinstance(value, dict) and isinstance(config[key], dict):                          config[key].update(value)                      else:                          config[key] = value if config[key] is None else type(config[key])(value)  # type: ignore                  except Exception as e:                      _warn(                          f\"Invalid keyword arguments value in Gui.run {key} - {value}. Unable to parse value to the correct type\",  # noqa: E501                          e,                      )          # Load config from env file          if os.path.isfile(env_file_abs_path):              for key, value in dotenv_values(env_file_abs_path).items():                  key = key.lower()                  if value is not None and key in config:                      try:                          config[key] = value if config[key] is None else type(config[key])(value)  # type: ignore                      except Exception as e:                          _warn(                              f\"Invalid env value in Gui.run(): {key} - {value}. Unable to parse value to the correct type\",  # noqa: E501                              e,                          )            # Taipy-config          if find_spec(\"taipy\") and find_spec(\"taipy.config\"):              from taipy.config import Config as TaipyConfig                try:                  section = TaipyConfig.unique_sections[\"gui\"]                  self.config.update(section._to_dict())              except KeyError:                  _warn(\"taipy-config section for taipy-gui is not initialized.\")            # Load from system arguments          self._handle_argparse()        def __log_outside_reloader(self, logger, msg):          if not is_running_from_reloader():              logger.info(msg)        def resolve(self):          app_config = self.config          logger = _TaipyLogger._get_logger()          # Special config for notebook runtime          if _is_in_notebook() or app_config[\"run_in_thread\"] and not app_config[\"single_client\"]:              app_config[\"single_client\"] = True              self.__log_outside_reloader(logger, \"Running in 'single_client' mode in notebook environment\")            if app_config[\"run_server\"] and app_config[\"ngrok_token\"] and app_config[\"use_reloader\"]:              app_config[\"use_reloader\"] = False              self.__log_outside_reloader(                  logger, \"'use_reloader' parameter will not be used when 'ngrok_token' parameter is available\"              )            if app_config[\"use_reloader\"] and _is_in_notebook():              app_config[\"use_reloader\"] = False              self.__log_outside_reloader(logger, \"'use_reloader' parameter is not available in notebook environment\")            if app_config[\"use_reloader\"] and not app_config[\"debug\"]:              app_config[\"debug\"] = True              self.__log_outside_reloader(logger, \"application is running in 'debug' mode\")            if app_config[\"debug\"] and not app_config[\"allow_unsafe_werkzeug\"]:              app_config[\"allow_unsafe_werkzeug\"] = True              self.__log_outside_reloader(logger, \"'allow_unsafe_werkzeug' has been set to True\")            if app_config[\"debug\"] and app_config[\"async_mode\"] != \"threading\":              app_config[\"async_mode\"] = \"threading\"              self.__log_outside_reloader(                  logger,                  \"'async_mode' parameter has been overridden to 'threading'. Using Flask built-in development server with debug mode\",  # noqa: E501              )            self._resolve_notebook_proxy()          self._resolve_stylekit()          self._resolve_url_prefix()        def _resolve_stylekit(self):          app_config = self.config          # support legacy margin variable          stylekit_config = app_config[\"stylekit\"]            if isinstance(app_config[\"stylekit\"], dict) and \"root_margin\" in app_config[\"stylekit\"]:              from ._default_config import _default_stylekit, default_config                stylekit_config = app_config[\"stylekit\"]              if (                  stylekit_config[\"root_margin\"] == _default_stylekit[\"root_margin\"]                  and app_config[\"margin\"] != default_config[\"margin\"]              ):                  app_config[\"stylekit\"][\"root_margin\"] = str(app_config[\"margin\"])              app_config[\"margin\"] = None        def _resolve_url_prefix(self):          app_config = self.config          base_url = app_config.get(\"base_url\")          if base_url is None:              app_config[\"base_url\"] = \"/\"          else:              base_url = f\"{'' if base_url.startswith('/') else '/'}{base_url}\"              base_url = f\"{base_url}{'' if base_url.endswith('/') else '/'}\"              app_config[\"base_url\"] = base_url        def _resolve_notebook_proxy(self):          app_config = self.config          app_config[\"notebook_proxy\"] = app_config[\"notebook_proxy\"] if _is_in_notebook() else False "}
{"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 threading  import typing as t    from ._warnings import _warn  from .gui import Gui  from .state import State      def download(      state: State, content: t.Any, name: t.Optional[str] = \"\", on_action: t.Optional[t.Union[str, t.Callable]] = \"\"  ):      \"\"\"Download content to the client.        Arguments:          state (State^): The current user state as received in any callback.          content: File path or file content. See below.          name: File name for the content on the client browser (defaults to content name).          on_action: Callback function (or callback name) to call when the download ends. See below.        ## Notes:        - *content*: this parameter can hold several values depending on your use case:          - a string: the value must be an existing path name to the file that gets downloaded or            the URL to the resource you want to download.          - a buffer (such as a `bytes` object): if the size of the buffer is smaller than             the [*data_url_max_size*](../gui/configuration.md#p-data_url_max_size) configuration             setting, then the [`python-magic`](https://pypi.org/project/python-magic/) package is             used to determine the [MIME type](https://en.wikipedia.org/wiki/Media_type) of the             buffer content, and the download is performed using a generated \"data:\" URL with             the relevant type, and a base64-encoded version of the buffer content.<br/>             If the buffer is too large, its content is transferred after saving it in a temporary             server file.        - *on_action*: this callback is triggered when the transfer of the content is achieved.</br>             In this function, you can perform any clean-up operation that could be required after             the download is completed.<br/>             This callback can use three optional parameters:             - *state*: the `State^` instance of the caller.             - *id* (optional): a string representing the identifier of the caller. If this function               is called directly, this will always be \"Gui.download\". Some controls may also trigger               download actions, and then *id* would reflect the identifier of those controls.             - *payload* (optional): an optional payload from the caller.<br/>               This is a dictionary with the following keys:                - *action*: the name of the callback;                - *args*: an array of two strings. The first element reflects the *name* parameter,                  and the second element reflects the server-side URL where the file is located.      \"\"\"      if state and isinstance(state._gui, Gui):          state._gui._download(content, name, on_action)      else:          _warn(\"'download()' must be called in the context of a callback.\")      def notify(      state: State,      notification_type: str = \"I\",      message: str = \"\",      system_notification: t.Optional[bool] = None,      duration: t.Optional[int] = None,  ):      \"\"\"Send a notification to the user interface.        Arguments:          state (State^): The current user state as received in any callback.          notification_type: The notification type. This can be one of \"success\", \"info\",              \"warning\", or \"error\".<br/>              To remove the last notification, set this parameter to the empty string.          message: The text message to display.          system_notification: If True, the system will also show the notification.<br/>              If not specified or set to None, this parameter will use the value of              *configuration[system_notification]*.          duration: The time, in milliseconds, during which the notification is shown.              If not specified or set to None, this parameter will use the value of              *configuration[notification_duration]*.        Note that you can also call this function with *notification_type* set to the first letter      or the alert type (i.e. setting *notification_type* to \"i\" is equivalent to setting it to      \"info\").        If *system_notification* is set to True, then the browser requests the system      to display a notification as well. They usually appear in small windows that      fly out of the system tray.<br/>      The first time your browser is requested to show such a system notification for      Taipy applications, you may be prompted to authorize the browser to do so. Please      refer to your browser documentation for details on how to allow or prevent this      feature.      \"\"\"      if state and isinstance(state._gui, Gui):          state._gui._notify(notification_type, message, system_notification, duration)      else:          _warn(\"'notify()' must be called in the context of a callback.\")      def hold_control(      state: State,      callback: t.Optional[t.Union[str, t.Callable]] = None,      message: t.Optional[str] = \"Work in Progress...\",  ):      \"\"\"Hold the User Interface actions.        When the User Interface is held, users cannot interact with visual elements.<br/>      The application must call `resume_control()^` so that users can interact again      with the visual elements.        You can set a callback function (or the name of a function) in the *callback* parameter. Then,      a \"Cancel\" button will be displayed so the user can cancel whatever is happening in the      application. When pressed, the callback is invoked.        Arguments:          state (State^): The current user state received in any callback.          callback (Optional[Union[str, Callable]]): The function to be called if the user              chooses to cancel.<br/>              If empty or None, no cancel action is provided to the user.<br/>              The signature of this function is:              - state (State^): The user state;              - id (str): the id of the button that triggered the callback. That will always be                \"UIBlocker\" since it is created and managed internally;          message: The message to show. The default value is the string \"Work in Progress...\".      \"\"\"      if state and isinstance(state._gui, Gui):          state._gui._hold_actions(callback, message)      else:          _warn(\"'hold_actions()' must be called in the context of a callback.\")      def resume_control(state: State):      \"\"\"Resume the User Interface actions.        This function must be called after `hold_control()^` was invoked, when interaction      must be allowed again for the user.        Arguments:          state (State^): The current user state as received in any callback.      \"\"\"      if state and isinstance(state._gui, Gui):          state._gui._resume_actions()      else:          _warn(\"'resume_actions()' must be called in the context of a callback.\")      def navigate(      state: State,      to: t.Optional[str] = \"\",      params: t.Optional[t.Dict[str, str]] = None,      tab: t.Optional[str] = None,      force: t.Optional[bool] = False,  ):      \"\"\"Navigate to a page.        Arguments:          state (State^): The current user state as received in any callback.          to: The name of the page to navigate to. This can be a page identifier (as created by              `Gui.add_page()^` with no leading '/') or an URL.<br/>              If omitted, the application navigates to the root page.          params: A dictionary of query parameters.          tab: When navigating to a page that is not a known page, the page is opened in a tab identified by              *tab* (as in [window.open](https://developer.mozilla.org/en-US/docs/Web/API/Window/open)).<br/>              The default value creates a new tab for the page (which is equivalent to setting *tab* to \"_blank\").          force: When navigating to a known page, the content is refreshed even it the page is already shown.      \"\"\"      if state and isinstance(state._gui, Gui):          state._gui._navigate(to, params, tab, force)      else:          _warn(\"'navigate()' must be called in the context of a callback.\")      def get_user_content_url(      state: State, path: t.Optional[str] = None, params: t.Optional[t.Dict[str, str]] = None  ) -> t.Optional[str]:      \"\"\"Get a user content URL.        This function can be used if you need to deliver dynamic content to your page: you can create      a path at run-time that, when queried, will deliver some user-defined content defined in the      *on_user_content* callback (see the description of the `Gui^` class for more information).        Arguments:          state (State^): The current user state as received in any callback.          path: An optional additional path to the URL.          params: An optional dictionary sent to the *on_user_content* callback.<br/>              These arguments are added as query parameters to the generated URL and converted into              strings.        Returns:          An URL that, when queried, triggers the *on_user_content* callback.      \"\"\"      if state and isinstance(state._gui, Gui):          return state._gui._get_user_content_url(path, params)      _warn(\"'get_user_content_url()' must be called in the context of a callback.\")      return None      def get_state_id(state: State) -> t.Optional[str]:      \"\"\"Get the identifier of a state.        The state identifier is a string generated by Taipy GUI for a given `State^` that is used      to serialize callbacks.      See the      [User Manual section on Long Running Callbacks](../gui/callbacks.md#long-running-callbacks)      for details on when and how this function can be used.        Arguments:          state (State^): The current user state as received in any callback.        Returns:          A string that uniquely identifies the state.<br/>          If None, then **state** was not handled by a `Gui^` instance.      \"\"\"      if state and isinstance(state._gui, Gui):          return state._gui._get_client_id()      return None      def get_module_context(state: State) -> t.Optional[str]:      \"\"\"Get the name of the module currently in used when using page scopes        Arguments:          state (State^): The current user state as received in any callback.        Returns:          The name of the current module      \"\"\"      if state and isinstance(state._gui, Gui):          return state._gui._get_locals_context()      return None      def get_context_id(state: State) -> t.Any:      _warn(\"'get_context_id()' was deprecated in Taipy GUI 2.0. Use 'get_state_id()' instead.\")      return get_state_id(state)      def get_module_name_from_state(state: State) -> t.Optional[str]:      \"\"\"Get the module name that triggered a callback.        Pages can be defined in different modules yet refer to callback functions declared elsewhere      (typically, the application's main module).        This function returns the name of the module where the page that holds the control that      triggered the callback was declared.  This lets applications implement different behaviors      depending on what page is involved.        This function must be called only in the body of a callback function.        Arguments:          state (State^): The `State^` instance, as received in any callback.        Returns:          The name of the module that holds the definition of the page containing the control              that triggered the callback that was provided the *state* object.      \"\"\"      if state and isinstance(state._gui, Gui):          return state._gui._get_locals_context()      return None      def invoke_callback(      gui: Gui,      state_id: str,      callback: t.Callable,      args: t.Union[t.Tuple, t.List],      module_context: t.Optional[str] = None,  ) -> t.Any:      \"\"\"Invoke a user callback for a given state.        See the      [User Manual section on Long Running Callbacks in a Thread](../gui/callbacks.md#long-running-callbacks-in-a-thread)      for details on when and how this function can be used.        Arguments:          gui (Gui^): The current Gui instance.          state_id: The identifier of the state to use, as returned by `get_state_id()^`.          callback (Callable[[State^, ...], None]): The user-defined function that is invoked.<br/>              The first parameter of this function **must** be a `State^`.          args (Union[Tuple, List]): The remaining arguments, as a List or a Tuple.          module_context (Optional[str]): the name of the module that will be used.      \"\"\"      if isinstance(gui, Gui):          return gui._call_user_callback(state_id, callback, list(args), module_context)      _warn(\"'invoke_callback()' must be called with a valid Gui instance.\")      def broadcast_callback(      gui: Gui,      callback: t.Callable,      args: t.Optional[t.Union[t.Tuple, t.List]] = None,      module_context: t.Optional[str] = None,  ) -> t.Any:      \"\"\"Invoke a callback for every client.        This callback gets invoked for every client connected to the application with the appropriate      `State^` instance. You can then perform client-specific tasks, such as updating the state      variable reflected in the user interface.        Arguments:          gui (Gui^): The current Gui instance.          callback: The user-defined function to be invoked.<br/>              The first parameter of this function must be a `State^` object representing the              client for which it is invoked.<br/>              The other parameters should reflect the ones provided in the *args* collection.          args: The parameters to send to *callback*, if any.      \"\"\"      if isinstance(gui, Gui):          return gui._call_broadcast_callback(callback, list(args) if args else [], module_context)      _warn(\"'broadcast_callback()' must be called with a valid Gui instance.\")      def invoke_state_callback(gui: Gui, state_id: str, callback: t.Callable, args: t.Union[t.Tuple, t.List]) -> t.Any:      _warn(\"'invoke_state_callback()' was deprecated in Taipy GUI 2.0. Use 'invoke_callback()' instead.\")      return invoke_callback(gui, state_id, callback, args)      def invoke_long_callback(      state: State,      user_function: t.Callable,      user_function_args: t.Union[t.Tuple, t.List] = [],      user_status_function: t.Optional[t.Callable] = None,      user_status_function_args: t.Union[t.Tuple, t.List] = [],      period=0,  ):      \"\"\"Invoke a long running user callback.        Long-running callbacks are run in a separate thread to not block the application itself.        This function expects to be provided a function to run in the background (in *user_function*).<br/>      It can also be specified a *status function* that is called when the operation performed by      *user_function* is finished (successfully or not), or periodically (using the *period* parameter).        See the      [User Manual section on Long Running Callbacks](../gui/callbacks.md#long-running-callbacks)      for details on when and how this function can be used.        Arguments:          state (State^): The `State^` instance, as received in any callback.          user_function (Callable[[...], None]): The function that will be run independently of Taipy GUI. Note              that this function must not use *state*, which is not persisted across threads.          user_function_args (Optional[List|Tuple]): The arguments to send to *user_function*.          user_status_function (Optional(Callable[[State^, bool, ...], None])): The optional user-defined status              function that is invoked at the end of and possibly during the runtime of *user_function*:                - The first parameter of this function is set to a `State^` instance.              - The second parameter of this function is set to a bool or an int, depending on the                conditions under which it is called:                   - If this parameter is set to a bool value, then:                       - If True, this indicates that *user_function* has finished properly.                          The last argument passed will be the result of the user_function call.                     - If False, this indicates that *user_function* failed.                   - If this parameter is set to an int value, then this value indicates                   how many periods (as lengthy as indicated in *period*) have elapsed since *user_function* was                   started.          user_status_function_args (Optional[List|Tuple]): The remaining arguments of the user status function.          period (int): The interval, in milliseconds, at which *user_status_function* is called.<br/>              The default value is 0, meaning no call to *user_status_function* will happen until *user_function*              terminates (then the second parameter of that call will be ).</br>              When set to a value smaller than 500, *user_status_function* is called only when *user_function*              terminates (as if *period* was set to 0).      \"\"\"      if not state or not isinstance(state._gui, Gui):          _warn(\"'invoke_long_callback()' must be called in the context of a callback.\")          return        state_id = get_state_id(state)      module_context = get_module_context(state)      if not isinstance(state_id, str) or not isinstance(module_context, str):          return        this_gui = state._gui        def callback_on_exception(state: State, function_name: str, e: Exception):          if not this_gui._call_on_exception(function_name, e):              _warn(f\"invoke_long_callback(): Exception raised in function {function_name}()\", e)        def callback_on_status(          status: t.Union[int, bool],          e: t.Optional[Exception] = None,          function_name: t.Optional[str] = None,          function_result: t.Optional[t.Any] = None,      ):          if callable(user_status_function):              invoke_callback(                  this_gui,                  str(state_id),                  user_status_function,                  [status] + list(user_status_function_args) + [function_result],  # type: ignore                  str(module_context),              )          if e:              invoke_callback(                  this_gui,                  str(state_id),                  callback_on_exception,                  (                      str(function_name),                      e,                  ),                  str(module_context),              )        def user_function_in_thread(*uf_args):          try:              res = user_function(*uf_args)              callback_on_status(True, function_result=res)          except Exception as e:              callback_on_status(False, e, user_function.__name__)        def thread_status(name: str, period_s: float, count: int):          active_thread = next((t for t in threading.enumerate() if t.name == name), None)          if active_thread:              callback_on_status(count)              threading.Timer(period_s, thread_status, (name, period_s, count + 1)).start()        thread = threading.Thread(target=user_function_in_thread, args=user_function_args)      thread.start()      if isinstance(period, int) and period >= 500 and callable(user_status_function):          thread_status(thread.name, period / 1000.0, 0) "}
{"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 __future__ import annotations    import contextlib  import importlib  import inspect  import json  import os  import pathlib  import re  import sys  import tempfile  import time  import typing as t  import warnings  from importlib import metadata, util  from importlib.util import find_spec  from types import FrameType, SimpleNamespace  from urllib.parse import unquote, urlencode, urlparse    import __main__  import markdown as md_lib  import tzlocal  from flask import Blueprint, Flask, g, jsonify, request, send_file, send_from_directory  from taipy.logger._taipy_logger import _TaipyLogger  from werkzeug.utils import secure_filename    if util.find_spec(\"pyngrok\"):      from pyngrok import ngrok    from ._default_config import _default_stylekit, default_config  from ._page import _Page  from ._renderers import _EmptyPage  from ._renderers._markdown import _TaipyMarkdownExtension  from ._renderers.factory import _Factory  from ._renderers.json import _TaipyJsonEncoder  from ._renderers.utils import _get_columns_dict  from ._warnings import TaipyGuiWarning, _warn  from .builder import _ElementApiGenerator  from .config import Config, ConfigParameter, _Config  from .data.content_accessor import _ContentAccessor  from .data.data_accessor import _DataAccessor, _DataAccessors  from .data.data_format import _DataFormat  from .data.data_scope import _DataScopes  from .extension.library import Element, ElementLibrary  from .gui_types import _WsType  from .page import Page  from .partial import Partial  from .server import _Server  from .state import State  from .utils import (      _delscopeattr,      _filter_locals,      _get_broadcast_var_name,      _get_client_var_name,      _get_css_var_value,      _get_expr_var_name,      _get_module_name_from_frame,      _get_non_existent_file_path,      _get_page_from_module,      _getscopeattr,      _getscopeattr_drill,      _hasscopeattr,      _is_in_notebook,      _LocalsContext,      _MapDict,      _setscopeattr,      _setscopeattr_drill,      _TaipyBase,      _TaipyContent,      _TaipyContentHtml,      _TaipyContentImage,      _TaipyData,      _TaipyLov,      _TaipyLovValue,      _to_camel_case,      _variable_decode,      is_debugging,  )  from .utils._adapter import _Adapter  from .utils._bindings import _Bindings  from .utils._evaluator import _Evaluator  from .utils._variable_directory import _MODULE_ID, _VariableDirectory  from .utils.chart_config_builder import _build_chart_config  from .utils.table_col_builder import _enhance_columns      class _DoNotUpdate:      def __repr__(self):          return \"Taipy: Do not update\"      class Gui:      \"\"\"Entry point for the Graphical User Interface generation.        Attributes:          on_action (Callable): The function that is called when a control              triggers an action, as the result of an interaction with the end-user.<br/>              It defaults to the `on_action()` global function defined in the Python              application. If there is no such function, actions will not trigger anything.<br/>              The signature of the *on_action* callback function must be:                - *state*: the `State^` instance of the caller.              - *id* (optional): a string representing the identifier of the caller.              - *payload* (optional): an optional payload from the caller.          on_change (Callable): The function that is called when a control              modifies variables it is bound to, as the result of an interaction with the              end-user.<br/>              It defaults to the `on_change()` global function defined in the Python              application. If there is no such function, user interactions will not trigger              anything.<br/>              The signature of the *on_change* callback function must be:                - *state*: the `State^` instance of the caller.              - *var_name* (str): The name of the variable that triggered this callback.              - *var_value* (any): The new value for this variable.          on_init (Callable): The function that is called on the first connection of a new client.<br/>              It defaults to the `on_init()` global function defined in the Python              application. If there is no such function, the first connection will not trigger              anything.<br/>                The signature of the *on_init* callback function must be:                - *state*: the `State^` instance of the caller.          on_navigate (Callable): The function that is called when a page is requested.<br/>              It defaults to the `on_navigate()` global function defined in the Python              application. If there is no such function, page requests will not trigger              anything.<br/>              The signature of the *on_navigate* callback function must be:                - *state*: the `State^` instance of the caller.              - *page_name*: the name of the page the user is navigating to.              - *params* (Optional): the query parameters provided in the URL.                The *on_navigate* callback function must return the name of the page the user should be              directed to.          on_exception (Callable): The function that is called an exception occurs on user code.<br/>              It defaults to the `on_exception()` global function defined in the Python              application. If there is no such function, exceptions will not trigger              anything.<br/>              The signature of the *on_exception* callback function must be:                - *state*: the `State^` instance of the caller.              - *function_name*: the name of the function that raised the exception.              - *exception*: the exception object that was raised.          on_status (Callable): The function that is called when the status page is shown.<br/>              It defaults to the `on_status()` global function defined in the Python              application. If there is no such function, status page content shows only the status of the              server.<br/>              The signature of the *on_status* callback function must be:                - *state*: the `State^` instance of the caller.                It must return raw and valid HTML content as a string.          on_user_content (Callable): The function that is called when a specific URL (generated by              `get_user_content_url()^`) is requested.<br/>              This callback function must return the raw HTML content of the page to be displayed on              the browser.                This attribute defaults to the `on_user_content()` global function defined in the Python              application. If there is no such function, those specific URLs will not trigger              anything.<br/>              The signature of the *on_user_content* callback function must be:                - *state*: the `State^` instance of the caller.              - *path*: the path provided to the `get_user_content_url()^` to build the URL.              - *parameters*: An optional dictionary as defined in the `get_user_content_url()^` call.                The returned HTML content can therefore use both the variables stored in the *state*              and the parameters provided in the call to `get_user_content_url()^`.          state (State^): **Only defined when running in an IPython notebook context.**<br/>              The unique instance of `State^` that you can use to change bound variables              directly, potentially impacting the user interface in real-time.        !!! note          This class belongs to and is documented in the `taipy.gui` package but it is          accessible from the top `taipy` package to simplify its access, allowing to          use:          ```py          from taipy import Gui          ```      \"\"\"        __root_page_name = \"TaiPy_root_page\"      __env_filename = \"taipy.gui.env\"      __UI_BLOCK_NAME = \"TaipyUiBlockVar\"      __MESSAGE_GROUPING_NAME = \"TaipyMessageGrouping\"      __ON_INIT_NAME = \"TaipyOnInit\"      __ARG_CLIENT_ID = \"client_id\"      __INIT_URL = \"taipy-init\"      __JSX_URL = \"taipy-jsx\"      __CONTENT_ROOT = \"taipy-content\"      __UPLOAD_URL = \"taipy-uploads\"      _EXTENSION_ROOT = \"taipy-extension\"      __USER_CONTENT_URL = \"taipy-user-content\"      __BROADCAST_G_ID = \"taipy_broadcasting\"      __BRDCST_CALLBACK_G_ID = \"taipy_brdcst_callback\"      __SELF_VAR = \"__gui\"      __DO_NOT_UPDATE_VALUE = _DoNotUpdate()      _HTML_CONTENT_KEY = \"__taipy_html_content\"      __USER_CONTENT_CB = \"custom_user_content_cb\"        __RE_HTML = re.compile(r\"(.*?)\\.html$\")      __RE_MD = re.compile(r\"(.*?)\\.md$\")      __RE_PY = re.compile(r\"(.*?)\\.py$\")      __RE_PAGE_NAME = re.compile(r\"^[\\w\\-\\/]+$\")        __reserved_routes: t.List[str] = [          __INIT_URL,          __JSX_URL,          __CONTENT_ROOT,          __UPLOAD_URL,          _EXTENSION_ROOT,          __USER_CONTENT_URL,      ]        __LOCAL_TZ = str(tzlocal.get_localzone())        __extensions: t.Dict[str, t.List[ElementLibrary]] = {}        __shared_variables: t.List[str] = []        __content_providers: t.Dict[type, t.Callable[..., str]] = {}        def __init__(          self,          page: t.Optional[t.Union[str, Page]] = None,          pages: t.Optional[dict] = None,          css_file: t.Optional[str] = None,          path_mapping: t.Optional[dict] = {},          env_filename: t.Optional[str] = None,          libraries: t.Optional[t.List[ElementLibrary]] = None,          flask: t.Optional[Flask] = None,      ):          \"\"\"Initialize a new Gui instance.            Arguments:              page (Optional[Union[str, Page^]]): An optional `Page^` instance that is used                  when there is a single page in this interface, referenced as the *root*                  page (located at `/`).<br/>                  If *page* is a raw string and if it holds a path to a readable file then                  a `Markdown^` page is built from the content of that file.<br/>                  If *page* is a string that does not indicate a path to readable file then                  a `Markdown^` page is built from that string.<br/>                  Note that if *pages* is provided, those pages are added as well.              pages (Optional[dict]): Used if you want to initialize this instance with a set                  of pages.<br/>                  The method `(Gui.)add_pages(pages)^` is called if *pages* is not None.                  You can find details on the possible values of this argument in the                  documentation for this method.              css_file (Optional[str]): A pathname to a CSS file that gets used as a style sheet in                  all the pages.<br/>                  The default value is a file that has the same base name as the Python                  file defining the `main` function, sitting next to this Python file,                  with the `.css` extension.              path_mapping (Optional[dict]): A dictionary that associates a URL prefix to                  a path in the server file system.<br/>                  If the assets of your application are located in */home/me/app_assets* and                  you want to access them using only '*assets*' in your application, you can                  set *path_mapping={\"assets\": \"/home/me/app_assets\"}*. If your application                  then requests the file *\"/assets/images/logo.png\"*, the server searches                  for the file  *\"/home/me/app_assets/images/logo.png\"*.<br/>                  If empty or not defined, access through the browser to all resources under the directory                  of the main Python file is allowed.              env_filename (Optional[str]): An optional file from which to load application                  configuration variables (see the                  [Configuration](../gui/configuration.md#configuring-the-gui-instance) section                  of the User Manual for details.)<br/>                  The default value is \"taipy.gui.env\"              libraries (Optional[List[ElementLibrary]]): An optional list of extension library                  instances that pages can reference.<br/>                  Using this argument is equivalent to calling `(Gui.)add_library()^` for each                  list's elements.              flask (Optional[Flask]): An optional instance of a Flask application object.<br/>                  If this argument is set, this `Gui` instance will use the value of this argument                  as the underlying server. If omitted or set to None, this `Gui` will create its                  own Flask application instance and use it to serve the pages.          \"\"\"          # store suspected local containing frame          self.__frame = t.cast(FrameType, t.cast(FrameType, inspect.currentframe()).f_back)          self.__default_module_name = _get_module_name_from_frame(self.__frame)          self._set_css_file(css_file)            # Preserve server config for server initialization          self._path_mapping = path_mapping          self._flask = flask            self._config = _Config()          self.__content_accessor = None          self._accessors = _DataAccessors()          self.__state: t.Optional[State] = None          self.__bindings = _Bindings(self)          self.__locals_context = _LocalsContext()          self.__var_dir = _VariableDirectory(self.__locals_context)            self.__evaluator: _Evaluator = None  # type: ignore          self.__adapter = _Adapter()          self.__directory_name_of_pages: t.List[str] = []            # default actions          self.on_action: t.Optional[t.Callable] = None          self.on_change: t.Optional[t.Callable] = None          self.on_init: t.Optional[t.Callable] = None          self.on_navigate: t.Optional[t.Callable] = None          self.on_exception: t.Optional[t.Callable] = None          self.on_status: t.Optional[t.Callable] = None          self.on_user_content: t.Optional[t.Callable] = None            # sid from client_id          self.__client_id_2_sid: t.Dict[str, t.Set[str]] = {}            # Load default config          self._flask_blueprint: t.List[Blueprint] = []          self._config._load(default_config)            # get taipy version          try:              gui_file = pathlib.Path(__file__ or \".\").resolve()              with open(gui_file.parent / \"version.json\") as version_file:                  self.__version = json.load(version_file)          except Exception as e:  # pragma: no cover              _warn(\"Cannot retrieve version.json file\", e)              self.__version = {}            # Load Markdown extension          # NOTE: Make sure, if you change this extension list, that the User Manual gets updated.          # There's a section that explicitly lists these extensions in          #      docs/gui/pages.md#markdown-specifics          self._markdown = md_lib.Markdown(              extensions=[                  \"fenced_code\",                  \"meta\",                  \"admonition\",                  \"sane_lists\",                  \"tables\",                  \"attr_list\",                  \"md_in_html\",                  _TaipyMarkdownExtension(gui=self),              ]          )            if page:              self.add_page(name=Gui.__root_page_name, page=page)          if pages is not None:              self.add_pages(pages)          if env_filename is not None:              self.__env_filename = env_filename          if libraries is not None:              for library in libraries:                  Gui.add_library(library)        @staticmethod      def add_library(library: ElementLibrary) -> None:          \"\"\"Add a custom visual element library.            This application will be able to use custom visual elements defined in this library.            Arguments:              library: The custom visual element library to add to this application.            Multiple libraries with the same name can be added. This allows to split multiple custom visual          elements in several `ElementLibrary^` instances, but still refer to these elements with the same          prefix in the page definitions.          \"\"\"          if isinstance(library, ElementLibrary):              _Factory.set_library(library)              library_name = library.get_name()              if library_name.isidentifier():                  libs = Gui.__extensions.get(library_name)                  if libs is None:                      Gui.__extensions[library_name] = [library]                  else:                      libs.append(library)                  _ElementApiGenerator().add_library(library)              else:                  raise NameError(f\"ElementLibrary passed to add_library() has an invalid name: '{library_name}'\")          else:  # pragma: no cover              raise RuntimeError(                  f\"add_library() argument should be a subclass of ElementLibrary instead of '{type(library)}'\"              )        @staticmethod      def register_content_provider(content_type: type, content_provider: t.Callable[..., str]) -> None:          \"\"\"Add a custom content provider.            The application can use custom content for the `part` block when its *content* property is set to an object with type *type*.            Arguments:              content_type: The type of the content that triggers the content provider.              content_provider: The function that converts content of type *type* into an HTML string.            \"\"\"  # noqa: E501          if Gui.__content_providers.get(content_type):              _warn(f\"The type {content_type} is already associated with a provider.\")              return          if not callable(content_provider):              _warn(f\"The provider for {content_type} must be a function.\")              return          Gui.__content_providers[content_type] = content_provider        def __process_content_provider(self, state: State, path: str, query: t.Dict[str, str]):          variable_name = query.get(\"variable_name\")          content = None          if variable_name:              content = _getscopeattr(self, variable_name)              if isinstance(content, _TaipyContentHtml):                  content = content.get()              provider_fn = Gui.__content_providers.get(type(content))              if provider_fn is None:                  # try plotly                  if find_spec(\"plotly\") and find_spec(\"plotly.graph_objs\"):                      from plotly.graph_objs import Figure as PlotlyFigure                        if isinstance(content, PlotlyFigure):                            def get_plotly_content(figure: PlotlyFigure):                              return figure.to_html()                            Gui.register_content_provider(PlotlyFigure, get_plotly_content)                          provider_fn = get_plotly_content              if provider_fn is None:                  # try matplotlib                  if find_spec(\"matplotlib\") and find_spec(\"matplotlib.figure\"):                      from matplotlib.figure import Figure as MatplotlibFigure                        if isinstance(content, MatplotlibFigure):                            def get_matplotlib_content(figure: MatplotlibFigure):                              import base64                              from io import BytesIO                                buf = BytesIO()                              figure.savefig(buf, format=\"png\")                              data = base64.b64encode(buf.getbuffer()).decode(\"ascii\")                              return f'<img src=\"data:image/png;base64,{data}\"/>'                            Gui.register_content_provider(MatplotlibFigure, get_matplotlib_content)                          provider_fn = get_matplotlib_content                if callable(provider_fn):                  try:                      return provider_fn(content)                  except Exception as e:                      _warn(f\"Error in content provider for type {str(type(content))}\", e)          return (              '<div style=\"background:white;color:red;\">'              + (f\"No valid provider for type {type(content).__name__}\" if content else \"Wrong context.\")              + \"</div>\"          )        @staticmethod      def add_shared_variable(*names: str) -> None:          \"\"\"Add shared variables.            The variables will be synchronized between all clients when updated.          Note that only variables from the main module will be registered.            This is a synonym for `(Gui.)add_shared_variables()^`.            Arguments:              names: The names of the variables that become shared, as a list argument.          \"\"\"          for name in names:              if name not in Gui.__shared_variables:                  Gui.__shared_variables.append(name)        @staticmethod      def add_shared_variables(*names: str) -> None:          \"\"\"Add shared variables.            The variables will be synchronized between all clients when updated.          Note that only variables from the main module will be registered.            This is a synonym for `(Gui.)add_shared_variable()^`.            Arguments:              names: The names of the variables that become shared, as a list argument.          \"\"\"          Gui.add_shared_variable(*names)        def _get_shared_variables(self) -> t.List[str]:          return self.__evaluator.get_shared_variables()        def __get_content_accessor(self):          if self.__content_accessor is None:              self.__content_accessor = _ContentAccessor(self._get_config(\"data_url_max_size\", 50 * 1024))          return self.__content_accessor        def _bindings(self):          return self.__bindings        def _get_data_scope(self) -> SimpleNamespace:          return self.__bindings._get_data_scope()        def _get_all_data_scopes(self) -> t.Dict[str, SimpleNamespace]:          return self.__bindings._get_all_scopes()        def _get_config(self, name: ConfigParameter, default_value: t.Any) -> t.Any:          return self._config._get_config(name, default_value)        def _get_themes(self) -> t.Optional[t.Dict[str, t.Any]]:          theme = self._get_config(\"theme\", None)          dark_theme = self._get_config(\"dark_theme\", None)          light_theme = self._get_config(\"light_theme\", None)          res = {}          if theme:              res[\"base\"] = theme          if dark_theme:              res[\"dark\"] = dark_theme          if light_theme:              res[\"light\"] = light_theme          return res if theme or dark_theme or light_theme else None        def _bind(self, name: str, value: t.Any) -> None:          self._bindings()._bind(name, value)        def __get_state(self):          return self.__state        def _get_client_id(self) -> str:          return (              _DataScopes._GLOBAL_ID              if self._bindings()._is_single_client()              else getattr(g, Gui.__ARG_CLIENT_ID, \"unknown id\")          )        def __set_client_id_in_context(self, client_id: t.Optional[str] = None, force=False):          if not client_id and request:              client_id = request.args.get(Gui.__ARG_CLIENT_ID, \"\")          if not client_id and force:              res = self._bindings()._get_or_create_scope(\"\")              client_id = res[0] if res[1] else None          if client_id and request:              if sid := getattr(request, \"sid\", None):                  sids = self.__client_id_2_sid.get(client_id, None)                  if sids is None:                      sids = set()                      self.__client_id_2_sid[client_id] = sids                  sids.add(sid)          g.client_id = client_id        def __is_var_modified_in_context(self, var_name: str, derived_vars: t.Set[str]) -> bool:          modified_vars: t.Optional[t.Set[str]] = getattr(g, \"modified_vars\", None)          der_vars: t.Optional[t.Set[str]] = getattr(g, \"derived_vars\", None)          setattr(g, \"update_count\", getattr(g, \"update_count\", 0) + 1)          if modified_vars is None:              modified_vars = set()              g.modified_vars = modified_vars          if der_vars is None:              g.derived_vars = derived_vars          else:              der_vars.update(derived_vars)          if var_name in modified_vars:              return True          modified_vars.add(var_name)          return False        def __clean_vars_on_exit(self) -> t.Optional[t.Set[str]]:          update_count = getattr(g, \"update_count\", 0) - 1          if update_count < 1:              derived_vars: t.Set[str] = getattr(g, \"derived_vars\", set())              delattr(g, \"update_count\")              delattr(g, \"modified_vars\")              delattr(g, \"derived_vars\")              return derived_vars          else:              setattr(g, \"update_count\", update_count)              return None        def _manage_message(self, msg_type: _WsType, message: dict) -> None:          try:              client_id = None              if msg_type == _WsType.CLIENT_ID.value:                  res = self._bindings()._get_or_create_scope(message.get(\"payload\", \"\"))                  client_id = res[0] if res[1] else None              self.__set_client_id_in_context(client_id or message.get(Gui.__ARG_CLIENT_ID))              with self._set_locals_context(message.get(\"module_context\") or None):                  if msg_type == _WsType.UPDATE.value:                      payload = message.get(\"payload\", {})                      self.__front_end_update(                          str(message.get(\"name\")),                          payload.get(\"value\"),                          message.get(\"propagate\", True),                          payload.get(\"relvar\"),                          payload.get(\"on_change\"),                      )                  elif msg_type == _WsType.ACTION.value:                      self.__on_action(message.get(\"name\"), message.get(\"payload\"))                  elif msg_type == _WsType.DATA_UPDATE.value:                      self.__request_data_update(str(message.get(\"name\")), message.get(\"payload\"))                  elif msg_type == _WsType.REQUEST_UPDATE.value:                      self.__request_var_update(message.get(\"payload\"))              self.__send_ack(message.get(\"ack_id\"))          except Exception as e:  # pragma: no cover              _warn(f\"Decoding Message has failed: {message}\", e)        def __front_end_update(          self,          var_name: str,          value: t.Any,          propagate=True,          rel_var: t.Optional[str] = None,          on_change: t.Optional[str] = None,      ) -> None:          if not var_name:              return          # Check if Variable is a managed type          current_value = _getscopeattr_drill(self, self.__evaluator.get_hash_from_expr(var_name))          if isinstance(current_value, _TaipyData):              return          elif rel_var and isinstance(current_value, _TaipyLovValue):  # pragma: no cover              lov_holder = _getscopeattr_drill(self, self.__evaluator.get_hash_from_expr(rel_var))              if isinstance(lov_holder, _TaipyLov):                  val = value if isinstance(value, list) else [value]                  elt_4_ids = self.__adapter._get_elt_per_ids(lov_holder.get_name(), lov_holder.get())                  ret_val = [elt_4_ids.get(x, x) for x in val]                  if isinstance(value, list):                      value = ret_val                  elif ret_val:                      value = ret_val[0]          elif isinstance(current_value, _TaipyBase):              value = current_value.cast_value(value)          self._update_var(              var_name, value, propagate, current_value if isinstance(current_value, _TaipyBase) else None, on_change          )        def _update_var(          self,          var_name: str,          value: t.Any,          propagate=True,          holder: t.Optional[_TaipyBase] = None,          on_change: t.Optional[str] = None,      ) -> None:          if holder:              var_name = holder.get_name()          hash_expr = self.__evaluator.get_hash_from_expr(var_name)          derived_vars = {hash_expr}          # set to broadcast mode if hash_expr is in shared_variable          if hash_expr in self._get_shared_variables():              self._set_broadcast()          # Use custom attrsetter function to allow value binding for _MapDict          if propagate:              _setscopeattr_drill(self, hash_expr, value)              # In case expression == hash (which is when there is only a single variable in expression)              if var_name == hash_expr or hash_expr.startswith(\"tpec_\"):                  derived_vars.update(self._re_evaluate_expr(var_name))          elif holder:              derived_vars.update(self._evaluate_holders(hash_expr))          # if the variable has been evaluated then skip updating to prevent infinite loop          var_modified = self.__is_var_modified_in_context(hash_expr, derived_vars)          if not var_modified:              self._call_on_change(                  var_name,                  value.get() if isinstance(value, _TaipyBase) else value._dict if isinstance(value, _MapDict) else value,                  on_change,              )          derived_modified = self.__clean_vars_on_exit()          if derived_modified is not None:              self.__send_var_list_update(list(derived_modified), var_name)        def _get_real_var_name(self, var_name: str) -> t.Tuple[str, str]:          if not var_name:              return (var_name, var_name)          # Handle holder prefix if needed          if var_name.startswith(_TaipyBase._HOLDER_PREFIX):              for hp in _TaipyBase._get_holder_prefixes():                  if var_name.startswith(hp):                      var_name = var_name[len(hp) :]                      break          suffix_var_name = \"\"          if \".\" in var_name:              first_dot_index = var_name.index(\".\")              suffix_var_name = var_name[first_dot_index + 1 :]              var_name = var_name[:first_dot_index]          var_name_decode, module_name = _variable_decode(self._get_expr_from_hash(var_name))          current_context = self._get_locals_context()          # #583: allow module resolution for var_name in current_context root_page context          if (              module_name              and self._config.root_page              and self._config.root_page._renderer              and self._config.root_page._renderer._get_module_name() == module_name          ):              return f\"{var_name_decode}.{suffix_var_name}\" if suffix_var_name else var_name_decode, module_name          if module_name == current_context:              var_name = var_name_decode          else:              if var_name not in self.__var_dir._var_head:                  raise NameError(f\"Can't find matching variable for {var_name} on context: {current_context}\")              _found = False              for k, v in self.__var_dir._var_head[var_name]:                  if v == current_context:                      var_name = k                      _found = True                      break              if not _found:  # pragma: no cover                  raise NameError(f\"Can't find matching variable for {var_name} on context: {current_context}\")          return f\"{var_name}.{suffix_var_name}\" if suffix_var_name else var_name, current_context        def _call_on_change(self, var_name: str, value: t.Any, on_change: t.Optional[str] = None):          try:              var_name, current_context = self._get_real_var_name(var_name)          except Exception as e:  # pragma: no cover              _warn(\"\", e)              return          on_change_fn = self._get_user_function(on_change) if on_change else None          if not callable(on_change_fn):              on_change_fn = self._get_user_function(\"on_change\")          if callable(on_change_fn):              try:                  argcount = on_change_fn.__code__.co_argcount                  if argcount > 0 and inspect.ismethod(on_change_fn):                      argcount -= 1                  args: t.List[t.Any] = [None for _ in range(argcount)]                  if argcount > 0:                      args[0] = self.__get_state()                  if argcount > 1:                      args[1] = var_name                  if argcount > 2:                      args[2] = value                  if argcount > 3:                      args[3] = current_context                  on_change_fn(*args)              except Exception as e:  # pragma: no cover                  if not self._call_on_exception(on_change or \"on_change\", e):                      _warn(f\"{on_change or 'on_change'}(): callback function raised an exception\", e)        def _get_content(self, var_name: str, value: t.Any, image: bool) -> t.Any:          ret_value = self.__get_content_accessor().get_info(var_name, value, image)          return f\"/{Gui.__CONTENT_ROOT}/{ret_value[0]}\" if isinstance(ret_value, tuple) else ret_value        def __serve_content(self, path: str) -> t.Any:          self.__set_client_id_in_context()          parts = path.split(\"/\")          if len(parts) > 1:              file_name = parts[-1]              (dir_path, as_attachment) = self.__get_content_accessor().get_content_path(                  path[: -len(file_name) - 1], file_name, request.args.get(\"bypass\")              )              if dir_path:                  return send_from_directory(str(dir_path), file_name, as_attachment=as_attachment)          return (\"\", 404)        def _get_user_content_url(          self, path: t.Optional[str] = None, query_args: t.Optional[t.Dict[str, str]] = None      ) -> t.Optional[str]:          qargs = query_args or {}          qargs.update({Gui.__ARG_CLIENT_ID: self._get_client_id()})          return f\"/{Gui.__USER_CONTENT_URL}/{path or 'TaIpY'}?{urlencode(qargs)}\"        def __serve_user_content(self, path: str) -> t.Any:          self.__set_client_id_in_context()          qargs: t.Dict[str, str] = {}          qargs.update(request.args)          qargs.pop(Gui.__ARG_CLIENT_ID, None)          cb_function: t.Optional[t.Union[t.Callable, str]] = None          cb_function_name = None          if qargs.get(Gui._HTML_CONTENT_KEY):              cb_function = self.__process_content_provider              cb_function_name = cb_function.__name__          else:              cb_function_name = qargs.get(Gui.__USER_CONTENT_CB)              if cb_function_name:                  cb_function = self._get_user_function(cb_function_name)                  if not callable(cb_function):                      parts = cb_function_name.split(\".\", 1)                      if len(parts) > 1:                          base = _getscopeattr(self, parts[0], None)                          if base and (meth := getattr(base, parts[1], None)):                              cb_function = meth                          else:                              base = self.__evaluator._get_instance_in_context(parts[0])                              if base and (meth := getattr(base, parts[1], None)):                                  cb_function = meth                  if not callable(cb_function):                      _warn(f\"{cb_function_name}() callback function has not been defined.\")                      cb_function = None          if cb_function is None:              cb_function_name = \"on_user_content\"              if hasattr(self, cb_function_name) and callable(self.on_user_content):                  cb_function = self.on_user_content              else:                  _warn(\"on_user_content() callback function has not been defined.\")          if callable(cb_function):              try:                  args: t.List[t.Any] = []                  if path:                      args.append(path)                  if len(qargs):                      args.append(qargs)                  ret = self._call_function_with_state(cb_function, args)                  if ret is None:                      _warn(f\"{cb_function_name}() callback function must return a value.\")                  else:                      return (ret, 200)              except Exception as e:  # pragma: no cover                  if not self._call_on_exception(str(cb_function_name), e):                      _warn(f\"{cb_function_name}() callback function raised an exception\", e)          return (\"\", 404)        def __serve_extension(self, path: str) -> t.Any:          parts = path.split(\"/\")          last_error = \"\"          resource_name = None          if len(parts) > 1:              libs = Gui.__extensions.get(parts[0], [])              for library in libs:                  try:                      resource_name = library.get_resource(\"/\".join(parts[1:]))                      if resource_name:                          return send_file(resource_name)                  except Exception as e:                      last_error = f\"\\n{e}\"  # Check if the resource is served by another library with the same name          _warn(f\"Resource '{resource_name or path}' not accessible for library '{parts[0]}'{last_error}\")          return (\"\", 404)        def __get_version(self) -> str:          return f'{self.__version.get(\"major\", 0)}.{self.__version.get(\"minor\", 0)}.{self.__version.get(\"patch\", 0)}'        def __append_libraries_to_status(self, status: t.Dict[str, t.Any]):          libraries: t.Dict[str, t.Any] = {}          for libs_list in self.__extensions.values():              for lib in libs_list:                  if not isinstance(lib, ElementLibrary):                      continue                  libs = libraries.get(lib.get_name())                  if libs is None:                      libs = []                      libraries[lib.get_name()] = libs                  elts: t.List[t.Dict[str, str]] = []                  libs.append({\"js module\": lib.get_js_module_name(), \"elements\": elts})                  for element_name, elt in lib.get_elements().items():                      if not isinstance(elt, Element):                          continue                      elt_dict = {\"name\": element_name}                      if hasattr(elt, \"_render_xhtml\"):                          elt_dict[\"render function\"] = elt._render_xhtml.__code__.co_name                      else:                          elt_dict[\"react name\"] = elt._get_js_name(element_name)                      elts.append(elt_dict)          status.update({\"libraries\": libraries})        def _serve_status(self, template: pathlib.Path) -> t.Dict[str, t.Dict[str, str]]:          base_json: t.Dict[str, t.Any] = {\"user_status\": str(self.__call_on_status() or \"\")}          if self._get_config(\"extended_status\", False):              base_json.update(                  {                      \"flask_version\": str(metadata.version(\"flask\") or \"\"),                      \"backend_version\": self.__get_version(),                      \"host\": f'{self._get_config(\"host\", \"localhost\")}:{self._get_config(\"port\", \"default\")}',                      \"python_version\": sys.version,                  }              )              self.__append_libraries_to_status(base_json)              try:                  base_json.update(json.loads(template.read_text()))              except Exception as e:  # pragma: no cover                  _warn(f\"Exception raised reading JSON in '{template}'\", e)          return {\"gui\": base_json}        def __upload_files(self):          self.__set_client_id_in_context()          if \"var_name\" not in request.form:              _warn(\"No var name\")              return (\"No var name\", 400)          var_name = request.form[\"var_name\"]          multiple = \"multiple\" in request.form and request.form[\"multiple\"] == \"True\"          if \"blob\" not in request.files:              _warn(\"No file part\")              return (\"No file part\", 400)          file = request.files[\"blob\"]          # If the user does not select a file, the browser submits an          # empty file without a filename.          if file.filename == \"\":              _warn(\"No selected file\")              return (\"No selected file\", 400)          suffix = \"\"          complete = True          part = 0          if \"total\" in request.form:              total = int(request.form[\"total\"])              if total > 1 and \"part\" in request.form:                  part = int(request.form[\"part\"])                  suffix = f\".part.{part}\"                  complete = part == total - 1          if file:  # and allowed_file(file.filename)              upload_path = pathlib.Path(self._get_config(\"upload_folder\", tempfile.gettempdir())).resolve()              file_path = _get_non_existent_file_path(upload_path, secure_filename(file.filename))              file.save(str(upload_path / (file_path.name + suffix)))              if complete:                  if part > 0:                      try:                          with open(file_path, \"wb\") as grouped_file:                              for nb in range(part + 1):                                  with open(upload_path / f\"{file_path.name}.part.{nb}\", \"rb\") as part_file:                                      grouped_file.write(part_file.read())                      except EnvironmentError as ee:  # pragma: no cover                          _warn(\"Cannot group file after chunk upload\", ee)                          return                  # notify the file is uploaded                  newvalue = str(file_path)                  if multiple:                      value = _getscopeattr(self, var_name)                      if not isinstance(value, t.List):                          value = [] if value is None else [value]                      value.append(newvalue)                      newvalue = value                  setattr(self._bindings(), var_name, newvalue)          return (\"\", 200)        _data_request_counter = 1        def __send_var_list_update(  # noqa C901          self,          modified_vars: t.List[str],          front_var: t.Optional[str] = None,      ):          ws_dict = {}          values = {v: _getscopeattr_drill(self, v) for v in modified_vars}          for k, v in values.items():              if isinstance(v, (_TaipyData, _TaipyContentHtml)) and v.get_name() in modified_vars:                  modified_vars.remove(v.get_name())              elif isinstance(v, _DoNotUpdate):                  modified_vars.remove(k)          for _var in modified_vars:              newvalue = values.get(_var)              if isinstance(newvalue, _TaipyData):                  # A changing integer that triggers a data request                  newvalue = Gui._data_request_counter                  Gui._data_request_counter = (Gui._data_request_counter % 100) + 1              else:                  if isinstance(newvalue, (_TaipyContent, _TaipyContentImage)):                      ret_value = self.__get_content_accessor().get_info(                          front_var, newvalue.get(), isinstance(newvalue, _TaipyContentImage)                      )                      if isinstance(ret_value, tuple):                          newvalue = f\"/{Gui.__CONTENT_ROOT}/{ret_value[0]}\"                      else:                          newvalue = ret_value                  elif isinstance(newvalue, _TaipyContentHtml):                      newvalue = self._get_user_content_url(                          None, {\"variable_name\": str(_var), Gui._HTML_CONTENT_KEY: str(time.time())}                      )                  elif isinstance(newvalue, _TaipyLov):                      newvalue = [self.__adapter._run_for_var(newvalue.get_name(), elt) for elt in newvalue.get()]                  elif isinstance(newvalue, _TaipyLovValue):                      if isinstance(newvalue.get(), list):                          newvalue = [                              self.__adapter._run_for_var(newvalue.get_name(), elt, id_only=True)                              for elt in newvalue.get()                          ]                      else:                          newvalue = self.__adapter._run_for_var(newvalue.get_name(), newvalue.get(), id_only=True)                  if isinstance(newvalue, (dict, _MapDict)):                      continue  # this var has no transformer                  debug_warnings: t.List[warnings.WarningMessage] = []                  with warnings.catch_warnings(record=True) as warns:                      warnings.resetwarnings()                      json.dumps(newvalue, cls=_TaipyJsonEncoder)                      if len(warns):                          keep_value = True                          for w in list(warns):                              if is_debugging():                                  debug_warnings.append(w)                              if w.category is not DeprecationWarning and w.category is not PendingDeprecationWarning:                                  keep_value = False                                  break                          if not keep_value:                              # do not send data that is not serializable                              continue                  for w in debug_warnings:                      warnings.warn(w.message, w.category)              ws_dict[_var] = newvalue          # TODO: What if value == newvalue?          self.__send_ws_update_with_dict(ws_dict)        def __request_data_update(self, var_name: str, payload: t.Any) -> None:          # Use custom attrgetter function to allow value binding for _MapDict          newvalue = _getscopeattr_drill(self, var_name)          if isinstance(newvalue, _TaipyData):              ret_payload = None              if isinstance(payload, dict):                  lib_name = payload.get(\"library\")                  if isinstance(lib_name, str):                      libs = self.__extensions.get(lib_name, [])                      for lib in libs:                          user_var_name = var_name                          try:                              with contextlib.suppress(NameError):                                  # ignore name error and keep var_name                                  user_var_name = self._get_real_var_name(var_name)[0]                              ret_payload = lib.get_data(lib_name, payload, user_var_name, newvalue)                              if ret_payload:                                  break                          except Exception as e:  # pragma: no cover                              _warn(                                  f\"Exception raised in '{lib_name}.get_data({lib_name}, payload, {user_var_name}, value)'\",  # noqa: E501                                  e,                              )              if not isinstance(ret_payload, dict):                  ret_payload = self._accessors._get_data(self, var_name, newvalue, payload)              self.__send_ws_update_with_dict({var_name: ret_payload})        def __request_var_update(self, payload: t.Any):          if isinstance(payload, dict) and isinstance(payload.get(\"names\"), list):              if payload.get(\"refresh\", False):                  # refresh vars                  for _var in t.cast(list, payload.get(\"names\")):                      val = _getscopeattr_drill(self, _var)                      self._refresh_expr(                          val.get_name() if isinstance(val, _TaipyBase) else _var,                          val if isinstance(val, _TaipyBase) else None,                      )              self.__send_var_list_update(payload[\"names\"])        def __send_ws(self, payload: dict, allow_grouping=True) -> None:          grouping_message = self.__get_message_grouping() if allow_grouping else None          if grouping_message is None:              try:                  self._server._ws.emit(                      \"message\",                      payload,                      to=self.__get_ws_receiver(),                  )                  time.sleep(0.001)              except Exception as e:  # pragma: no cover                  _warn(f\"Exception raised in WebSocket communication in '{self.__frame.f_code.co_name}'\", e)          else:              grouping_message.append(payload)        def __broadcast_ws(self, payload: dict):          try:              self._server._ws.emit(                  \"message\",                  payload,              )              time.sleep(0.001)          except Exception as e:  # pragma: no cover              _warn(f\"Exception raised in WebSocket communication in '{self.__frame.f_code.co_name}'\", e)        def __send_ack(self, ack_id: t.Optional[str]) -> None:          if ack_id:              try:                  self._server._ws.emit(\"message\", {\"type\": _WsType.ACKNOWLEDGEMENT.value, \"id\": ack_id})                  time.sleep(0.001)              except Exception as e:  # pragma: no cover                  _warn(f\"Exception raised in WebSocket communication (send ack) in '{self.__frame.f_code.co_name}'\", e)        def _send_ws_id(self, id: str) -> None:          self.__send_ws(              {                  \"type\": _WsType.CLIENT_ID.value,                  \"id\": id,              },              allow_grouping=False,          )        def __send_ws_download(self, content: str, name: str, on_action: str) -> None:          self.__send_ws({\"type\": _WsType.DOWNLOAD_FILE.value, \"content\": content, \"name\": name, \"onAction\": on_action})        def __send_ws_alert(self, type: str, message: str, system_notification: bool, duration: int) -> None:          self.__send_ws(              {                  \"type\": _WsType.ALERT.value,                  \"atype\": type,                  \"message\": message,                  \"system\": system_notification,                  \"duration\": duration,              }          )        def __send_ws_partial(self, partial: str):          self.__send_ws(              {                  \"type\": _WsType.PARTIAL.value,                  \"name\": partial,              }          )        def __send_ws_block(          self,          action: t.Optional[str] = None,          message: t.Optional[str] = None,          close: t.Optional[bool] = False,          cancel: t.Optional[bool] = False,      ):          self.__send_ws(              {                  \"type\": _WsType.BLOCK.value,                  \"action\": action,                  \"close\": close,                  \"message\": message,                  \"noCancel\": not cancel,              }          )        def __send_ws_navigate(          self,          to: str,          params: t.Optional[t.Dict[str, str]],          tab: t.Optional[str],          force: bool,      ):          self.__send_ws({\"type\": _WsType.NAVIGATE.value, \"to\": to, \"params\": params, \"tab\": tab, \"force\": force})        def __send_ws_update_with_dict(self, modified_values: dict) -> None:          payload = [              {\"name\": _get_client_var_name(k), \"payload\": (v if isinstance(v, dict) and \"value\" in v else {\"value\": v})}              for k, v in modified_values.items()          ]          if self._is_broadcasting():              self.__broadcast_ws({\"type\": _WsType.MULTIPLE_UPDATE.value, \"payload\": payload})              self._set_broadcast(False)          else:              self.__send_ws({\"type\": _WsType.MULTIPLE_UPDATE.value, \"payload\": payload})        def __send_ws_broadcast(self, var_name: str, var_value: t.Any):          self.__broadcast_ws(              {\"type\": _WsType.UPDATE.value, \"name\": _get_broadcast_var_name(var_name), \"payload\": {\"value\": var_value}}          )        def __get_ws_receiver(self) -> t.Union[t.List[str], t.Any, None]:          if self._bindings()._is_single_client():              return None          sid = getattr(request, \"sid\", None) if request else None          sids = self.__client_id_2_sid.get(self._get_client_id(), set())          if sid:              sids.add(sid)          return list(sids)        def __get_message_grouping(self):          return (              _getscopeattr(self, Gui.__MESSAGE_GROUPING_NAME)              if _hasscopeattr(self, Gui.__MESSAGE_GROUPING_NAME)              else None          )        def __enter__(self):          self.__hold_messages()          return self        def __exit__(self, exc_type, exc_value, traceback):          try:              self.__send_messages()          except Exception as e:  # pragma: no cover              _warn(\"Exception raised while sending messages\", e)          if exc_value:  # pragma: no cover              _warn(f\"An {exc_type or 'Exception'} was raised\", exc_value)          return True        def __hold_messages(self):          grouping_message = self.__get_message_grouping()          if grouping_message is None:              self._bind_var_val(Gui.__MESSAGE_GROUPING_NAME, [])        def __send_messages(self):          grouping_message = self.__get_message_grouping()          if grouping_message is not None:              _delscopeattr(self, Gui.__MESSAGE_GROUPING_NAME)              if len(grouping_message):                  self.__send_ws({\"type\": _WsType.MULTIPLE_MESSAGE.value, \"payload\": grouping_message})        def _get_user_function(self, func_name: str) -> t.Union[t.Callable, str]:          func = _getscopeattr(self, func_name, None)          if not callable(func):              func = self._get_locals_bind().get(func_name)          if not callable(func):              func = self.__locals_context.get_default().get(func_name)          return func if callable(func) else func_name        def _get_user_instance(self, class_name: str, class_type: type) -> t.Union[object, str]:          cls = _getscopeattr(self, class_name, None)          if not isinstance(cls, class_type):              cls = self._get_locals_bind().get(class_name)          if not isinstance(cls, class_type):              cls = self.__locals_context.get_default().get(class_name)          return cls if isinstance(cls, class_type) else class_name        def __on_action(self, id: t.Optional[str], payload: t.Any) -> None:          if isinstance(payload, dict):              action = payload.get(\"action\")          else:              action = str(payload)              payload = {\"action\": action}          if action:              if self.__call_function_with_args(action_function=self._get_user_function(action), id=id, payload=payload):                  return              else:  # pragma: no cover                  _warn(f\"on_action(): '{action}' is not a valid function.\")          if hasattr(self, \"on_action\"):              self.__call_function_with_args(action_function=self.on_action, id=id, payload=payload)        def __call_function_with_args(self, **kwargs):          action_function = kwargs.get(\"action_function\")          id = kwargs.get(\"id\")          payload = kwargs.get(\"payload\")            if callable(action_function):              try:                  argcount = action_function.__code__.co_argcount                  if argcount > 0 and inspect.ismethod(action_function):                      argcount -= 1                  args = [None for _ in range(argcount)]                  if argcount > 0:                      args[0] = self.__get_state()                  if argcount > 1:                      try:                          args[1] = self._get_real_var_name(id)[0]                      except Exception:                          args[1] = id                  if argcount > 2:                      args[2] = payload                  action_function(*args)                  return True              except Exception as e:  # pragma: no cover                  if not self._call_on_exception(action_function.__name__, e):                      _warn(f\"on_action(): Exception raised in '{action_function.__name__}()'\", e)          return False        def _call_function_with_state(self, user_function: t.Callable, args: t.List[t.Any]) -> t.Any:          args.insert(0, self.__get_state())          argcount = user_function.__code__.co_argcount          if argcount > 0 and inspect.ismethod(user_function):              argcount -= 1          if argcount > len(args):              args += (argcount - len(args)) * [None]          else:              args = args[:argcount]          return user_function(*args)        def _set_module_context(self, module_context: t.Optional[str]) -> t.ContextManager[None]:          return self._set_locals_context(module_context) if module_context is not None else contextlib.nullcontext()        def _call_user_callback(          self, state_id: t.Optional[str], user_callback: t.Callable, args: t.List[t.Any], module_context: t.Optional[str]      ) -> t.Any:          try:              with self.get_flask_app().app_context():                  self.__set_client_id_in_context(state_id)                  with self._set_module_context(module_context):                      return self._call_function_with_state(user_callback, args)          except Exception as e:  # pragma: no cover              if not self._call_on_exception(user_callback.__name__, e):                  _warn(f\"invoke_callback(): Exception raised in '{user_callback.__name__}()'\", e)          return None        def _call_broadcast_callback(          self, user_callback: t.Callable, args: t.List[t.Any], module_context: t.Optional[str]      ) -> t.Any:          @contextlib.contextmanager          def _broadcast_callback() -> t.Iterator[None]:              try:                  setattr(g, Gui.__BRDCST_CALLBACK_G_ID, True)                  yield              finally:                  setattr(g, Gui.__BRDCST_CALLBACK_G_ID, False)            with _broadcast_callback():              # Use global scopes for broadcast callbacks              return self._call_user_callback(_DataScopes._GLOBAL_ID, user_callback, args, module_context)        def _is_in_brdcst_callback(self):          try:              return getattr(g, Gui.__BRDCST_CALLBACK_G_ID, False)          except RuntimeError:              return False        # Proxy methods for Evaluator      def _evaluate_expr(self, expr: str) -> t.Any:          return self.__evaluator.evaluate_expr(self, expr)        def _re_evaluate_expr(self, var_name: str) -> t.Set[str]:          return self.__evaluator.re_evaluate_expr(self, var_name)        def _refresh_expr(self, var_name: str, holder: t.Optional[_TaipyBase]):          return self.__evaluator.refresh_expr(self, var_name, holder)        def _get_expr_from_hash(self, hash_val: str) -> str:          return self.__evaluator.get_expr_from_hash(hash_val)        def _evaluate_bind_holder(self, holder: t.Type[_TaipyBase], expr: str) -> str:          return self.__evaluator.evaluate_bind_holder(self, holder, expr)        def _evaluate_holders(self, expr: str) -> t.List[str]:          return self.__evaluator.evaluate_holders(self, expr)        def _is_expression(self, expr: str) -> bool:          if self.__evaluator is None:              return False          return self.__evaluator._is_expression(expr)        # make components resettable      def _set_building(self, building: bool):          self._building = building        def __is_building(self):          return hasattr(self, \"_building\") and self._building        def _get_rebuild_fn_name(self, name: str):          return f\"{Gui.__SELF_VAR}.{name}\"        def __get_attributes(self, attr_json: str, hash_json: str, args_dict: t.Dict[str, t.Any]):          attributes: t.Dict[str, t.Any] = json.loads(unquote(attr_json))          hashes: t.Dict[str, str] = json.loads(unquote(hash_json))          attributes.update({k: args_dict.get(v) for k, v in hashes.items()})          return attributes, hashes        def _tbl_cols(          self, rebuild: bool, rebuild_val: t.Optional[bool], attr_json: str, hash_json: str, **kwargs      ) -> t.Union[str, _DoNotUpdate]:          if not self.__is_building():              try:                  rebuild = rebuild_val if rebuild_val is not None else rebuild                  if rebuild:                      attributes, hashes = self.__get_attributes(attr_json, hash_json, kwargs)                      data_hash = hashes.get(\"data\", \"\")                      data = kwargs.get(data_hash)                      col_dict = _get_columns_dict(                          data,                          attributes.get(\"columns\", {}),                          self._accessors._get_col_types(data_hash, _TaipyData(data, data_hash)),                          attributes.get(\"date_format\"),                          attributes.get(\"number_format\"),                      )                      _enhance_columns(attributes, hashes, col_dict, \"table(cols)\")                        return json.dumps(col_dict, cls=_TaipyJsonEncoder)              except Exception as e:  # pragma: no cover                  _warn(\"Exception while rebuilding table columns\", e)          return Gui.__DO_NOT_UPDATE_VALUE        def _chart_conf(          self, rebuild: bool, rebuild_val: t.Optional[bool], attr_json: str, hash_json: str, **kwargs      ) -> t.Union[str, _DoNotUpdate]:          if not self.__is_building():              try:                  rebuild = rebuild_val if rebuild_val is not None else rebuild                  if rebuild:                      attributes, hashes = self.__get_attributes(attr_json, hash_json, kwargs)                      data_hash = hashes.get(\"data\", \"\")                      config = _build_chart_config(                          self,                          attributes,                          self._accessors._get_col_types(data_hash, _TaipyData(kwargs.get(data_hash), data_hash)),                      )                        return json.dumps(config, cls=_TaipyJsonEncoder)              except Exception as e:  # pragma: no cover                  _warn(\"Exception while rebuilding chart config\", e)          return Gui.__DO_NOT_UPDATE_VALUE        # Proxy methods for Adapter        def _add_adapter_for_type(self, type_name: str, adapter: t.Callable) -> None:          self.__adapter._add_for_type(type_name, adapter)        def _add_type_for_var(self, var_name: str, type_name: str) -> None:          self.__adapter._add_type_for_var(var_name, type_name)        def _get_adapter_for_type(self, type_name: str) -> t.Optional[t.Callable]:          return self.__adapter._get_for_type(type_name)        def _get_unique_type_adapter(self, type_name: str) -> str:          return self.__adapter._get_unique_type(type_name)        def _run_adapter(          self, adapter: t.Optional[t.Callable], value: t.Any, var_name: str, id_only=False      ) -> t.Union[t.Tuple[str, ...], str, None]:          return self.__adapter._run(adapter, value, var_name, id_only)        def _get_valid_adapter_result(self, value: t.Any, id_only=False) -> t.Union[t.Tuple[str, ...], str, None]:          return self.__adapter._get_valid_result(value, id_only)        def _is_ui_blocked(self):          return _getscopeattr(self, Gui.__UI_BLOCK_NAME, False)        def __get_on_cancel_block_ui(self, callback: t.Optional[str]):          def _taipy_on_cancel_block_ui(guiApp, id: t.Optional[str], payload: t.Any):              if _hasscopeattr(guiApp, Gui.__UI_BLOCK_NAME):                  _setscopeattr(guiApp, Gui.__UI_BLOCK_NAME, False)              guiApp.__on_action(id, {\"action\": callback})            return _taipy_on_cancel_block_ui        def __add_pages_in_folder(self, folder_name: str, folder_path: str):          from ._renderers import Html, Markdown            list_of_files = os.listdir(folder_path)          for file_name in list_of_files:              if file_name.startswith(\"__\"):                  continue              if (re_match := Gui.__RE_HTML.match(file_name)) and f\"{re_match.group(1)}.py\" not in list_of_files:                  _renderers = Html(os.path.join(folder_path, file_name), frame=None)                  _renderers.modify_taipy_base_url(folder_name)                  self.add_page(name=f\"{folder_name}/{re_match.group(1)}\", page=_renderers)              elif (re_match := Gui.__RE_MD.match(file_name)) and f\"{re_match.group(1)}.py\" not in list_of_files:                  _renderers_md = Markdown(os.path.join(folder_path, file_name), frame=None)                  self.add_page(name=f\"{folder_name}/{re_match.group(1)}\", page=_renderers_md)              elif re_match := Gui.__RE_PY.match(file_name):                  module_name = re_match.group(1)                  module_path = os.path.join(folder_name, module_name).replace(os.path.sep, \".\")                  try:                      module = importlib.import_module(module_path)                      page_instance = _get_page_from_module(module)                      if page_instance is not None:                          self.add_page(name=f\"{folder_name}/{module_name}\", page=page_instance)                  except Exception as e:                      _warn(f\"Error while importing module '{module_path}'\", e)              elif os.path.isdir(child_dir_path := os.path.join(folder_path, file_name)):                  child_dir_name = f\"{folder_name}/{file_name}\"                  self.__add_pages_in_folder(child_dir_name, child_dir_path)        # Proxy methods for LocalsContext      def _get_locals_bind(self) -> t.Dict[str, t.Any]:          return self.__locals_context.get_locals()        def _get_default_locals_bind(self) -> t.Dict[str, t.Any]:          return self.__locals_context.get_default()        def _get_locals_bind_from_context(self, context: t.Optional[str]) -> t.Dict[str, t.Any]:          return self.__locals_context._get_locals_bind_from_context(context)        def _get_locals_context(self) -> str:          current_context = self.__locals_context.get_context()          return current_context if current_context is not None else self.__default_module_name        def _set_locals_context(self, context: t.Optional[str]) -> t.ContextManager[None]:          return self.__locals_context.set_locals_context(context)        def _get_page_context(self, page_name: str) -> str | None:          if page_name not in self._config.routes:              return None          page = None          for p in self._config.pages:              if p._route == page_name:                  page = p          if page is None:              return None          return (              (page._renderer._get_module_name() or self.__default_module_name)              if page._renderer is not None              else self.__default_module_name          )        @staticmethod      def _get_root_page_name():          return Gui.__root_page_name        def _set_flask(self, flask: Flask):          self._flask = flask        def _get_default_module_name(self):          return self.__default_module_name        @staticmethod      def _get_timezone() -> str:          return Gui.__LOCAL_TZ        @staticmethod      def _set_timezone(tz: str):          Gui.__LOCAL_TZ = tz        # Public methods      def add_page(          self,          name: str,          page: t.Union[str, Page],          style: t.Optional[str] = \"\",      ) -> None:          \"\"\"Add a page to the Graphical User Interface.            Arguments:              name: The name of the page.              page (Union[str, Page^]): The content of the page.<br/>                  It can be an instance of `Markdown^` or `Html^`.<br/>                  If *page* is a string, then:                    - If *page* is set to the pathname of a readable file, the page                    content is read as Markdown input text.                  - If it is not, the page content is read from this string as                    Markdown text.              style (Optional[str]): Additional CSS style to apply to this page.                    - if there is style associated with a page, it is used at a global level                  - if there is no style associated with the page, the style is cleared at a global level                  - if the page is embedded in a block control, the style is ignored            Note that page names cannot start with the slash ('/') character and that each          page must have a unique name.          \"\"\"          # Validate name          if name is None:  # pragma: no cover              raise Exception(\"name is required for add_page() function.\")          if not Gui.__RE_PAGE_NAME.match(name):  # pragma: no cover              raise SyntaxError(                  f'Page name \"{name}\" is invalid. It must only contain letters, digits, dash (-), underscore (_), and forward slash (/) characters.'  # noqa: E501              )          if name.startswith(\"/\"):  # pragma: no cover              raise SyntaxError(f'Page name \"{name}\" cannot start with forward slash (/) character.')          if name in self._config.routes:  # pragma: no cover              raise Exception(f'Page name \"{name if name != Gui.__root_page_name else \"/\"}\" is already defined.')          if isinstance(page, str):              from ._renderers import Markdown                page = Markdown(page, frame=None)          elif not isinstance(page, Page):  # pragma: no cover              raise Exception(                  f'Parameter \"page\" is invalid for page name \"{name if name != Gui.__root_page_name else \"/\"}.'              )          # Init a new page          new_page = _Page()          new_page._route = name          new_page._renderer = page          new_page._style = style          # Append page to _config          self._config.pages.append(new_page)          self._config.routes.append(name)          # set root page          if name == Gui.__root_page_name:              self._config.root_page = new_page          # Update locals context          self.__locals_context.add(page._get_module_name(), page._get_locals())          # Update variable directory          if not page._is_class_module():              self.__var_dir.add_frame(page._frame)        def add_pages(self, pages: t.Optional[t.Union[t.Mapping[str, t.Union[str, Page]], str]] = None) -> None:          \"\"\"Add several pages to the Graphical User Interface.            Arguments:              pages (Union[dict[str, Union[str, Page^]], str]): The pages to add.<br/>                  If *pages* is a dictionary, a page is added to this `Gui` instance                  for each of the entries in *pages*:                    - The entry key is used as the page name.                  - The entry value is used as the page content:                      - The value can can be an instance of `Markdown^` or `Html^`, then                        it is used as the page definition.                      - If entry value is a string, then:                          - If it is set to the pathname of a readable file, the page                            content is read as Markdown input text.                          - If it is not, the page content is read from this string as                            Markdown text.            !!! note \"Reading pages from a directory\"              If *pages* is a string that holds the path to a readable directory, then              this directory is traversed, recursively, to find files that Taipy can build              pages from.                For every new directory that is traversed, a new hierarchical level              for pages is created.                For every file that is found:                - If the filename extension is *.md*, it is read as Markdown content and                a new page is created with the base name of this filename.              - If the filename extension is *.html*, it is read as HTML content and                a new page is created with the base name of this filename.                For example, say you have the following directory structure:              ```              reports              \u251c\u2500\u2500 home.html              \u251c\u2500\u2500 budget/              \u2502   \u251c\u2500\u2500 expenses/              \u2502   \u2502   \u251c\u2500\u2500 marketing.md              \u2502   \u2502   \u2514\u2500\u2500 production.md              \u2502   \u2514\u2500\u2500 revenue/              \u2502       \u251c\u2500\u2500 EMAE.md              \u2502       \u251c\u2500\u2500 USA.md              \u2502       \u2514\u2500\u2500 ASIA.md              \u2514\u2500\u2500 cashflow/                  \u251c\u2500\u2500 weekly.md                  \u251c\u2500\u2500 monthly.md                  \u2514\u2500\u2500 yearly.md              ```                Calling `gui.add_pages('reports')` is equivalent to calling:              ```py              gui.add_pages({                              \"reports/home\", Html(\"reports/home.html\"),                              \"reports/budget/expenses/marketing\", Markdown(\"reports/budget/expenses/marketing.md\"),                              \"reports/budget/expenses/production\", Markdown(\"reports/budget/expenses/production.md\"),                              \"reports/budget/revenue/EMAE\", Markdown(\"reports/budget/revenue/EMAE.md\"),                              \"reports/budget/revenue/USA\", Markdown(\"reports/budget/revenue/USA.md\"),                              \"reports/budget/revenue/ASIA\", Markdown(\"reports/budget/revenue/ASIA.md\"),                              \"reports/cashflow/weekly\", Markdown(\"reports/cashflow/weekly.md\"),                              \"reports/cashflow/monthly\", Markdown(\"reports/cashflow/monthly.md\"),                              \"reports/cashflow/yearly\", Markdown(\"reports/cashflow/yearly.md\")              })              ```          \"\"\"          if isinstance(pages, dict):              for k, v in pages.items():                  if k == \"/\":                      k = Gui.__root_page_name                  self.add_page(name=k, page=v)          elif isinstance(folder_name := pages, str):              if not hasattr(self, \"_root_dir\"):                  self._root_dir = os.path.dirname(inspect.getabsfile(self.__frame))              folder_path = folder_name if os.path.isabs(folder_name) else os.path.join(self._root_dir, folder_name)              folder_name = os.path.basename(folder_path)              if not os.path.isdir(folder_path):  # pragma: no cover                  raise RuntimeError(f\"Path {folder_path} is not a valid directory\")              if folder_name in self.__directory_name_of_pages:  # pragma: no cover                  raise Exception(f\"Base directory name {folder_name} of path {folder_path} is not unique\")              if folder_name in Gui.__reserved_routes:  # pragma: no cover                  raise Exception(f\"Invalid directory. Directory {folder_name} is a reserved route\")              self.__directory_name_of_pages.append(folder_name)              self.__add_pages_in_folder(folder_name, folder_path)        # partials        def add_partial(          self,          page: t.Union[str, Page],      ) -> Partial:          \"\"\"Create a new `Partial^`.            The [User Manual section on Partials](../gui/pages/index.md#partials) gives details on          when and how to use this class.            Arguments:              page (Union[str, Page^]): The page to create a new Partial from.<br/>                  It can be an instance of `Markdown^` or `Html^`.<br/>                  If *page* is a string, then:                    - If *page* is set to the pathname of a readable file, the content of                    the new `Partial` is read as Markdown input text.                  - If it is not, the content of the new `Partial` is read from this string                    as Markdown text.            Returns:              The new `Partial` object defined by *page*.          \"\"\"          new_partial = Partial()          # Validate name          if (              new_partial._route in self._config.partial_routes or new_partial._route in self._config.routes          ):  # pragma: no cover              _warn(f'Partial name \"{new_partial._route}\" is already defined.')          if isinstance(page, str):              from ._renderers import Markdown                page = Markdown(page, frame=None)          elif not isinstance(page, Page):  # pragma: no cover              raise Exception(f'Partial name \"{new_partial._route}\" has an invalid Page.')          new_partial._renderer = page          # Append partial to _config          self._config.partials.append(new_partial)          self._config.partial_routes.append(str(new_partial._route))          # Update locals context          self.__locals_context.add(page._get_module_name(), page._get_locals())          # Update variable directory          self.__var_dir.add_frame(page._frame)          return new_partial        def _update_partial(self, partial: Partial):          partials = _getscopeattr(self, Partial._PARTIALS, {})          partials[partial._route] = partial          _setscopeattr(self, Partial._PARTIALS, partials)          self.__send_ws_partial(str(partial._route))        def _get_partial(self, route: str) -> t.Optional[Partial]:          partials = _getscopeattr(self, Partial._PARTIALS, {})          partial = partials.get(route)          if partial is None:              partial = next((p for p in self._config.partials if p._route == route), None)          return partial        # Main binding method (bind in markdown declaration)      def _bind_var(self, var_name: str) -> str:          bind_context = None          if var_name in self._get_locals_bind().keys():              bind_context = self._get_locals_context()          if bind_context is None:              encoded_var_name = self.__var_dir.add_var(var_name, self._get_locals_context(), var_name)          else:              encoded_var_name = self.__var_dir.add_var(var_name, bind_context)          if not hasattr(self._bindings(), encoded_var_name):              bind_locals = self._get_locals_bind_from_context(bind_context)              if var_name in bind_locals.keys():                  self._bind(encoded_var_name, bind_locals[var_name])              else:                  _warn(                      f\"Variable '{var_name}' is not available in either the '{self._get_locals_context()}' or '__main__' modules.\"  # noqa: E501                  )          return encoded_var_name        def _bind_var_val(self, var_name: str, value: t.Any) -> bool:          if _MODULE_ID not in var_name:              var_name = self.__var_dir.add_var(var_name, self._get_locals_context())          if not hasattr(self._bindings(), var_name):              self._bind(var_name, value)              return True          return False        def __bind_local_func(self, name: str):          func = getattr(self, name, None)          if func is not None and not callable(func):  # pragma: no cover              _warn(f\"{self.__class__.__name__}.{name}: {func} should be a function; looking for {name} in the script.\")              func = None          if func is None:              func = self._get_locals_bind().get(name)          if func is not None:              if callable(func):                  setattr(self, name, func)              else:  # pragma: no cover                  _warn(f\"{name}: {func} should be a function.\")        def load_config(self, config: Config) -> None:          self._config._load(config)        def _broadcast(self, name: str, value: t.Any):          \"\"\"NOT UNDOCUMENTED          Send the new value of a variable to all connected clients.            Arguments:              name: The name of the variable to update or create.              value: The value (must be serializable to the JSON format).          \"\"\"          self.__send_ws_broadcast(name, value)        def _broadcast_all_clients(self, name: str, value: t.Any):          try:              self._set_broadcast()              self._update_var(name, value)          finally:              self._set_broadcast(False)        def _set_broadcast(self, broadcast: bool = True):          with contextlib.suppress(RuntimeError):              setattr(g, Gui.__BROADCAST_G_ID, broadcast)        def _is_broadcasting(self) -> bool:          try:              return getattr(g, Gui.__BROADCAST_G_ID, False)          except RuntimeError:              return False        def _download(          self, content: t.Any, name: t.Optional[str] = \"\", on_action: t.Optional[t.Union[str, t.Callable]] = \"\"      ):          if callable(on_action) and on_action.__name__:              on_action_name = (                  _get_expr_var_name(str(on_action.__code__))                  if on_action.__name__ == \"<lambda>\"                  else _get_expr_var_name(on_action.__name__)              )              if on_action_name:                  self._bind_var_val(on_action_name, on_action)                  on_action = on_action_name              else:                  _warn(\"download() on_action is invalid.\")          content_str = self._get_content(\"Gui.download\", content, False)          self.__send_ws_download(content_str, str(name), str(on_action))        def _notify(          self,          notification_type: str = \"I\",          message: str = \"\",          system_notification: t.Optional[bool] = None,          duration: t.Optional[int] = None,      ):          self.__send_ws_alert(              notification_type,              message,              self._get_config(\"system_notification\", False) if system_notification is None else system_notification,              self._get_config(\"notification_duration\", 3000) if duration is None else duration,          )        def _hold_actions(          self,          callback: t.Optional[t.Union[str, t.Callable]] = None,          message: t.Optional[str] = \"Work in Progress...\",      ):  # pragma: no cover          action_name = callback.__name__ if callable(callback) else callback          # TODO: what if lambda? (it does work)          func = self.__get_on_cancel_block_ui(action_name)          def_action_name = func.__name__          _setscopeattr(self, def_action_name, func)            if _hasscopeattr(self, Gui.__UI_BLOCK_NAME):              _setscopeattr(self, Gui.__UI_BLOCK_NAME, True)          else:              self._bind(Gui.__UI_BLOCK_NAME, True)          self.__send_ws_block(action=def_action_name, message=message, cancel=bool(action_name))        def _resume_actions(self):  # pragma: no cover          if _hasscopeattr(self, Gui.__UI_BLOCK_NAME):              _setscopeattr(self, Gui.__UI_BLOCK_NAME, False)          self.__send_ws_block(close=True)        def _navigate(          self,          to: t.Optional[str] = \"\",          params: t.Optional[t.Dict[str, str]] = None,          tab: t.Optional[str] = None,          force: t.Optional[bool] = False,      ):          to = to or Gui.__root_page_name          if not to.startswith(\"/\") and to not in self._config.routes and not urlparse(to).netloc:              _warn(f'Cannot navigate to \"{to if to != Gui.__root_page_name else \"/\"}\": unknown page.')              return False          self.__send_ws_navigate(to if to != Gui.__root_page_name else \"/\", params, tab, force or False)          return True        def __init_libs(self):          for name, libs in self.__extensions.items():              for lib in libs:                  if not isinstance(lib, ElementLibrary):                      continue                  try:                      self._call_function_with_state(lib.on_user_init, [])                  except Exception as e:  # pragma: no cover                      if not self._call_on_exception(f\"{name}.on_user_init\", e):                          _warn(f\"Exception raised in {name}.on_user_init()\", e)        def __init_route(self):          self.__set_client_id_in_context(force=True)          if not _hasscopeattr(self, Gui.__ON_INIT_NAME):              _setscopeattr(self, Gui.__ON_INIT_NAME, True)              self.__pre_render_pages()              self.__init_libs()              if hasattr(self, \"on_init\") and callable(self.on_init):                  try:                      self._call_function_with_state(self.on_init, [])                  except Exception as e:  # pragma: no cover                      if not self._call_on_exception(\"on_init\", e):                          _warn(\"Exception raised in on_init()\", e)          return self._render_route()        def _call_on_exception(self, function_name: str, exception: Exception) -> bool:          if hasattr(self, \"on_exception\") and callable(self.on_exception):              try:                  self.on_exception(self.__get_state(), str(function_name), exception)              except Exception as e:  # pragma: no cover                  _warn(\"Exception raised in on_exception()\", e)              return True          return False        def __call_on_status(self) -> t.Optional[str]:          if hasattr(self, \"on_status\") and callable(self.on_status):              try:                  return self.on_status(self.__get_state())              except Exception as e:  # pragma: no cover                  if not self._call_on_exception(\"on_status\", e):                      _warn(\"Exception raised in on_status\", e)          return None        def __pre_render_pages(self) -> None:          \"\"\"Pre-render all pages to have a proper initialization of all variables\"\"\"          self.__set_client_id_in_context()          for page in self._config.pages:              if page is not None:                  with contextlib.suppress(Exception):                      page.render(self)        def __render_page(self, page_name: str) -> t.Any:          self.__set_client_id_in_context()          nav_page = page_name          if hasattr(self, \"on_navigate\") and callable(self.on_navigate):              try:                  if self.on_navigate.__code__.co_argcount == 2:                      nav_page = self.on_navigate(self.__get_state(), page_name)                  else:                      params = request.args.to_dict() if hasattr(request, \"args\") else {}                      params.pop(\"client_id\", None)                      params.pop(\"v\", None)                      nav_page = self.on_navigate(self.__get_state(), page_name, params)                  if nav_page != page_name:                      if isinstance(nav_page, str):                          if self._navigate(nav_page):                              return (\"Root page cannot be re-routed by on_navigate().\", 302)                      else:                          _warn(f\"on_navigate() returned an invalid page name '{nav_page}'.\")                      nav_page = page_name              except Exception as e:  # pragma: no cover                  if not self._call_on_exception(\"on_navigate\", e):                      _warn(\"Exception raised in on_navigate()\", e)          page = next((page_i for page_i in self._config.pages if page_i._route == nav_page), None)            # Try partials          if page is None:              page = self._get_partial(nav_page)          # Make sure that there is a page instance found          if page is None:              return (                  jsonify({\"error\": f\"Page '{nav_page}' doesn't exist.\"}),                  400,                  {\"Content-Type\": \"application/json; charset=utf-8\"},              )          context = page.render(self)          if (              nav_page == Gui.__root_page_name              and page._rendered_jsx is not None              and \"<PageContent\" not in page._rendered_jsx          ):              page._rendered_jsx += \"<PageContent />\"          # Return jsx page          if page._rendered_jsx is not None:              return self._server._render(                  page._rendered_jsx, page._style if page._style is not None else \"\", page._head, context              )          else:              return (\"No page template\", 404)        def _render_route(self) -> t.Any:          return self._server._direct_render_json(              {                  \"locations\": {                      \"/\" if route == Gui.__root_page_name else f\"/{route}\": f\"/{route}\" for route in self._config.routes                  },                  \"blockUI\": self._is_ui_blocked(),              }          )        def _register_data_accessor(self, data_accessor_class: t.Type[_DataAccessor]) -> None:          self._accessors._register(data_accessor_class)        def get_flask_app(self) -> Flask:          \"\"\"Get the internal Flask application.            This method must be called **after** `(Gui.)run()^` was invoked.            Returns:              The Flask instance used.          \"\"\"          if hasattr(self, \"_server\"):              return self._server.get_flask()          raise RuntimeError(\"get_flask_app() cannot be invoked before run() has been called.\")        def _set_frame(self, frame: FrameType):          if not isinstance(frame, FrameType):  # pragma: no cover              raise RuntimeError(\"frame must be a FrameType where Gui can collect the local variables.\")          self.__frame = frame          self.__default_module_name = _get_module_name_from_frame(self.__frame)        def _set_css_file(self, css_file: t.Optional[str] = None):          if css_file is None:              script_file = pathlib.Path(self.__frame.f_code.co_filename or \".\").resolve()              if script_file.with_suffix(\".css\").exists():                  css_file = f\"{script_file.stem}.css\"              elif script_file.is_dir() and (script_file / \"taipy.css\").exists():                  css_file = \"taipy.css\"          self.__css_file = css_file        def _set_state(self, state: State):          if isinstance(state, State):              self.__state = state        def __get_client_config(self) -> t.Dict[str, t.Any]:          config = {              \"timeZone\": self._config.get_time_zone(),              \"darkMode\": self._get_config(\"dark_mode\", True),              \"baseURL\": self._config._get_config(\"base_url\", \"/\"),          }          if themes := self._get_themes():              config[\"themes\"] = themes          if len(self.__extensions):              config[\"extensions\"] = {}              for libs in self.__extensions.values():                  for lib in libs:                      config[\"extensions\"][f\"./{Gui._EXTENSION_ROOT}/{lib.get_js_module_name()}\"] = [  # type: ignore                          e._get_js_name(n)                          for n, e in lib.get_elements().items()                          if isinstance(e, Element) and not e._is_server_only()                      ]          if stylekit := self._get_config(\"stylekit\", _default_stylekit):              config[\"stylekit\"] = {_to_camel_case(k): v for k, v in stylekit.items()}          return config        def __get_css_vars(self) -> str:          css_vars = []          if stylekit := self._get_config(\"stylekit\", _default_stylekit):              for k, v in stylekit.items():                  css_vars.append(f'--{k.replace(\"_\", \"-\")}:{_get_css_var_value(v)};')          return \" \".join(css_vars)        def __init_server(self):          app_config = self._config.config          # Init server if there is no server          if not hasattr(self, \"_server\"):              self._server = _Server(                  self,                  path_mapping=self._path_mapping,                  flask=self._flask,                  async_mode=app_config[\"async_mode\"],                  allow_upgrades=not app_config[\"notebook_proxy\"],                  server_config=app_config.get(\"server_config\"),              )            # Stop and reinitialize the server if it is still running as a thread          if (_is_in_notebook() or app_config[\"run_in_thread\"]) and hasattr(self._server, \"_thread\"):              self.stop()              self._flask_blueprint = []              self._server = _Server(                  self,                  path_mapping=self._path_mapping,                  flask=self._flask,                  async_mode=app_config[\"async_mode\"],                  allow_upgrades=not app_config[\"notebook_proxy\"],                  server_config=app_config.get(\"server_config\"),              )              self._bindings()._new_scopes()        def __init_ngrok(self):          app_config = self._config.config          if app_config[\"run_server\"] and app_config[\"ngrok_token\"]:  # pragma: no cover              if not util.find_spec(\"pyngrok\"):                  raise RuntimeError(\"Cannot use ngrok as pyngrok package is not installed.\")              ngrok.set_auth_token(app_config[\"ngrok_token\"])              http_tunnel = ngrok.connect(app_config[\"port\"], \"http\")              _TaipyLogger._get_logger().info(f\" * NGROK Public Url: {http_tunnel.public_url}\")        def __bind_default_function(self):          with self.get_flask_app().app_context():              self.__var_dir.process_imported_var()              # bind on_* function if available              self.__bind_local_func(\"on_init\")              self.__bind_local_func(\"on_change\")              self.__bind_local_func(\"on_action\")              self.__bind_local_func(\"on_navigate\")              self.__bind_local_func(\"on_exception\")              self.__bind_local_func(\"on_status\")              self.__bind_local_func(\"on_user_content\")        def __register_blueprint(self):          # add en empty main page if it is not defined          if Gui.__root_page_name not in self._config.routes:              new_page = _Page()              new_page._route = Gui.__root_page_name              new_page._renderer = _EmptyPage()              self._config.pages.append(new_page)              self._config.routes.append(Gui.__root_page_name)            pages_bp = Blueprint(\"taipy_pages\", __name__)          self._flask_blueprint.append(pages_bp)            # server URL Rule for taipy images          images_bp = Blueprint(\"taipy_images\", __name__)          images_bp.add_url_rule(f\"/{Gui.__CONTENT_ROOT}/<path:path>\", view_func=self.__serve_content)          self._flask_blueprint.append(images_bp)            # server URL for uploaded files          upload_bp = Blueprint(\"taipy_upload\", __name__)          upload_bp.add_url_rule(f\"/{Gui.__UPLOAD_URL}\", view_func=self.__upload_files, methods=[\"POST\"])          self._flask_blueprint.append(upload_bp)            # server URL for user content          user_content_bp = Blueprint(\"taipy_user_content\", __name__)          user_content_bp.add_url_rule(f\"/{Gui.__USER_CONTENT_URL}/<path:path>\", view_func=self.__serve_user_content)          self._flask_blueprint.append(user_content_bp)            # server URL for extension resources          extension_bp = Blueprint(\"taipy_extensions\", __name__)          extension_bp.add_url_rule(f\"/{Gui._EXTENSION_ROOT}/<path:path>\", view_func=self.__serve_extension)          scripts = [              s if bool(urlparse(s).netloc) else f\"/{Gui._EXTENSION_ROOT}/{name}/{s}{lib.get_query(s)}\"              for name, libs in Gui.__extensions.items()              for lib in libs              for s in (lib.get_scripts() or [])          ]          styles = [              s if bool(urlparse(s).netloc) else f\"/{Gui._EXTENSION_ROOT}/{name}/{s}{lib.get_query(s)}\"              for name, libs in Gui.__extensions.items()              for lib in libs              for s in (lib.get_styles() or [])          ]          if self._get_config(\"stylekit\", True):              styles.append(\"stylekit/stylekit.css\")          else:              styles.append(\"https://fonts.googleapis.com/css?family=Roboto:300,400,500,700&display=swap\")          if self.__css_file:              styles.append(f\"/{self.__css_file}\")            self._flask_blueprint.append(extension_bp)            _conf_webapp_path = (              pathlib.Path(self._get_config(\"webapp_path\", None)) if self._get_config(\"webapp_path\", None) else None          )          _webapp_path = str((pathlib.Path(__file__).parent / \"webapp\").resolve())          if _conf_webapp_path:              if _conf_webapp_path.is_dir():                  _webapp_path = str(_conf_webapp_path.resolve())                  _warn(f\"Using webapp_path: '{_conf_webapp_path}'.\")              else:  # pragma: no cover                  _warn(                      f\"webapp_path: '{_conf_webapp_path}' is not a valid directory path. Falling back to '{_webapp_path}'.\"  # noqa: E501                  )            self._flask_blueprint.append(              self._server._get_default_blueprint(                  static_folder=_webapp_path,                  template_folder=_webapp_path,                  title=self._get_config(\"title\", \"Taipy App\"),                  favicon=self._get_config(\"favicon\", \"favicon.png\"),                  root_margin=self._get_config(\"margin\", None),                  scripts=scripts,                  styles=styles,                  version=self.__get_version(),                  client_config=self.__get_client_config(),                  watermark=self._get_config(\"watermark\", None),                  css_vars=self.__get_css_vars(),                  base_url=self._get_config(\"base_url\", \"/\"),              )          )            # Run parse markdown to force variables binding at runtime          pages_bp.add_url_rule(f\"/{Gui.__JSX_URL}/<path:page_name>\", view_func=self.__render_page)            # server URL Rule for flask rendered react-router          pages_bp.add_url_rule(f\"/{Gui.__INIT_URL}\", view_func=self.__init_route)            # Register Flask Blueprint if available          for bp in self._flask_blueprint:              self._server.get_flask().register_blueprint(bp)        def run(          self,          run_server: bool = True,          run_in_thread: bool = False,          async_mode: str = \"gevent\",          **kwargs,      ) -> t.Optional[Flask]:          \"\"\"          Start the server that delivers pages to web clients.            Once you enter `run()`, users can run web browsers and point to the web server          URL that `Gui` serves. The default is to listen to the *localhost* address          (127.0.0.1) on the port number 5000. However, the configuration of this `Gui`          object may impact that (see the          [Configuration](../gui/configuration.md#configuring-the-gui-instance)          section of the User Manual for details).            Arguments:              run_server (bool): Whether or not to run a web server locally.                  If set to *False*, a web server is *not* created and started.              run_in_thread (bool): Whether or not to run a web server in a separated thread.                  If set to *True*, the web server runs is a separated thread.<br/>                  Note that if you are running in an IPython notebook context, the web                  server always runs in a separate thread.              async_mode (str): The asynchronous model to use for the Flask-SocketIO.                  Valid values are:<br/>                    - \"gevent\": Use a [gevent](https://www.gevent.org/servers.html) server.                  - \"threading\": Use the Flask Development Server. This allows the application to use                    the Flask reloader (the *use_reloader* option) and Debug mode (the *debug* option).                  - \"eventlet\": Use an [*eventlet*](https://flask.palletsprojects.com/en/2.2.x/deploying/eventlet/)                    event-driven WSGI server.                    The default value is \"gevent\"<br/>                  Note that only the \"threading\" value provides support for the development reloader                  functionality (*use_reloader* option). Any other value makes the *use_reloader* configuration parameter                  ignored.<br/>                  Also note that setting the *debug* argument to True forces *async_mode* to \"threading\".              **kwargs (dict[str, any]): Additional keyword arguments that configure how this `Gui` is run.                  Please refer to the                  [Configuration section](../gui/configuration.md#configuring-the-gui-instance)                  of the User Manual for more information.            Returns:              The Flask instance if *run_server* is False else None.          \"\"\"          # --------------------------------------------------------------------------------          # The ssl_context argument was removed just after 1.1. It was defined as:          # t.Optional[t.Union[ssl.SSLContext, t.Tuple[str, t.Optional[str]], t.Literal[\"adhoc\"]]] = None          #          # With the doc:          #     ssl_context (Optional[Union[ssl.SSLContext, Tuple[str, Optional[str]], te.Literal['adhoc']]]):          #         Configures TLS to serve over HTTPS. This value can be:          #          #         - An `ssl.SSLContext` object          #         - A `(cert_file, key_file)` tuple to create a typical context          #         - The string \"adhoc\" to generate a temporary self-signed certificate.          #          #         The default value is None.          # --------------------------------------------------------------------------------          app_config = self._config.config            run_root_dir = os.path.dirname(inspect.getabsfile(self.__frame))            # Register _root_dir for abs path          if not hasattr(self, \"_root_dir\"):              self._root_dir = run_root_dir            is_reloading = kwargs.pop(\"_reload\", False)            if not is_reloading:              self.__run_kwargs = kwargs = {                  **kwargs,                  \"run_server\": run_server,                  \"run_in_thread\": run_in_thread,                  \"async_mode\": async_mode,              }            # Load application config from multiple sources (env files, kwargs, command line)          self._config._build_config(run_root_dir, self.__env_filename, kwargs)            self._config.resolve()          TaipyGuiWarning.set_debug_mode(self._get_config(\"debug\", False))            self.__init_server()            self.__init_ngrok()            locals_bind = _filter_locals(self.__frame.f_locals)            self.__locals_context.set_default(locals_bind, self.__default_module_name)            self.__var_dir.set_default(self.__frame)            if self.__state is None or is_reloading:              self.__state = State(self, self.__locals_context.get_all_keys(), self.__locals_context.get_all_context())            if _is_in_notebook():              # Allow gui.state.x in notebook mode              self.state = self.__state            self.__bind_default_function()            # Base global ctx is TaipyHolder classes + script modules and callables          glob_ctx: t.Dict[str, t.Any] = {t.__name__: t for t in _TaipyBase.__subclasses__()}          glob_ctx.update({k: v for k, v in locals_bind.items() if inspect.ismodule(v) or callable(v)})          glob_ctx[Gui.__SELF_VAR] = self            # Call on_init on each library          for name, libs in self.__extensions.items():              for lib in libs:                  if not isinstance(lib, ElementLibrary):                      continue                  try:                      lib_context = lib.on_init(self)                      if (                          isinstance(lib_context, tuple)                          and len(lib_context) > 1                          and isinstance(lib_context[0], str)                          and lib_context[0].isidentifier()                      ):                          if lib_context[0] in glob_ctx:                              _warn(f\"Method {name}.on_init() returned a name already defined '{lib_context[0]}'.\")                          else:                              glob_ctx[lib_context[0]] = lib_context[1]                      elif lib_context:                          _warn(                              f\"Method {name}.on_init() should return a Tuple[str, Any] where the first element must be a valid Python identifier.\"  # noqa: E501                          )                  except Exception as e:  # pragma: no cover                      if not self._call_on_exception(f\"{name}.on_init\", e):                          _warn(f\"Method {name}.on_init() raised an exception\", e)            # Initiate the Evaluator with the right context          self.__evaluator = _Evaluator(glob_ctx, self.__shared_variables)            self.__register_blueprint()            # Register data accessor communication data format (JSON, Apache Arrow)          self._accessors._set_data_format(_DataFormat.APACHE_ARROW if app_config[\"use_arrow\"] else _DataFormat.JSON)            # Use multi user or not          self._bindings()._set_single_client(bool(app_config[\"single_client\"]))            # Start Flask Server          if not run_server:              return self.get_flask_app()            return self._server.run(              host=app_config[\"host\"],              port=app_config[\"port\"],              debug=app_config[\"debug\"],              use_reloader=app_config[\"use_reloader\"],              flask_log=app_config[\"flask_log\"],              run_in_thread=app_config[\"run_in_thread\"],              allow_unsafe_werkzeug=app_config[\"allow_unsafe_werkzeug\"],              notebook_proxy=app_config[\"notebook_proxy\"],          )        def reload(self):  # pragma: no cover          \"\"\"          Reload the web server.            This function reloads the underlying web server only in the situation where          it was run in a separated thread: the *run_in_thread* parameter to the          `(Gui.)run^` method was set to True, or you are running in an IPython notebook          context.          \"\"\"          if hasattr(self, \"_server\") and hasattr(self._server, \"_thread\") and self._server._is_running:              self._server.stop_thread()              self.run(**self.__run_kwargs, _reload=True)              _TaipyLogger._get_logger().info(\"Gui server has been reloaded.\")        def stop(self):          \"\"\"          Stop the web server.            This function stops the underlying web server only in the situation where          it was run in a separated thread: the *run_in_thread* parameter to the          `(Gui.)run()^` method was set to True, or you are running in an IPython notebook          context.          \"\"\"          if hasattr(self, \"_server\") and hasattr(self._server, \"_thread\") and self._server._is_running:              self._server.stop_thread()              _TaipyLogger._get_logger().info(\"Gui server has been stopped.\") "}
{"text": "import inspect  import typing as t  from contextlib import nullcontext  from operator import attrgetter  from types import FrameType    from flask import has_app_context  from flask.ctx import AppContext    from .utils import _get_module_name_from_frame, _is_in_notebook  from .utils._attributes import _attrsetter    if t.TYPE_CHECKING:      from .gui import Gui      class State:      \"\"\"Accessor to the bound variables from callbacks.        `State` is used when you need to access the value of variables      bound to visual elements (see [Binding](../gui/binding.md)).<br/>      Because each browser connected to the application server may represent and      modify any variable at any moment as the result of user interaction, each      connection holds its own set of variables along with their values. We call      the set of these the application variables the application _state_, as seen      by a given client.        Each callback (see [Callbacks](../gui/callbacks.md)) receives a specific      instance of the `State` class, where you can find all the variables bound to      visual elements in your application.        Note that `State` also is a Python Context Manager: In situations where you      have several variables to update, it is more clear and more efficient to assign      the variable values in a `with` construct:      ```py      def my_callback(state, ...):        ...        with state as s:          s.var1 = value1          s.var2 = value2        ...      ```        You cannot set a variable in the context of a lambda function because Python      prevents any use of the assignment operator.<br/>      You can, however, use the `assign()` method on the state that the lambda function      receives, so you can work around this limitation:        Here is how you could define a button that changes the value of a variable      directly in a page expressed using Markdown:      ```         <|Set variable|button|on_action={lambda s: s.assign(\"var_name\", new_value)}|>      ```      This would be strictly similar to the Markdown line:      ```         <|Set variable|button|on_action=change_variable|>      ```      with the Python code:      ```py      def change_variable(state):          state.var_name = new_value      ```      \"\"\"        __gui_attr = \"_gui\"      __attrs = (          __gui_attr,          \"_user_var_list\",          \"_context_list\",      )      __methods = (          \"assign\",          \"broadcast\",          \"get_gui\",          \"refresh\",          \"_set_context\",          \"_notebook_context\",          \"_get_placeholder\",          \"_set_placeholder\",          \"_get_gui_attr\",          \"_get_placeholder_attrs\",          \"_add_attribute\",      )      __placeholder_attrs = (          \"_taipy_p1\",          \"_current_context\",      )      __excluded_attrs = __attrs + __methods + __placeholder_attrs        def __init__(self, gui: \"Gui\", var_list: t.Iterable[str], context_list: t.Iterable[str]) -> None:          super().__setattr__(State.__attrs[1], list(State.__filter_var_list(var_list, State.__excluded_attrs)))          super().__setattr__(State.__attrs[2], list(context_list))          super().__setattr__(State.__attrs[0], gui)        def get_gui(self) -> \"Gui\":          \"\"\"Return the Gui instance for this state object.            Returns:              Gui: The Gui instance for this state object.          \"\"\"          return super().__getattribute__(State.__gui_attr)        @staticmethod      def __filter_var_list(var_list: t.Iterable[str], excluded_attrs: t.Iterable[str]) -> t.Iterable[str]:          return filter(lambda n: n not in excluded_attrs, var_list)        def __getattribute__(self, name: str) -> t.Any:          if name in State.__methods:              return super().__getattribute__(name)          gui: \"Gui\" = self.get_gui()          if name == State.__gui_attr:              return gui          if name in State.__excluded_attrs:              raise AttributeError(f\"Variable '{name}' is protected and is not accessible.\")          if gui._is_in_brdcst_callback() and (              name not in gui._get_shared_variables() and not gui._bindings()._is_single_client()          ):              raise AttributeError(f\"Variable '{name}' is not available to be accessed in shared callback.\")          if name not in super().__getattribute__(State.__attrs[1]):              raise AttributeError(f\"Variable '{name}' is not defined.\")          with self._notebook_context(gui), self._set_context(gui):              encoded_name = gui._bind_var(name)              return getattr(gui._bindings(), encoded_name)        def __setattr__(self, name: str, value: t.Any) -> None:          gui: \"Gui\" = super().__getattribute__(State.__gui_attr)          if gui._is_in_brdcst_callback() and (              name not in gui._get_shared_variables() and not gui._bindings()._is_single_client()          ):              raise AttributeError(f\"Variable '{name}' is not available to be accessed in shared callback.\")          if name not in super().__getattribute__(State.__attrs[1]):              raise AttributeError(f\"Variable '{name}' is not accessible.\")          with self._notebook_context(gui), self._set_context(gui):              encoded_name = gui._bind_var(name)              setattr(gui._bindings(), encoded_name, value)        def __getitem__(self, key: str):          context = key if key in super().__getattribute__(State.__attrs[2]) else None          if context is None:              gui: \"Gui\" = super().__getattribute__(State.__gui_attr)              page_ctx = gui._get_page_context(key)              context = page_ctx if page_ctx is not None else None          if context is None:              raise RuntimeError(f\"Can't resolve context '{key}' from state object\")          self._set_placeholder(State.__placeholder_attrs[1], context)          return self        def _set_context(self, gui: \"Gui\") -> t.ContextManager[None]:          if (pl_ctx := self._get_placeholder(State.__placeholder_attrs[1])) is not None:              self._set_placeholder(State.__placeholder_attrs[1], None)              if pl_ctx != gui._get_locals_context():                  return gui._set_locals_context(pl_ctx)          if len(inspect.stack()) > 1:              ctx = _get_module_name_from_frame(t.cast(FrameType, t.cast(FrameType, inspect.stack()[2].frame)))              current_context = gui._get_locals_context()              # ignore context if the current one starts with the new one (to resolve for class modules)              if ctx != current_context and not current_context.startswith(str(ctx)):                  return gui._set_locals_context(ctx)          return nullcontext()        def _notebook_context(self, gui: \"Gui\"):          return gui.get_flask_app().app_context() if not has_app_context() and _is_in_notebook() else nullcontext()        def _get_placeholder(self, name: str):          if name in State.__placeholder_attrs:              try:                  return super().__getattribute__(name)              except AttributeError:                  return None          return None        def _set_placeholder(self, name: str, value: t.Any):          if name in State.__placeholder_attrs:              super().__setattr__(name, value)        def _get_placeholder_attrs(self):          return State.__placeholder_attrs        def _add_attribute(self, name: str, default_value: t.Optional[t.Any] = None) -> bool:          attrs: t.List[str] = super().__getattribute__(State.__attrs[1])          if name not in attrs:              attrs.append(name)              gui = super().__getattribute__(State.__gui_attr)              return gui._bind_var_val(name, default_value)          return False        def assign(self, name: str, value: t.Any) -> t.Any:          \"\"\"Assign a value to a state variable.            This should be used only from within a lambda function used          as a callback in a visual element.            Arguments:              name (str): The variable name to assign to.              value (Any): The new variable value.            Returns:              Any: The previous value of the variable.          \"\"\"          val = attrgetter(name)(self)          _attrsetter(self, name, value)          return val        def refresh(self, name: str):          \"\"\"Refresh a state variable.            This allows to re-sync the user interface with a variable value.            Arguments:              name (str): The variable name to refresh.          \"\"\"          val = attrgetter(name)(self)          _attrsetter(self, name, val)        def broadcast(self, name: str, value: t.Any):          \"\"\"Update a variable on all clients.            All connected clients will receive an update of the variable called *name* with the          provided value, even if it is not shared.            Arguments:              name (str): The variable name to update.              value (Any): The new variable value.          \"\"\"          gui: \"Gui\" = super().__getattribute__(State.__gui_attr)          with self._set_context(gui):              encoded_name = gui._bind_var(name)              gui._broadcast_all_clients(encoded_name, value)        def __enter__(self):          super().__getattribute__(State.__attrs[0]).__enter__()          return self        def __exit__(self, exc_type, exc_value, traceback):          return super().__getattribute__(State.__attrs[0]).__exit__(exc_type, exc_value, traceback) "}
{"text": "import re  import sys  import typing as t  import xml.etree.ElementTree as etree  from abc import ABC, abstractmethod  from inspect import isclass  from pathlib import Path  from urllib.parse import urlencode    from .._renderers.builder import _Builder  from .._warnings import _warn  from ..gui_types import PropertyType  from ..utils import _get_broadcast_var_name, _TaipyBase, _to_camel_case    if t.TYPE_CHECKING:      from ..gui import Gui      from ..state import State      class ElementProperty:      \"\"\"      The declaration of a property of a visual element.        Each visual element property is described by an instance of `ElementProperty`.      This class holds the information on the name, type and default value for the      element property.      \"\"\"        def __init__(          self,          property_type: PropertyType,          default_value: t.Optional[t.Any] = None,          js_name: t.Optional[str] = None,      ) -> None:          \"\"\"Initializes a new custom property declaration for an `Element^`.            Arguments:              property_type (PropertyType): The type of this property.              default_value (Optional[Any]): The default value for this property. Default is None.              js_name (Optional[str]): The name of this property, in the front-end JavaScript code.<br/>                  If unspecified, a camel case version of `name` is generated: for example, if `name` is                  \"my_property_name\", then this property is referred to as \"myPropertyName\" in the                  JavaScript code.          \"\"\"          self.default_value = default_value          if property_type == PropertyType.broadcast:              if isinstance(default_value, str):                  self.default_value = _get_broadcast_var_name(default_value)              else:                  _warn(\"Element property with type 'broadcast' must define a string default value.\")              self.property_type = PropertyType.react          else:              self.property_type = property_type          self._js_name = js_name          super().__init__()        def check(self, element_name: str, prop_name: str):          if not isinstance(prop_name, str) or not prop_name or not prop_name.isidentifier():              _warn(f\"Property name '{prop_name}' is invalid for element '{element_name}'.\")          if not isinstance(self.property_type, PropertyType) and not (              isclass(self.property_type) and issubclass(self.property_type, _TaipyBase)          ):              _warn(f\"Property type '{self.property_type}' is invalid for element property '{element_name}.{prop_name}'.\")        def _get_tuple(self, name: str) -> tuple:          return (name, self.property_type, self.default_value)        def get_js_name(self, name: str) -> str:          return self._js_name or _to_camel_case(name)      class Element:      \"\"\"      The definition of a custom visual element.        An element is defined by its properties (name, type and default value) and      what the default property name is.      \"\"\"        __RE_PROP_VAR = re.compile(r\"<tp:prop:(\\w+)>\")        def __init__(          self,          default_property: str,          properties: t.Dict[str, ElementProperty],          react_component: t.Optional[str] = None,          render_xhtml: t.Optional[t.Callable[[t.Dict[str, t.Any]], str]] = None,          inner_properties: t.Optional[t.Dict[str, ElementProperty]] = None,      ) -> None:          \"\"\"Initializes a new custom element declaration.            If *render_xhtml* is specified, then this is a static element, and          *react_component* is ignored.            Arguments:              default_property (str): the name of the default property for this element.              properties (List[ElementProperty]): The list of properties for this element.              inner_properties (Optional[List[ElementProperty]]): The optional list of inner properties for this element.<br/>                  Default values are set/binded automatically.              react_component (Optional[str]): The name of the component to be created on the front-end.<br/>                  If not specified, it is set to a camel case version of the element's name                  (\"one_name\" is transformed to \"OneName\").              render_xhtml (Optional[callable[[dict[str, Any]], str]]): A function that receives a                  dictionary containing the element's properties and their values                  and that must return a valid XHTML string.          \"\"\"  # noqa: E501          self.default_attribute = default_property          self.attributes = properties          self.inner_properties = inner_properties          self.js_name = react_component          if callable(render_xhtml):              self._render_xhtml = render_xhtml          super().__init__()        def _get_js_name(self, name: str) -> str:          return self.js_name or _to_camel_case(name, True)        def check(self, name: str):          if not isinstance(name, str) or not name or not name.isidentifier():              _warn(f\"Invalid element name: '{name}'.\")          default_found = False          if self.attributes:              for prop_name, property in self.attributes.items():                  if isinstance(property, ElementProperty):                      property.check(name, prop_name)                      if not default_found:                          default_found = self.default_attribute == prop_name                  else:                      _warn(f\"Property must inherit from 'ElementProperty' '{name}.{prop_name}'.\")          if not default_found:              _warn(f\"Element {name} has no default property.\")        def _is_server_only(self):          return hasattr(self, \"_render_xhtml\") and callable(self._render_xhtml)        def _call_builder(          self,          name,          gui: \"Gui\",          properties: t.Optional[t.Dict[str, t.Any]],          lib: \"ElementLibrary\",          is_html: t.Optional[bool] = False,      ) -> t.Union[t.Any, t.Tuple[str, str]]:          attributes = properties if isinstance(properties, dict) else {}          if self.inner_properties:              self.attributes.update(self.inner_properties)              for prop, attr in self.inner_properties.items():                  val = attr.default_value                  if val:                      # handling property replacement in inner properties <tp:prop:...>                      while m := Element.__RE_PROP_VAR.search(val):                          var = attributes.get(m.group(1))                          hash_value = \"None\" if var is None else gui._evaluate_expr(var)                          val = val[: m.start()] + hash_value + val[m.end() :]                  attributes[prop] = val          # this modifies attributes          hash_names = _Builder._get_variable_hash_names(gui, attributes)  # variable replacement          # call user render if any          if self._is_server_only():              xhtml = self._render_xhtml(attributes)              try:                  xml_root = etree.fromstring(xhtml)                  if is_html:                      return xhtml, name                  else:                      return xml_root                except Exception as e:                  _warn(f\"{name}.render_xhtml() did not return a valid XHTML string\", e)                  return f\"{name}.render_xhtml() did not return a valid XHTML string. {e}\"          else:              default_attr: t.Optional[ElementProperty] = None              default_value = None              default_name = None              attrs = []              if self.attributes:                  for prop_name, property in self.attributes.items():                      if isinstance(property, ElementProperty):                          if self.default_attribute == prop_name:                              default_name = prop_name                              default_attr = property                              default_value = property.default_value                          else:                              attrs.append(property._get_tuple(prop_name))              elt_built = _Builder(                  gui=gui,                  control_type=name,                  element_name=f\"{lib.get_js_module_name()}_{self._get_js_name(name)}\",                  attributes=properties,                  hash_names=hash_names,                  lib_name=lib.get_name(),                  default_value=default_value,              )              if default_attr is not None:                  elt_built.set_value_and_default(                      var_name=default_name,                      var_type=default_attr.property_type,                      default_val=default_attr.default_value,                      with_default=default_attr.property_type != PropertyType.data,                  )              elt_built.set_attributes(attrs)              return elt_built._build_to_string() if is_html else elt_built.el      class ElementLibrary(ABC):      \"\"\"      A library of user-defined visual elements.        An element library can declare any number of custom visual elements.        In order to use those elements you must register the element library      using the function `Gui.add_library()^`.        An element library can mix *static* and *dynamic* elements.      \"\"\"        @abstractmethod      def get_elements(self) -> t.Dict[str, Element]:          \"\"\"          Return the dictionary holding all visual element declarations.            The key for each of this dictionary's entry is the name of the element,          and the value is an instance of `Element^`.            The default implementation returns an empty dictionary, indicating that this library          contains no custom visual elements.          \"\"\"          return {}        @abstractmethod      def get_name(self) -> str:          \"\"\"          Return the library name.            This string is used for different purposes:            - It allows for finding the definition of visual elements when parsing the            page content.<br/>            Custom elements are defined with the fragment `<|<library_name>.<element_name>|>` in            Markdown pages, and with the tag `<<library_name>:<element_name>>` in HTML pages.            - In element libraries that hold elements with dynamic properties (where JavaScript)            is involved, the name of the JavaScript module that has the front-end code is            derived from this name, as described in `(ElementLibrary.)get_js_module_name()^`.            Returns:              The name of this element library. This must be a valid Python identifier.            !!! note \"Element libraries with the same name\"              You can add different libraries that have the same name.<br/>              This is useful in large projects where you want to split a potentially large number              of custom visual elements into different groups but still access them from your pages              using the same library name prefix.<br/>              In this situation, you will have to implement `(ElementLibrary.)get_js_module_name()^`              because each JavaScript module will have to have a unique name.            \"\"\"          return NotImplementedError  # type: ignore        def get_js_module_name(self) -> str:          \"\"\"          Return the name of the JavaScript module.            The JavaScript module is the JavaScript file that contains all the front-end          code for this element library. Typically, the name of JavaScript modules uses camel case.<br/>          This module name must be unique on the browser window scope: if your application uses          several custom element libraries, they must define a unique name for their JavaScript module.            The default implementation transforms the return value of `(ElementLibrary.)get_name()^` in          the following manner:            - The JavaScript module name is a camel case version of the element library name            (see `(ElementLibrary.)get_name()^`):              - If the library name is \"library\", the JavaScript module name defaults to \"Library\".              - If the library name is \"myLibrary\", the JavaScript module name defaults to \"Mylibrary\".          - If the element library name has underscore characters, each underscore-separated fragment is            considered as a distinct word:              - If the library name is \"my_library\", the JavaScript module name defaults to \"MyLibrary\".            Returns:              The name of the JavaScript module for this element library.<br/>              The default implementation returns a camel case version of `self.get_name()`,              as described above.          \"\"\"          return _to_camel_case(self.get_name(), True)        def get_scripts(self) -> t.List[str]:          \"\"\"          Return the list of the mandatory script file pathnames.            If a script file pathname is an absolute URL it will be used as is.<br/>          If it's not it will be passed to `(ElementLibrary.)get_resource()^` to retrieve a local          path to the resource.            The default implementation returns an empty list, indicating that this library contains          no custom visual elements with dynamic properties.            Returns:              A list of paths (relative to the element library Python implementation file or              absolute) to all JavaScript module files to be loaded on the front-end.<br/>              The default implementation returns an empty list.          \"\"\"          return []        def get_styles(self) -> t.List[str]:          \"\"\"          TODO          Returns the list of resources names for the css stylesheets.          Defaults to []            \"\"\"          return []        def get_resource(self, name: str) -> Path:          \"\"\"          TODO          Defaults to return None?          Returns a path for a resource name.          Resource URL should be formed as /taipy-extension/<library_name>/<resource virtual path> with(see get_resource_url)          - <resource virtual path> being the `name` parameter          - <library_name> the value returned by `get_name()`            Arguments:              name (str): The name of the resource for which a local Path should be returned.          \"\"\"  # noqa: E501          module_obj = sys.modules.get(self.__class__.__module__)          base = (Path(\".\") if module_obj is None else Path(module_obj.__file__).parent).resolve()  # type: ignore          base = base if base.exists() else Path(\".\").resolve()          file = (base / name).resolve()          if str(file).startswith(str(base)) and file.exists():              return file          else:              raise FileNotFoundError(f\"Cannot access resource {file}.\")        def get_resource_url(self, resource: str) -> str:          \"\"\"TODO\"\"\"          from ..gui import Gui            return f\"/{Gui._EXTENSION_ROOT}/{self.get_name()}/{resource}{self.get_query(resource)}\"        def get_data(self, library_name: str, payload: t.Dict, var_name: str, value: t.Any) -> t.Optional[t.Dict]:          \"\"\"          TODO          Called if implemented (i.e returns a dict).            Arguments:              library_name (str): The name of this library.              payload (dict): The payload send by the `createRequestDataUpdateAction()` front-end function.              var_name (str): The name of the variable holding the data.              value (any): The current value of the variable identified by *var_name*.          \"\"\"          return None        def on_init(self, gui: \"Gui\") -> t.Optional[t.Tuple[str, t.Any]]:          \"\"\"          Initialize this element library.            This method is invoked by `Gui.run()^`.            It allows to define variables that are accessible from elements          defined in this element library.            Arguments              gui: The `Gui^` instance.            Returns:              An optional tuple composed of a variable name (that *must* be a valid Python              identifier), associated with its value.<br/>              This name can be used as the name of a variable accessible by the elements defined              in this library.<br/>              This name must be unique across the entire application, which is a problem since              different element libraries might use the same symbol. A good development practice              is to make this variable name unique by prefixing it with the name of the element              library itself.          \"\"\"          return None        def on_user_init(self, state: \"State\"):          \"\"\"          Initialize user state on first access.            Arguments              state: The `State^` instance.          \"\"\"          pass        def get_query(self, name: str) -> str:          \"\"\"          Return an URL query depending on the resource name.<br/>          Default implementation returns the version if defined.            Arguments:              name (str): The name of the resource for which a query should be returned.            Returns:              A string that holds the query part of an URL (starting with ?).          \"\"\"          if version := self.get_version():              return f\"?{urlencode({'v': version})}\"          return \"\"        def get_version(self) -> t.Optional[str]:          \"\"\"          The optional library version            Returns:              An optional string representing the library version.<br/>              This version will be appended to the resource URL as a query arg (?v=<version>)          \"\"\"          return None "}
{"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  from enum import Enum    from .._renderers.utils import _get_columns_dict  from .._warnings import _warn  from ..gui_types import PropertyType  from ..utils import _MapDict    if t.TYPE_CHECKING:      from ..gui import Gui      class _Chart_iprops(Enum):      x = 0      y = 1      z = 2      label = 3      text = 4      mode = 5      type = 6      color = 7      xaxis = 8      yaxis = 9      selected_color = 10      marker = 11      selected_marker = 12      orientation = 13      _name = 14      line = 15      text_anchor = 16      options = 17      lon = 18      lat = 19      base = 20      r = 21      theta = 22      close = 23      open = 24      high = 25      low = 26      locations = 27      values = 28      labels = 29      decimator = 30      measure = 31      parents = 32      __CHART_AXIS: t.Dict[str, t.Tuple[_Chart_iprops, ...]] = {      \"bar\": (_Chart_iprops.x, _Chart_iprops.y, _Chart_iprops.base),      \"candlestick\": (          _Chart_iprops.x,          _Chart_iprops.close,          _Chart_iprops.open,          _Chart_iprops.high,          _Chart_iprops.low,      ),      \"choropleth\": (_Chart_iprops.locations, _Chart_iprops.z),      \"densitymapbox\": (_Chart_iprops.lon, _Chart_iprops.lat, _Chart_iprops.z),      \"funnelarea\": (_Chart_iprops.values,),      \"pie\": (_Chart_iprops.values, _Chart_iprops.labels),      \"scattergeo\": (_Chart_iprops.lon, _Chart_iprops.lat),      \"scattermapbox\": (_Chart_iprops.lon, _Chart_iprops.lat),      \"scatterpolar\": (_Chart_iprops.r, _Chart_iprops.theta),      \"scatterpolargl\": (_Chart_iprops.r, _Chart_iprops.theta),      \"treemap\": (_Chart_iprops.labels, _Chart_iprops.parents, _Chart_iprops.values),      \"waterfall\": (_Chart_iprops.x, _Chart_iprops.y, _Chart_iprops.measure),  }  __CHART_DEFAULT_AXIS: t.Tuple[_Chart_iprops, ...] = (_Chart_iprops.x, _Chart_iprops.y, _Chart_iprops.z)  __CHART_MARKER_TO_COLS: t.Tuple[str, ...] = (\"color\", \"size\", \"symbol\", \"opacity\")  __CHART_NO_INDEX: t.Tuple[str, ...] = (\"pie\", \"histogram\", \"heatmap\", \"funnelarea\")  _CHART_NAMES: t.Tuple[str, ...] = tuple(e.name[1:] if e.name[0] == \"_\" else e.name for e in _Chart_iprops)      def __check_dict(values: t.List[t.Any], properties: t.Iterable[_Chart_iprops]) -> None:      for prop in properties:          if values[prop.value] is not None and not isinstance(values[prop.value], (dict, _MapDict)):              _warn(f\"Property {prop.name} of chart control should be a dict.\")              values[prop.value] = None      def __get_multiple_indexed_attributes(      attributes: t.Dict[str, t.Any], names: t.Iterable[str], index: t.Optional[int] = None  ) -> t.List[t.Optional[str]]:      names = names if index is None else [f\"{n}[{index}]\" for n in names]  # type: ignore      return [attributes.get(name) for name in names]      __RE_INDEXED_DATA = re.compile(r\"^(\\d+)\\/(.*)\")      def __get_col_from_indexed(col_name: str, idx: int) -> t.Optional[str]:      if re_res := __RE_INDEXED_DATA.search(col_name):          return col_name if str(idx) == re_res.group(1) else None      return col_name      def _build_chart_config(gui: \"Gui\", attributes: t.Dict[str, t.Any], col_types: t.Dict[str, str]):  # noqa: C901      default_type = attributes.get(\"_default_type\", \"scatter\")      default_mode = attributes.get(\"_default_mode\", \"lines+markers\")      trace = __get_multiple_indexed_attributes(attributes, _CHART_NAMES)      if not trace[_Chart_iprops.mode.value]:          trace[_Chart_iprops.mode.value] = default_mode      # type      if not trace[_Chart_iprops.type.value]:          trace[_Chart_iprops.type.value] = default_type      if not trace[_Chart_iprops.xaxis.value]:          trace[_Chart_iprops.xaxis.value] = \"x\"      if not trace[_Chart_iprops.yaxis.value]:          trace[_Chart_iprops.yaxis.value] = \"y\"      # Indexed properties: Check for arrays      for prop in _Chart_iprops:          values = trace[prop.value]          if isinstance(values, (list, tuple)) and len(values):              prop_name = prop.name[1:] if prop.name[0] == \"_\" else prop.name              for idx, val in enumerate(values):                  if idx == 0:                      trace[prop.value] = val                  if val is not None:                      indexed_prop = f\"{prop_name}[{idx + 1}]\"                      if attributes.get(indexed_prop) is None:                          attributes[indexed_prop] = val      # marker selected_marker options      __check_dict(trace, (_Chart_iprops.marker, _Chart_iprops.selected_marker, _Chart_iprops.options))      axis = []      traces: t.List[t.List[t.Optional[str]]] = []      idx = 1      indexed_trace = __get_multiple_indexed_attributes(attributes, _CHART_NAMES, idx)      if len([x for x in indexed_trace if x]):          while len([x for x in indexed_trace if x]):              axis.append(                  __CHART_AXIS.get(                      indexed_trace[_Chart_iprops.type.value] or trace[_Chart_iprops.type.value] or \"\",                      __CHART_DEFAULT_AXIS,                  )              )              # marker selected_marker options              __check_dict(indexed_trace, (_Chart_iprops.marker, _Chart_iprops.selected_marker, _Chart_iprops.options))              if trace[_Chart_iprops.decimator.value] and not indexed_trace[_Chart_iprops.decimator.value]:                  # copy the decimator only once                  indexed_trace[_Chart_iprops.decimator.value] = trace[_Chart_iprops.decimator.value]                  trace[_Chart_iprops.decimator.value] = None              traces.append([x or trace[i] for i, x in enumerate(indexed_trace)])              idx += 1              indexed_trace = __get_multiple_indexed_attributes(attributes, _CHART_NAMES, idx)      else:          traces.append(trace)          # axis names          axis.append(__CHART_AXIS.get(trace[_Chart_iprops.type.value] or \"\", __CHART_DEFAULT_AXIS))        # list of data columns name indexes with label text      dt_idx = tuple(e.value for e in (axis[0] + (_Chart_iprops.label, _Chart_iprops.text)))        # configure columns      columns: t.Set[str] = set()      for j, trace in enumerate(traces):          dt_idx = tuple(              e.value for e in (axis[j] if j < len(axis) else axis[0]) + (_Chart_iprops.label, _Chart_iprops.text)          )          columns.update([trace[i] or \"\" for i in dt_idx if trace[i]])      # add optionnal column if any      markers = [          t[_Chart_iprops.marker.value]          or ({\"color\": t[_Chart_iprops.color.value]} if t[_Chart_iprops.color.value] else None)          for t in traces      ]      opt_cols = set()      for m in markers:          if isinstance(m, (dict, _MapDict)):              for prop1 in __CHART_MARKER_TO_COLS:                  val = m.get(prop1)                  if isinstance(val, str) and val not in columns:                      opt_cols.add(val)        # Validate the column names      col_dict = _get_columns_dict(attributes.get(\"data\"), list(columns), col_types, opt_columns=opt_cols)        # Manage Decimator      decimators: t.List[t.Optional[str]] = []      for tr in traces:          if tr[_Chart_iprops.decimator.value]:              cls = gui._get_user_instance(                  class_name=str(tr[_Chart_iprops.decimator.value]), class_type=PropertyType.decimator.value              )              if isinstance(cls, PropertyType.decimator.value):                  decimators.append(str(tr[_Chart_iprops.decimator.value]))                  continue          decimators.append(None)        # set default columns if not defined      icols = [[c2 for c2 in [__get_col_from_indexed(c1, i) for c1 in col_dict.keys()] if c2] for i in range(len(traces))]        for i, tr in enumerate(traces):          if i < len(axis):              used_cols = {tr[ax.value] for ax in axis[i] if tr[ax.value]}              unused_cols = [c for c in icols[i] if c not in used_cols]              if unused_cols and not any(tr[ax.value] for ax in axis[i]):                  traces[i] = list(                      v or (unused_cols.pop(0) if unused_cols and _Chart_iprops(j) in axis[i] else v)                      for j, v in enumerate(tr)                  )        if col_dict is not None:          reverse_cols = {str(cd.get(\"dfid\")): c for c, cd in col_dict.items()}            # List used axis          used_axis = [[e for e in (axis[j] if j < len(axis) else axis[0]) if tr[e.value]] for j, tr in enumerate(traces)]            ret_dict = {              \"columns\": col_dict,              \"labels\": [                  reverse_cols.get(tr[_Chart_iprops.label.value] or \"\", (tr[_Chart_iprops.label.value] or \"\"))                  for tr in traces              ],              \"texts\": [                  reverse_cols.get(tr[_Chart_iprops.text.value] or \"\", (tr[_Chart_iprops.text.value] or None))                  for tr in traces              ],              \"modes\": [tr[_Chart_iprops.mode.value] for tr in traces],              \"types\": [tr[_Chart_iprops.type.value] for tr in traces],              \"xaxis\": [tr[_Chart_iprops.xaxis.value] for tr in traces],              \"yaxis\": [tr[_Chart_iprops.yaxis.value] for tr in traces],              \"markers\": markers,              \"selectedMarkers\": [                  tr[_Chart_iprops.selected_marker.value]                  or (                      {\"color\": tr[_Chart_iprops.selected_color.value]}                      if tr[_Chart_iprops.selected_color.value]                      else None                  )                  for tr in traces              ],              \"traces\": [                  [reverse_cols.get(c or \"\", c) for c in [tr[e.value] for e in used_axis[j]]]                  for j, tr in enumerate(traces)              ],              \"orientations\": [tr[_Chart_iprops.orientation.value] for tr in traces],              \"names\": [tr[_Chart_iprops._name.value] for tr in traces],              \"lines\": [                  tr[_Chart_iprops.line.value]                  if isinstance(tr[_Chart_iprops.line.value], (dict, _MapDict))                  else {\"dash\": tr[_Chart_iprops.line.value]}                  if tr[_Chart_iprops.line.value]                  else None                  for tr in traces              ],              \"textAnchors\": [tr[_Chart_iprops.text_anchor.value] for tr in traces],              \"options\": [tr[_Chart_iprops.options.value] for tr in traces],              \"axisNames\": [[e.name for e in ax] for ax in used_axis],              \"addIndex\": [tr[_Chart_iprops.type.value] not in __CHART_NO_INDEX for tr in traces],          }          if len([d for d in decimators if d]):              ret_dict.update(decimators=decimators)          return ret_dict      return {} "}
{"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": "from __future__ import annotations    import typing as t    from .._warnings import _warn  from ..icon import Icon  from . import _MapDict      class _Adapter:      def __init__(self):          self.__adapter_for_type: t.Dict[str, t.Callable] = {}          self.__type_for_variable: t.Dict[str, str] = {}          self.__warning_by_type: t.Set[str] = set()        def _add_for_type(self, type_name: str, adapter: t.Callable) -> None:          self.__adapter_for_type[type_name] = adapter        def _add_type_for_var(self, var_name: str, type_name: str) -> None:          self.__type_for_variable[var_name] = type_name        def _get_for_type(self, type_name: str) -> t.Optional[t.Callable]:          return self.__adapter_for_type.get(type_name)        def _get_unique_type(self, type_name: str) -> str:          index = 0          while type_name in self.__adapter_for_type:              type_name = f\"{type_name}{index}\"              index += 1          return type_name        def _run_for_var(self, var_name: str, value: t.Any, id_only=False) -> t.Any:          ret = self._run(self.__get_for_var(var_name, value), value, var_name, id_only)          return ret if ret is not None else value        def __get_for_var(self, var_name: str, value: t.Any) -> t.Optional[t.Callable]:          adapter = None          type_name = self.__type_for_variable.get(var_name)          if not isinstance(type_name, str):              adapter = self.__adapter_for_type.get(var_name)              type_name = var_name if callable(adapter) else type(value).__name__          if adapter is None:              adapter = self.__adapter_for_type.get(type_name)          return adapter if callable(adapter) else None        def _get_elt_per_ids(self, var_name: str, lov: t.List[t.Any]) -> t.Dict[str, t.Any]:          dict_res = {}          adapter = self.__get_for_var(var_name, lov[0] if lov else None)          for value in lov:              try:                  result = adapter(value._dict if isinstance(value, _MapDict) else value) if adapter else value                  if result is not None:                      dict_res[self.__get_id(result)] = value                      children = self.__get_children(result)                      if children is not None:                          dict_res.update(self._get_elt_per_ids(var_name, children))              except Exception as e:                  _warn(f\"Cannot run adapter for {var_name}\", e)          return dict_res        def _run(          self, adapter: t.Optional[t.Callable], value: t.Any, var_name: str, id_only=False      ) -> t.Union[t.Tuple[str, ...], str, None]:          if value is None:              return None          try:              result = value._dict if isinstance(value, _MapDict) else value              if adapter:                  result = adapter(result)                  if result is None:                      return result              elif isinstance(result, str):                  return result              tpl_res = self._get_valid_result(result, id_only)              if tpl_res is None:                  _warn(                      f\"Adapter for {var_name} did not return a valid result. Please check the documentation on List of Values Adapters.\"  # noqa: E501                  )              else:                  if not id_only and len(tpl_res) > 2 and isinstance(tpl_res[2], list) and len(tpl_res[2]) > 0:                      tpl_res = (tpl_res[0], tpl_res[1], self.__on_tree(adapter, tpl_res[2]))                  return (                      (tpl_res + result[len(tpl_res) :])                      if isinstance(result, tuple) and isinstance(tpl_res, tuple)                      else tpl_res                  )          except Exception as e:              _warn(f\"Cannot run adapter for {var_name}\", e)          return None        def __on_tree(self, adapter: t.Optional[t.Callable], tree: t.List[t.Any]):          ret_list = []          for elt in tree:              ret = self._run(adapter, elt, adapter.__name__ if adapter else \"adapter\")              if ret is not None:                  ret_list.append(ret)          return ret_list        def _get_valid_result(self, value: t.Any, id_only=False) -> t.Union[t.Tuple[str, ...], str, None]:          id = self.__get_id(value)          if id_only:              return id          label = self.__get_label(value)          if label is None:              return None          children = self.__get_children(value)          return (id, label) if children is None else (id, label, children)  # type: ignore        def __get_id(self, value: t.Any, dig=True) -> str:          if isinstance(value, str):              return value          elif dig:              if isinstance(value, (list, tuple)) and len(value):                  return self.__get_id(value[0], False)              elif hasattr(value, \"id\"):                  return self.__get_id(value.id, False)              elif hasattr(value, \"__getitem__\") and \"id\" in value:                  return self.__get_id(value.get(\"id\"), False)          if value is not None and type(value).__name__ not in self.__warning_by_type:              _warn(f\"LoV id must be a string, using a string representation of {type(value)}.\")              self.__warning_by_type.add(type(value).__name__)          return \"\" if value is None else str(value)        def __get_label(self, value: t.Any, dig=True) -> t.Union[str, t.Dict, None]:          if isinstance(value, (str, Icon)):              return Icon.get_dict_or(value)          elif dig:              if isinstance(value, (list, tuple)) and len(value) > 1:                  return self.__get_label(value[1], False)              elif hasattr(value, \"label\"):                  return self.__get_label(value.label, False)              elif hasattr(value, \"__getitem__\") and \"label\" in value:                  return self.__get_label(value[\"label\"], False)          return None        def __get_children(self, value: t.Any) -> t.Optional[t.List[t.Any]]:          if isinstance(value, (tuple, list)) and len(value) > 2:              return value[2] if isinstance(value[2], list) else [value[2]]          elif hasattr(value, \"children\"):              return value.children if isinstance(value.children, list) else [value.children]          elif hasattr(value, \"__getitem__\") and \"children\" in value:              return value[\"children\"] if isinstance(value[\"children\"], list) else [value[\"children\"]]          return None "}
{"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": "from __future__ import annotations    import ast  import builtins  import re  import typing as t    from .._warnings import _warn    if t.TYPE_CHECKING:      from ..gui import Gui    from . import (      _get_client_var_name,      _get_expr_var_name,      _getscopeattr,      _getscopeattr_drill,      _hasscopeattr,      _MapDict,      _setscopeattr,      _setscopeattr_drill,      _TaipyBase,      _variable_decode,      _variable_encode,  )      class _Evaluator:      # Regex to separate content from inside curly braces when evaluating f string expressions      __EXPR_RE = re.compile(r\"\\{(([^\\}]*)([^\\{]*))\\}\")      __EXPR_IS_EXPR = re.compile(r\"[^\\\\][{}]\")      __EXPR_IS_EDGE_CASE = re.compile(r\"^\\s*{([^}]*)}\\s*$\")      __EXPR_VALID_VAR_EDGE_CASE = re.compile(r\"^([a-zA-Z\\.\\_0-9\\[\\]]*)$\")      __EXPR_EDGE_CASE_F_STRING = re.compile(r\"[\\{]*[a-zA-Z_][a-zA-Z0-9_]*:.+\")      __IS_TAIPYEXPR_RE = re.compile(r\"TpExPr_(.*)\")        def __init__(self, default_bindings: t.Dict[str, t.Any], shared_variable: t.List[str]) -> None:          # key = expression, value = hashed value of the expression          self.__expr_to_hash: t.Dict[str, str] = {}          # key = hashed value of the expression, value = expression          self.__hash_to_expr: t.Dict[str, str] = {}          # key = variable name of the expression, key = list of related expressions          # ex: {x + y}          # \"x_TPMDL_0\": [\"{x + y}\"],          # \"y_TPMDL_0\": [\"{x + y}\"],          self.__var_to_expr_list: t.Dict[str, t.List[str]] = {}          # key = expression, value = list of related variables          # \"{x + y}\": {\"x\": \"x_TPMDL_\", \"y\": \"y_TPMDL_0\"}          self.__expr_to_var_map: t.Dict[str, t.Dict[str, str]] = {}          # instead of binding everywhere the types          self.__global_ctx = default_bindings          # expr to holders          self.__expr_to_holders: t.Dict[str, t.Set[t.Type[_TaipyBase]]] = {}          # shared variables between multiple clients          self.__shared_variable = shared_variable        @staticmethod      def _expr_decode(s: str):          return str(result[1]) if (result := _Evaluator.__IS_TAIPYEXPR_RE.match(s)) else s        def get_hash_from_expr(self, expr: str) -> str:          return self.__expr_to_hash.get(expr, expr)        def get_expr_from_hash(self, hash_val: str) -> str:          return self.__hash_to_expr.get(hash_val, hash_val)        def get_shared_variables(self) -> t.List[str]:          return self.__shared_variable        def _is_expression(self, expr: str) -> bool:          return len(_Evaluator.__EXPR_IS_EXPR.findall(expr)) != 0        def _fetch_expression_list(self, expr: str) -> t.List:          return [v[0] for v in _Evaluator.__EXPR_RE.findall(expr)]        def _analyze_expression(self, gui: Gui, expr: str) -> t.Tuple[t.Dict[str, t.Any], t.Dict[str, str]]:          var_val: t.Dict[str, t.Any] = {}          var_map: t.Dict[str, str] = {}          non_vars = list(self.__global_ctx.keys())          non_vars.extend(dir(builtins))          # Get a list of expressions (value that has been wrapped in curly braces {}) and find variables to bind          for e in self._fetch_expression_list(expr):              var_name = e.split(sep=\".\")[0]              st = ast.parse('f\"{' + e + '}\"' if _Evaluator.__EXPR_EDGE_CASE_F_STRING.match(e) else e)              args = [arg.arg for node in ast.walk(st) if isinstance(node, ast.arguments) for arg in node.args]              targets = [                  # type: ignore                  compr.target.id                  for node in ast.walk(st)                  if isinstance(node, ast.ListComp)                  for compr in node.generators              ]              for node in ast.walk(st):                  if isinstance(node, ast.Name):                      var_name = node.id.split(sep=\".\")[0]                      if var_name not in args and var_name not in targets and var_name not in non_vars:                          try:                              encoded_var_name = gui._bind_var(var_name)                              var_val[var_name] = _getscopeattr_drill(gui, encoded_var_name)                              var_map[var_name] = encoded_var_name                          except AttributeError as e:                              _warn(f\"Variable '{var_name}' is not defined (in expression '{expr}')\", e)          return var_val, var_map        def __save_expression(          self,          gui: Gui,          expr: str,          expr_hash: t.Optional[str],          expr_evaluated: t.Optional[t.Any],          var_map: t.Dict[str, str],      ):          if expr in self.__expr_to_hash:              expr_hash = self.__expr_to_hash[expr]              gui._bind_var_val(expr_hash, expr_evaluated)              return expr_hash          if expr_hash is None:              expr_hash = _get_expr_var_name(expr)          else:              # edge case, only a single variable              expr_hash = f\"tpec_{_get_client_var_name(expr)}\"          self.__expr_to_hash[expr] = expr_hash          gui._bind_var_val(expr_hash, expr_evaluated)          self.__hash_to_expr[expr_hash] = expr          for var in var_map.values():              if var not in self.__global_ctx.keys():                  lst = self.__var_to_expr_list.get(var)                  if lst is None:                      self.__var_to_expr_list[var] = [expr]                  else:                      lst.append(expr)          if expr not in self.__expr_to_var_map:              self.__expr_to_var_map[expr] = var_map          # save expr_hash to shared variable if valid          for encoded_var_name in var_map.values():              var_name, module_name = _variable_decode(encoded_var_name)              # only variables in the main module with be taken into account              if module_name is not None and module_name != gui._get_default_module_name():                  continue              if var_name in self.__shared_variable:                  self.__shared_variable.append(expr_hash)          return expr_hash        def evaluate_bind_holder(self, gui: Gui, holder: t.Type[_TaipyBase], expr: str) -> str:          expr_hash = self.__expr_to_hash.get(expr, \"unknownExpr\")          hash_name = self.__get_holder_hash(holder, expr_hash)          expr_lit = expr.replace(\"'\", \"\\\\'\")          holder_expr = f\"{holder.__name__}({expr},'{expr_lit}')\"          self.__evaluate_holder(gui, holder, expr)          if a_set := self.__expr_to_holders.get(expr):              a_set.add(holder)          else:              self.__expr_to_holders[expr] = {holder}          self.__expr_to_hash[holder_expr] = hash_name          # expression is only the first part ...          expr = expr.split(\".\")[0]          self.__expr_to_var_map[holder_expr] = {expr: expr}          if a_list := self.__var_to_expr_list.get(expr):              if holder_expr not in a_list:                  a_list.append(holder_expr)          else:              self.__var_to_expr_list[expr] = [holder_expr]          return hash_name        def evaluate_holders(self, gui: Gui, expr: str) -> t.List[str]:          lst = []          for hld in self.__expr_to_holders.get(expr, []):              hash_val = self.__get_holder_hash(hld, self.__expr_to_hash.get(expr, \"\"))              self.__evaluate_holder(gui, hld, expr)              lst.append(hash_val)          return lst        @staticmethod      def __get_holder_hash(holder: t.Type[_TaipyBase], expr_hash: str) -> str:          return f\"{holder.get_hash()}_{_get_client_var_name(expr_hash)}\"        def __evaluate_holder(self, gui: Gui, holder: t.Type[_TaipyBase], expr: str) -> t.Optional[_TaipyBase]:          try:              expr_hash = self.__expr_to_hash.get(expr, \"unknownExpr\")              holder_hash = self.__get_holder_hash(holder, expr_hash)              expr_value = _getscopeattr_drill(gui, expr_hash)              holder_value = _getscopeattr(gui, holder_hash, None)              if not isinstance(holder_value, _TaipyBase):                  holder_value = holder(expr_value, expr_hash)                  _setscopeattr(gui, holder_hash, holder_value)              else:                  holder_value.set(expr_value)              return holder_value          except Exception as e:              _warn(f\"Cannot evaluate expression {holder.__name__}({expr_hash},'{expr_hash}') for {expr}\", e)          return None        def evaluate_expr(self, gui: Gui, expr: str) -> t.Any:          if not self._is_expression(expr):              return expr          var_val, var_map = self._analyze_expression(gui, expr)          expr_hash = None          is_edge_case = False            # The expr_string is placed here in case expr get replaced by edge case          expr_string = 'f\"' + expr.replace('\"', '\\\\\"') + '\"'          # simplify expression if it only contains var_name          m = _Evaluator.__EXPR_IS_EDGE_CASE.match(expr)          if m and not _Evaluator.__EXPR_EDGE_CASE_F_STRING.match(expr):              expr = m.group(1)              expr_hash = expr if _Evaluator.__EXPR_VALID_VAR_EDGE_CASE.match(expr) else None              is_edge_case = True          # validate whether expression has already been evaluated          module_name = gui._get_locals_context()          not_encoded_expr = expr          expr = f\"TpExPr_{_variable_encode(expr, module_name)}\"          if expr in self.__expr_to_hash and _hasscopeattr(gui, self.__expr_to_hash[expr]):              return self.__expr_to_hash[expr]          try:              # evaluate expressions              ctx: t.Dict[str, t.Any] = {}              ctx.update(self.__global_ctx)              # entries in var_val are not always seen (NameError) when passed as locals              ctx.update(var_val)              expr_evaluated = eval(not_encoded_expr if is_edge_case else expr_string, ctx)          except Exception as e:              _warn(f\"Cannot evaluate expression '{not_encoded_expr if is_edge_case else expr_string}'\", e)              expr_evaluated = None          # save the expression if it needs to be re-evaluated          return self.__save_expression(gui, expr, expr_hash, expr_evaluated, var_map)        def refresh_expr(self, gui: Gui, var_name: str, holder: t.Optional[_TaipyBase]):          \"\"\"          This function will execute when the __request_var_update function receive a refresh order          \"\"\"          expr = self.__hash_to_expr.get(var_name)          if expr:              expr_decoded, _ = _variable_decode(expr)              var_map = self.__expr_to_var_map.get(expr, {})              eval_dict = {k: _getscopeattr_drill(gui, gui._bind_var(v)) for k, v in var_map.items()}              if self._is_expression(expr_decoded):                  expr_string = 'f\"' + _variable_decode(expr)[0].replace('\"', '\\\\\"') + '\"'              else:                  expr_string = expr_decoded              try:                  ctx: t.Dict[str, t.Any] = {}                  ctx.update(self.__global_ctx)                  ctx.update(eval_dict)                  expr_evaluated = eval(expr_string, ctx)                  _setscopeattr(gui, var_name, expr_evaluated)                  if holder is not None:                      holder.set(expr_evaluated)              except Exception as e:                  _warn(f\"Exception raised evaluating {expr_string}\", e)        def re_evaluate_expr(self, gui: Gui, var_name: str) -> t.Set[str]:          \"\"\"          This function will execute when the _update_var function is handling          an expression with only a single variable          \"\"\"          modified_vars: t.Set[str] = set()          # Verify that the current hash is an edge case one (only a single variable inside the original expression)          if var_name.startswith(\"tp_\"):              return modified_vars          expr_original = None          # if var_name starts with tpec_ --> it is an edge case with modified var          if var_name.startswith(\"tpec_\"):              # backup for later reference              var_name_original = var_name              expr_original = self.__hash_to_expr[var_name]              temp_expr_var_map = self.__expr_to_var_map[expr_original]              if len(temp_expr_var_map) <= 1:                  # since this is an edge case --> only 1 item in the dict and that item is the original var                  for v in temp_expr_var_map.values():                      var_name = v                  # construct correct var_path to reassign values                  var_name_full, _ = _variable_decode(expr_original)                  var_name_full = var_name_full.split(\".\")                  var_name_full[0] = var_name                  var_name_full = \".\".join(var_name_full)                  _setscopeattr_drill(gui, var_name_full, _getscopeattr(gui, var_name_original))              else:                  # multiple key-value pair in expr_var_map --> expr is special case a[\"b\"]                  key = \"\"                  for v in temp_expr_var_map.values():                      if isinstance(_getscopeattr(gui, v), _MapDict):                          var_name = v                      else:                          key = v                  if key == \"\":                      return modified_vars                  _setscopeattr_drill(gui, f\"{var_name}.{_getscopeattr(gui, key)}\", _getscopeattr(gui, var_name_original))          # A middle check to see if var_name is from _MapDict          if \".\" in var_name:              var_name = var_name[: var_name.index(\".\")]          # otherwise, thar var_name is correct and doesn't require any resolution          if var_name not in self.__var_to_expr_list:              # _warn(\"{var_name} not found.\")              return modified_vars          # refresh expressions and holders          for expr in self.__var_to_expr_list[var_name]:              expr_decoded, _ = _variable_decode(expr)              hash_expr = self.__expr_to_hash.get(expr, \"UnknownExpr\")              if expr != var_name and not expr.startswith(_TaipyBase._HOLDER_PREFIX):                  expr_var_map = self.__expr_to_var_map.get(expr)  # [\"x\", \"y\"]                  if expr_var_map is None:                      _warn(f\"Something is amiss with expression list for {expr}.\")                  else:                      eval_dict = {k: _getscopeattr_drill(gui, gui._bind_var(v)) for k, v in expr_var_map.items()}                      if self._is_expression(expr_decoded):                          expr_string = 'f\"' + _variable_decode(expr)[0].replace('\"', '\\\\\"') + '\"'                      else:                          expr_string = expr_decoded                      try:                          ctx: t.Dict[str, t.Any] = {}                          ctx.update(self.__global_ctx)                          ctx.update(eval_dict)                          expr_evaluated = eval(expr_string, ctx)                          _setscopeattr(gui, hash_expr, expr_evaluated)                      except Exception as e:                          _warn(f\"Exception raised evaluating {expr_string}\", e)              # refresh holders if any              for h in self.__expr_to_holders.get(expr, []):                  holder_hash = self.__get_holder_hash(h, self.get_hash_from_expr(expr))                  if holder_hash not in modified_vars:                      _setscopeattr(gui, holder_hash, self.__evaluate_holder(gui, h, expr))                      modified_vars.add(holder_hash)              modified_vars.add(hash_expr)          return modified_vars        def _get_instance_in_context(self, name: str):          return self.__global_ctx.get(name) "}
{"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  from datetime import datetime  from importlib import util    import numpy as np  import pandas as pd    from .._warnings import _warn  from ..gui import Gui  from ..gui_types import PropertyType  from ..utils import _RE_PD_TYPE, _get_date_col_str_name  from .data_accessor import _DataAccessor  from .data_format import _DataFormat  from .utils import _df_data_filter, _df_relayout    _has_arrow_module = False  if util.find_spec(\"pyarrow\"):      _has_arrow_module = True      import pyarrow as pa      class _PandasDataAccessor(_DataAccessor):      __types = (pd.DataFrame,)        __INDEX_COL = \"_tp_index\"        __AGGREGATE_FUNCTIONS: t.List[str] = [\"count\", \"sum\", \"mean\", \"median\", \"min\", \"max\", \"std\", \"first\", \"last\"]        @staticmethod      def get_supported_classes() -> t.List[str]:          return [t.__name__ for t in _PandasDataAccessor.__types]  # type: ignore        @staticmethod      def __user_function(          row: pd.Series, gui: Gui, column_name: t.Optional[str], user_function: t.Callable, function_name: str      ) -> str:  # pragma: no cover          args = []          if column_name:              args.append(row[column_name])          args.extend((row.name, row))          if column_name:              args.append(column_name)          try:              return str(gui._call_function_with_state(user_function, args))          except Exception as e:              _warn(f\"Exception raised when calling user function {function_name}()\", e)          return \"\"        def __is_date_column(self, data: pd.DataFrame, col_name: str) -> bool:          col_types = data.dtypes[data.dtypes.index.astype(str) == col_name]          return len(col_types[col_types.astype(str).str.startswith(\"datetime\")]) > 0  # type: ignore        def __build_transferred_cols(          self,          gui: Gui,          payload_cols: t.Any,          dataframe: pd.DataFrame,          styles: t.Optional[t.Dict[str, str]] = None,          tooltips: t.Optional[t.Dict[str, str]] = None,          is_copied: t.Optional[bool] = False,          new_indexes: t.Optional[np.ndarray] = None,          handle_nan: t.Optional[bool] = False,      ) -> pd.DataFrame:          if isinstance(payload_cols, list) and len(payload_cols):              col_types = dataframe.dtypes[dataframe.dtypes.index.astype(str).isin(payload_cols)]          else:              col_types = dataframe.dtypes          cols = col_types.index.astype(str).tolist()          if styles:              if not is_copied:                  # copy the df so that we don't \"mess\" with the user's data                  dataframe = dataframe.copy()                  is_copied = True              for k, v in styles.items():                  col_applied = False                  func = gui._get_user_function(v)                  if callable(func):                      col_applied = self.__apply_user_function(gui, func, k if k in cols else None, v, dataframe, \"tps__\")                  if not col_applied:                      dataframe[v] = v                  cols.append(col_applied or v)          if tooltips:              if not is_copied:                  # copy the df so that we don't \"mess\" with the user's data                  dataframe = dataframe.copy()                  is_copied = True              for k, v in tooltips.items():                  col_applied = False                  func = gui._get_user_function(v)                  if callable(func):                      col_applied = self.__apply_user_function(gui, func, k if k in cols else None, v, dataframe, \"tpt__\")                  cols.append(col_applied or v)          # deal with dates          datecols = col_types[col_types.astype(str).str.startswith(\"datetime\")].index.tolist()  # type: ignore          if len(datecols) != 0:              if not is_copied:                  # copy the df so that we don't \"mess\" with the user's data                  dataframe = dataframe.copy()              tz = Gui._get_timezone()              for col in datecols:                  newcol = _get_date_col_str_name(cols, col)                  cols.append(newcol)                  re_type = _RE_PD_TYPE.match(str(col_types[col]))                  grps = re_type.groups() if re_type else ()                  if len(grps) > 4 and grps[4]:                      dataframe[newcol] = (                          dataframe[col]                          .dt.tz_convert(\"UTC\")                          .dt.strftime(_DataAccessor._WS_DATE_FORMAT)                          .astype(str)                          .replace(\"nan\", \"NaT\" if handle_nan else None)                      )                  else:                      dataframe[newcol] = (                          dataframe[col]                          .dt.tz_localize(tz)                          .dt.tz_convert(\"UTC\")                          .dt.strftime(_DataAccessor._WS_DATE_FORMAT)                          .astype(str)                          .replace(\"nan\", \"NaT\" if handle_nan else None)                      )                # remove the date columns from the list of columns              cols = list(set(cols) - set(datecols))          dataframe = dataframe.iloc[new_indexes] if new_indexes is not None else dataframe          dataframe = dataframe.loc[              :, dataframe.dtypes[dataframe.dtypes.index.astype(str).isin(cols)].index          ]  # type: ignore          return dataframe        def __apply_user_function(          self,          gui: Gui,          user_function: t.Callable,          column_name: t.Optional[str],          function_name: str,          data: pd.DataFrame,          prefix: t.Optional[str],      ):          try:              new_col_name = f\"{prefix}{column_name}__{function_name}\" if column_name else function_name              data[new_col_name] = data.apply(                  _PandasDataAccessor.__user_function,                  axis=1,                  args=(gui, column_name, user_function, function_name),              )              return new_col_name          except Exception as e:              _warn(f\"Exception raised when invoking user function {function_name}()\", e)          return False        def __format_data(          self,          data: pd.DataFrame,          data_format: _DataFormat,          orient: str,          start: t.Optional[int] = None,          rowcount: t.Optional[int] = None,          data_extraction: t.Optional[bool] = None,          handle_nan: t.Optional[bool] = False,      ) -> t.Dict[str, t.Any]:          ret: t.Dict[str, t.Any] = {              \"format\": str(data_format.value),          }          if rowcount is not None:              ret[\"rowcount\"] = rowcount          if start is not None:              ret[\"start\"] = start          if data_extraction is not None:              ret[\"dataExtraction\"] = data_extraction  # Extract data out of dictionary on front-end          if data_format == _DataFormat.APACHE_ARROW:              if not _has_arrow_module:                  raise RuntimeError(\"Cannot use Arrow as pyarrow package is not installed\")              # Convert from pandas to Arrow              table = pa.Table.from_pandas(data)              # Create sink buffer stream              sink = pa.BufferOutputStream()              # Create Stream writer              writer = pa.ipc.new_stream(sink, table.schema)              # Write data to table              writer.write_table(table)              writer.close()              # End buffer stream              buf = sink.getvalue()              # Convert buffer to Python bytes and return              ret[\"data\"] = buf.to_pybytes()              ret[\"orient\"] = orient          else:              # Workaround for Python built in JSON encoder that does not yet support ignore_nan              ret[\"data\"] = data.replace([np.nan, pd.NA], [None, None]).to_dict(orient=orient)  # type: ignore          return ret        def get_col_types(self, var_name: str, value: t.Any) -> t.Union[None, t.Dict[str, str]]:  # type: ignore          if isinstance(value, _PandasDataAccessor.__types):  # type: ignore              return {str(k): v for k, v in value.dtypes.apply(lambda x: x.name.lower()).items()}          elif isinstance(value, list):              ret_dict: t.Dict[str, str] = {}              for i, v in enumerate(value):                  ret_dict.update({f\"{i}/{k}\": v for k, v in v.dtypes.apply(lambda x: x.name.lower()).items()})              return ret_dict          return None        def __get_data(  # noqa: C901          self,          gui: Gui,          var_name: str,          value: pd.DataFrame,          payload: t.Dict[str, t.Any],          data_format: _DataFormat,          col_prefix: t.Optional[str] = \"\",      ) -> t.Dict[str, t.Any]:          columns = payload.get(\"columns\", [])          if col_prefix:              columns = [c[len(col_prefix) :] if c.startswith(col_prefix) else c for c in columns]          ret_payload = {\"pagekey\": payload.get(\"pagekey\", \"unknown page\")}          paged = not payload.get(\"alldata\", False)          is_copied = False            # add index if not chart          if paged:              if _PandasDataAccessor.__INDEX_COL not in value.columns:                  value = value.copy()                  is_copied = True                  value[_PandasDataAccessor.__INDEX_COL] = value.index              if columns and _PandasDataAccessor.__INDEX_COL not in columns:                  columns.append(_PandasDataAccessor.__INDEX_COL)            # filtering          filters = payload.get(\"filters\")          if isinstance(filters, list) and len(filters) > 0:              query = \"\"              vars = []              for fd in filters:                  col = fd.get(\"col\")                  val = fd.get(\"value\")                  action = fd.get(\"action\")                  if isinstance(val, str):                      if self.__is_date_column(value, col):                          val = datetime.fromisoformat(val[:-1])                      vars.append(val)                  val = f\"@vars[{len(vars) - 1}]\" if isinstance(val, (str, datetime)) else val                  right = f\".str.contains({val})\" if action == \"contains\" else f\" {action} {val}\"                  if query:                      query += \" and \"                  query += f\"`{col}`{right}\"              try:                  value = value.query(query)                  is_copied = True              except Exception as e:                  _warn(f\"Dataframe filtering: invalid query '{query}' on {value.head()}\", e)            if paged:              aggregates = payload.get(\"aggregates\")              applies = payload.get(\"applies\")              if isinstance(aggregates, list) and len(aggregates) and isinstance(applies, dict):                  applies_with_fn = {                      k: v if v in _PandasDataAccessor.__AGGREGATE_FUNCTIONS else gui._get_user_function(v)                      for k, v in applies.items()                  }                    for col in columns:                      if col not in applies_with_fn.keys():                          applies_with_fn[col] = \"first\"                  try:                      value = value.groupby(aggregates).agg(applies_with_fn)                  except Exception:                      _warn(f\"Cannot aggregate {var_name} with groupby {aggregates} and aggregates {applies}.\")              inf = payload.get(\"infinite\")              if inf is not None:                  ret_payload[\"infinite\"] = inf              # real number of rows is needed to calculate the number of pages              rowcount = len(value)              # here we'll deal with start and end values from payload if present              if isinstance(payload[\"start\"], int):                  start = int(payload[\"start\"])              else:                  try:                      start = int(str(payload[\"start\"]), base=10)                  except Exception:                      _warn(f'start should be an int value {payload[\"start\"]}.')                      start = 0              if isinstance(payload[\"end\"], int):                  end = int(payload[\"end\"])              else:                  try:                      end = int(str(payload[\"end\"]), base=10)                  except Exception:                      end = -1              if start < 0 or start >= rowcount:                  start = 0              if end < 0 or end >= rowcount:                  end = rowcount - 1              # deal with sort              order_by = payload.get(\"orderby\")              if isinstance(order_by, str) and len(order_by):                  try:                      if value.columns.dtype.name == \"int64\":                          order_by = int(order_by)                      new_indexes = value[order_by].values.argsort(axis=0)                      if payload.get(\"sort\") == \"desc\":                          # reverse order                          new_indexes = new_indexes[::-1]                      new_indexes = new_indexes[slice(start, end + 1)]                  except Exception:                      _warn(f\"Cannot sort {var_name} on columns {order_by}.\")                      new_indexes = slice(start, end + 1)  # type: ignore              else:                  new_indexes = slice(start, end + 1)  # type: ignore              value = self.__build_transferred_cols(                  gui,                  columns,                  value,                  styles=payload.get(\"styles\"),                  tooltips=payload.get(\"tooltips\"),                  is_copied=is_copied,                  new_indexes=new_indexes,                  handle_nan=payload.get(\"handlenan\", False),              )              dictret = self.__format_data(                  value, data_format, \"records\", start, rowcount, handle_nan=payload.get(\"handlenan\", False)              )          else:              ret_payload[\"alldata\"] = True              decimator_payload: t.Dict[str, t.Any] = payload.get(\"decimatorPayload\", {})              decimators = decimator_payload.get(\"decimators\", [])              nb_rows_max = decimator_payload.get(\"width\")              for decimator_pl in decimators:                  decimator = decimator_pl.get(\"decimator\")                  decimator_instance = (                      gui._get_user_instance(decimator, PropertyType.decimator.value) if decimator is not None else None                  )                  if isinstance(decimator_instance, PropertyType.decimator.value):                      x_column, y_column, z_column = (                          decimator_pl.get(\"xAxis\", \"\"),                          decimator_pl.get(\"yAxis\", \"\"),                          decimator_pl.get(\"zAxis\", \"\"),                      )                      chart_mode = decimator_pl.get(\"chartMode\", \"\")                      if decimator_instance._zoom and \"relayoutData\" in decimator_payload and not z_column:                          relayoutData = decimator_payload.get(\"relayoutData\", {})                          x0 = relayoutData.get(\"xaxis.range[0]\")                          x1 = relayoutData.get(\"xaxis.range[1]\")                          y0 = relayoutData.get(\"yaxis.range[0]\")                          y1 = relayoutData.get(\"yaxis.range[1]\")                            value, is_copied = _df_relayout(                              value, x_column, y_column, chart_mode, x0, x1, y0, y1, is_copied                          )                        if nb_rows_max and decimator_instance._is_applicable(value, nb_rows_max, chart_mode):                          try:                              value, is_copied = _df_data_filter(                                  value,                                  x_column,                                  y_column,                                  z_column,                                  decimator=decimator_instance,                                  payload=decimator_payload,                                  is_copied=is_copied,                              )                              gui._call_on_change(f\"{var_name}.{decimator}.nb_rows\", len(value))                          except Exception as e:                              _warn(f\"Limit rows error with {decimator} for Dataframe\", e)              value = self.__build_transferred_cols(gui, columns, value, is_copied=is_copied)              dictret = self.__format_data(value, data_format, \"list\", data_extraction=True)          ret_payload[\"value\"] = dictret          return ret_payload        def get_data(          self, gui: Gui, var_name: str, value: t.Any, payload: t.Dict[str, t.Any], data_format: _DataFormat      ) -> t.Dict[str, t.Any]:          if isinstance(value, list):              # If is_chart data              if payload.get(\"alldata\", False):                  ret_payload = {                      \"alldata\": True,                      \"value\": {\"multi\": True},                      \"pagekey\": payload.get(\"pagekey\", \"unknown page\"),                  }                  data = []                  for i, v in enumerate(value):                      ret = (                          self.__get_data(gui, var_name, v, payload, data_format, f\"{i}/\")                          if isinstance(v, pd.DataFrame)                          else {}                      )                      ret_val = ret.get(\"value\", {})                      data.append(ret_val.pop(\"data\", None))                      ret_payload.get(\"value\", {}).update(ret_val)                  ret_payload[\"value\"][\"data\"] = data                  return ret_payload              else:                  value = value[0]          if isinstance(value, _PandasDataAccessor.__types):  # type: ignore              return self.__get_data(gui, var_name, value, payload, data_format)          return {} "}
{"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 re  import typing as t  from datetime import datetime    from ..gui_types import PropertyType  from .builder import _Builder    if t.TYPE_CHECKING:      from ..extension.library import ElementLibrary      from ..gui import Gui      class _Factory:      DEFAULT_CONTROL = \"text\"        _START_SUFFIX = \".start\"      _END_SUFFIX = \".end\"        __TAIPY_NAME_SPACE = \"taipy.\"        __CONTROL_DEFAULT_PROP_NAME = {          \"button\": \"label\",          \"chart\": \"data\",          \"content\": \"value\",          \"date\": \"date\",          \"date_range\": \"dates\",          \"dialog\": \"open\",          \"expandable\": \"title\",          \"file_download\": \"content\",          \"file_selector\": \"content\",          \"image\": \"content\",          \"indicator\": \"display\",          \"input\": \"value\",          \"layout\": \"columns\",          \"menu\": \"lov\",          \"navbar\": \"value\",          \"number\": \"value\",          \"pane\": \"open\",          \"part\": \"class_name\",          \"selector\": \"value\",          \"slider\": \"value\",          \"status\": \"value\",          \"table\": \"data\",          \"text\": \"value\",          \"toggle\": \"value\",          \"tree\": \"value\",      }        _TEXT_ATTRIBUTES = [\"format\", \"id\", \"hover_text\", \"raw\"]        __TEXT_ANCHORS = [\"bottom\", \"top\", \"left\", \"right\"]      __TEXT_ANCHOR_NONE = \"none\"        __LIBRARIES: t.Dict[str, t.List[\"ElementLibrary\"]] = {}        __CONTROL_BUILDERS = {          \"button\": lambda gui, control_type, attrs: _Builder(              gui=gui,              control_type=control_type,              element_name=\"Button\",              attributes=attrs,          )          .set_value_and_default(with_update=False)          .set_attributes(              [                  (\"id\",),                  (\"on_action\", PropertyType.function),                  (\"active\", PropertyType.dynamic_boolean, True),                  (\"hover_text\", PropertyType.dynamic_string),              ]          ),          \"chart\": lambda gui, control_type, attrs: _Builder(              gui=gui,              control_type=control_type,              element_name=\"Chart\",              attributes=attrs,          )          .set_value_and_default(with_default=False, var_type=PropertyType.data)          .set_attributes(              [                  (\"id\",),                  (\"title\",),                  (\"width\", PropertyType.string_or_number),                  (\"height\", PropertyType.string_or_number),                  (\"layout\", PropertyType.dynamic_dict),                  (\"plot_config\", PropertyType.dict),                  (\"on_range_change\", PropertyType.function),                  (\"active\", PropertyType.dynamic_boolean, True),                  (\"render\", PropertyType.dynamic_boolean, True),                  (\"hover_text\", PropertyType.dynamic_string),                  (\"on_change\", PropertyType.function),                  (\"template\", PropertyType.dict),                  (\"template[dark]\", PropertyType.dict, gui._get_config(\"chart_dark_template\", None)),                  (\"template[light]\", PropertyType.dict),              ]          )          ._get_chart_config(\"scatter\", \"lines+markers\")          ._set_propagate(),          \"content\": lambda gui, control_type, attrs: _Builder(              gui=gui, control_type=control_type, element_name=\"PageContent\", attributes=attrs          ),          \"date\": lambda gui, control_type, attrs: _Builder(              gui=gui,              control_type=control_type,              element_name=\"DateSelector\",              attributes=attrs,              default_value=datetime.fromtimestamp(0),          )          .set_value_and_default(var_type=PropertyType.date)          .set_attributes(              [                  (\"with_time\", PropertyType.boolean),                  (\"id\",),                  (\"active\", PropertyType.dynamic_boolean, True),                  (\"editable\", PropertyType.dynamic_boolean, True),                  (\"hover_text\", PropertyType.dynamic_string),                  (\"label\",),                  (\"on_change\", PropertyType.function),                  (\"format\",),              ]          )          ._set_propagate(),          \"date_range\": lambda gui, control_type, attrs: _Builder(              gui=gui,              control_type=control_type,              element_name=\"DateRange\",              attributes=attrs,          )          .set_value_and_default(var_type=PropertyType.date_range)          .set_attributes(              [                  (\"with_time\", PropertyType.boolean),                  (\"id\",),                  (\"active\", PropertyType.dynamic_boolean, True),                  (\"editable\", PropertyType.dynamic_boolean, True),                  (\"hover_text\", PropertyType.dynamic_string),                  (\"label_start\",),                  (\"label_end\",),                  (\"on_change\", PropertyType.function),                  (\"format\",),              ]          )          ._set_propagate(),          \"dialog\": lambda gui, control_type, attrs: _Builder(              gui=gui,              control_type=control_type,              element_name=\"Dialog\",              attributes=attrs,          )          .set_value_and_default(var_type=PropertyType.dynamic_boolean)          ._set_partial()  # partial should be set before page          .set_attributes(              [                  (\"id\",),                  (\"page\",),                  (\"title\",),                  (\"on_action\", PropertyType.function),                  (\"close_label\", PropertyType.string),                  (\"labels\", PropertyType.string_list),                  (\"active\", PropertyType.dynamic_boolean, True),                  (\"width\", PropertyType.string_or_number),                  (\"height\", PropertyType.string_or_number),                  (\"hover_text\", PropertyType.dynamic_string),              ]          )          ._set_propagate(),          \"expandable\": lambda gui, control_type, attrs: _Builder(              gui=gui, control_type=control_type, element_name=\"Expandable\", attributes=attrs, default_value=None          )          .set_value_and_default()          ._set_partial()  # partial should be set before page          .set_attributes(              [                  (\"id\",),                  (\"page\",),                  (\"expanded\", PropertyType.dynamic_boolean, True, True, False),                  (\"hover_text\", PropertyType.dynamic_string),                  (\"on_change\", PropertyType.function),              ]          ),          \"file_download\": lambda gui, control_type, attrs: _Builder(              gui=gui,              control_type=control_type,              element_name=\"FileDownload\",              attributes=attrs,          )          .set_value_and_default(var_name=\"label\", with_update=False)          ._set_content(\"content\", image=False)          .set_attributes(              [                  (\"id\",),                  (\"on_action\", PropertyType.function),                  (\"active\", PropertyType.dynamic_boolean, True),                  (\"render\", PropertyType.dynamic_boolean, True),                  (\"auto\", PropertyType.boolean, False),                  (\"bypass_preview\", PropertyType.boolean, True),                  (\"name\",),                  (\"hover_text\", PropertyType.dynamic_string),              ]          ),          \"file_selector\": lambda gui, control_type, attrs: _Builder(              gui=gui,              control_type=control_type,              element_name=\"FileSelector\",              attributes=attrs,          )          .set_value_and_default(var_name=\"label\", with_update=False)          ._set_file_content()          .set_attributes(              [                  (\"id\",),                  (\"on_action\", PropertyType.function),                  (\"active\", PropertyType.dynamic_boolean, True),                  (\"multiple\", PropertyType.boolean, False),                  (\"extensions\",),                  (\"drop_message\",),                  (\"hover_text\", PropertyType.dynamic_string),              ]          ),          \"image\": lambda gui, control_type, attrs: _Builder(              gui=gui,              control_type=control_type,              element_name=\"Image\",              attributes=attrs,          )          .set_value_and_default(var_name=\"label\", with_update=False)          ._set_content(\"content\")          .set_attributes(              [                  (\"id\",),                  (\"on_action\", PropertyType.function),                  (\"active\", PropertyType.dynamic_boolean, True),                  (\"width\",),                  (\"height\",),                  (\"hover_text\", PropertyType.dynamic_string),              ]          ),          \"indicator\": lambda gui, control_type, attrs: _Builder(              gui=gui,              control_type=control_type,              element_name=\"Indicator\",              attributes=attrs,          )          .set_value_and_default(with_update=False, native_type=True)          .set_attributes(              [                  (\"id\",),                  (\"min\", PropertyType.number),                  (\"max\", PropertyType.number),                  (\"value\", PropertyType.dynamic_number),                  (\"format\",),                  (\"orientation\"),                  (\"hover_text\", PropertyType.dynamic_string),                  (\"width\",),                  (\"height\",),              ]          ),          \"input\": lambda gui, control_type, attrs: _Builder(              gui=gui,              control_type=control_type,              element_name=\"Input\",              attributes=attrs,          )          ._set_input_type(\"text\", True)          .set_value_and_default()          ._set_propagate()          .set_attributes(              [                  (\"id\",),                  (\"active\", PropertyType.dynamic_boolean, True),                  (\"hover_text\", PropertyType.dynamic_string),                  (\"on_change\", PropertyType.function),                  (\"on_action\", PropertyType.function),                  (\"action_keys\",),                  (\"label\",),                  (\"change_delay\", PropertyType.number, gui._get_config(\"change_delay\", None)),                  (\"multiline\", PropertyType.boolean, False),                  (\"lines_shown\", PropertyType.number, 5),              ]          ),          \"layout\": lambda gui, control_type, attrs: _Builder(              gui=gui, control_type=control_type, element_name=\"Layout\", attributes=attrs, default_value=None          )          .set_value_and_default(with_default=False)          .set_attributes(              [                  (\"id\",),                  (\"columns[mobile]\",),                  (\"gap\",),              ]          ),          \"menu\": lambda gui, control_type, attrs: _Builder(              gui=gui,              control_type=control_type,              element_name=\"MenuCtl\",              attributes=attrs,          )          ._get_adapter(\"lov\")  # need to be called before set_lov          ._set_lov()          .set_attributes(              [                  (\"id\",),                  (\"active\", PropertyType.dynamic_boolean, True),                  (\"label\"),                  (\"width\"),                  (\"width[mobile]\",),                  (\"on_action\", PropertyType.function),                  (\"inactive_ids\", PropertyType.dynamic_list),                  (\"hover_text\", PropertyType.dynamic_string),              ]          )          ._set_propagate(),          \"navbar\": lambda gui, control_type, attrs: _Builder(              gui=gui, control_type=control_type, element_name=\"NavBar\", attributes=attrs, default_value=None          )          ._get_adapter(\"lov\", multi_selection=False)  # need to be called before set_lov          ._set_lov()          .set_attributes(              [                  (\"id\",),                  (\"active\", PropertyType.dynamic_boolean, True),                  (\"hover_text\", PropertyType.dynamic_string),              ]          ),          \"number\": lambda gui, control_type, attrs: _Builder(              gui=gui,              control_type=control_type,              element_name=\"Input\",              attributes=attrs,              default_value=0,          )          ._set_input_type(\"number\")          .set_value_and_default(var_type=PropertyType.dynamic_number)          ._set_propagate()          .set_attributes(              [                  (\"id\",),                  (\"active\", PropertyType.dynamic_boolean, True),                  (\"hover_text\", PropertyType.dynamic_string),                  (\"on_change\", PropertyType.function),                  (\"on_action\", PropertyType.function),                  (\"label\",),                  (\"change_delay\", PropertyType.number, gui._get_config(\"change_delay\", None)),              ]          ),          \"pane\": lambda gui, control_type, attrs: _Builder(              gui=gui, control_type=control_type, element_name=\"Pane\", attributes=attrs, default_value=None          )          .set_value_and_default(var_type=PropertyType.dynamic_boolean)          ._set_partial()  # partial should be set before page          .set_attributes(              [                  (\"id\",),                  (\"page\",),                  (\"anchor\", PropertyType.string, \"left\"),                  (\"on_close\", PropertyType.function),                  (\"persistent\", PropertyType.boolean, False),                  (\"active\", PropertyType.dynamic_boolean, True),                  (\"width\", PropertyType.string_or_number, \"30vw\"),                  (\"height\", PropertyType.string_or_number, \"30vh\"),                  (\"hover_text\", PropertyType.dynamic_string),                  (\"on_change\", PropertyType.function),              ]          )          ._set_propagate(),          \"part\": lambda gui, control_type, attrs: _Builder(              gui=gui, control_type=control_type, element_name=\"Part\", attributes=attrs, default_value=None          )          ._set_partial()  # partial should be set before page          .set_attributes(              [                  (\"id\",),                  (\"page\", PropertyType.dynamic_string),                  (\"render\", PropertyType.dynamic_boolean, True),                  (\"height\", PropertyType.dynamic_string),                  (\"content\", PropertyType.toHtmlContent),              ]          ),          \"selector\": lambda gui, control_type, attrs: _Builder(              gui=gui, control_type=control_type, element_name=\"Selector\", attributes=attrs, default_value=None          )          .set_value_and_default(with_default=False, var_type=PropertyType.lov_value)          ._get_adapter(\"lov\")  # need to be called before set_lov          ._set_lov()          .set_attributes(              [                  (\"active\", PropertyType.dynamic_boolean, True),                  (\"dropdown\", PropertyType.boolean, False),                  (\"filter\", PropertyType.boolean),                  (\"height\", PropertyType.string_or_number),                  (\"hover_text\", PropertyType.dynamic_string),                  (\"id\",),                  (\"value_by_id\", PropertyType.boolean),                  (\"multiple\", PropertyType.boolean),                  (\"width\", PropertyType.string_or_number),                  (\"on_change\", PropertyType.function),                  (\"label\",),              ]          )          ._set_propagate(),          \"slider\": lambda gui, control_type, attrs: _Builder(              gui=gui,              control_type=control_type,              element_name=\"Slider\",              attributes=attrs,              default_value=0,          )          .set_value_and_default(native_type=True, var_type=PropertyType.slider_value)          .set_attributes(              [                  (\"active\", PropertyType.dynamic_boolean, True),                  (\"height\"),                  (\"hover_text\", PropertyType.dynamic_string),                  (\"id\",),                  (\"value_by_id\", PropertyType.boolean),                  (\"max\", PropertyType.number, 100),                  (\"min\", PropertyType.number, 0),                  (\"orientation\"),                  (\"width\", PropertyType.string, \"300px\"),                  (\"on_change\", PropertyType.function),                  (\"continuous\", PropertyType.boolean, True),                  (\"lov\", PropertyType.lov),                  (\"change_delay\", PropertyType.number, gui._get_config(\"change_delay\", None)),              ]          )          ._set_labels()          ._set_string_with_check(\"text_anchor\", _Factory.__TEXT_ANCHORS + [_Factory.__TEXT_ANCHOR_NONE], \"bottom\")          ._set_propagate(),          \"status\": lambda gui, control_type, attrs: _Builder(              gui=gui,              control_type=control_type,              element_name=\"Status\",              attributes=attrs,          )          .set_value_and_default(with_update=False)          .set_attributes(              [                  (\"id\",),                  (\"without_close\", PropertyType.boolean, False),                  (\"hover_text\", PropertyType.dynamic_string),              ]          ),          \"table\": lambda gui, control_type, attrs: _Builder(              gui=gui,              control_type=control_type,              element_name=\"Table\",              attributes=attrs,          )          .set_value_and_default(with_default=False, var_type=PropertyType.data)          ._get_dataframe_attributes()          .set_attributes(              [                  (\"page_size\", PropertyType.number, \"100\"),                  (\"allow_all_rows\", PropertyType.boolean),                  (\"show_all\", PropertyType.boolean),                  (\"auto_loading\", PropertyType.boolean),                  (\"width\", PropertyType.string_or_number, \"100%\"),                  (\"height\", PropertyType.string_or_number, \"80vh\"),                  (\"id\",),                  (\"active\", PropertyType.dynamic_boolean, True),                  (\"editable\", PropertyType.dynamic_boolean, True),                  (\"on_edit\", PropertyType.function),                  (\"on_delete\", PropertyType.function),                  (\"on_add\", PropertyType.function),                  (\"on_action\", PropertyType.function),                  (\"nan_value\",),                  (\"filter\", PropertyType.boolean),                  (\"hover_text\", PropertyType.dynamic_string),                  (\"size\",),              ]          )          ._set_propagate()          ._get_list_attribute(\"selected\", PropertyType.number)          ._set_table_pagesize_options(),          \"text\": lambda gui, control_type, attrs: _Builder(              gui=gui,              control_type=control_type,              element_name=\"Field\",              attributes=attrs,          )          .set_value_and_default(with_update=False)          ._set_dataType()          .set_attributes(              [                  (\"format\",),                  (\"id\",),                  (\"hover_text\", PropertyType.dynamic_string),                  (\"raw\", PropertyType.boolean, False),                  (\"mode\", PropertyType.string),              ]          ),          \"toggle\": lambda gui, control_type, attrs: _Builder(              gui=gui, control_type=control_type, element_name=\"Toggle\", attributes=attrs, default_value=None          )          .set_value_and_default(with_default=False, var_type=PropertyType.lov_value)          ._get_adapter(\"lov\", multi_selection=False)  # need to be called before set_lov          ._set_lov()          .set_attributes(              [                  (\"active\", PropertyType.dynamic_boolean, True),                  (\"hover_text\", PropertyType.dynamic_string),                  (\"id\",),                  (\"label\",),                  (\"value_by_id\", PropertyType.boolean),                  (\"unselected_value\", PropertyType.string, \"\"),                  (\"allow_unselect\", PropertyType.boolean),                  (\"on_change\", PropertyType.function),              ]          )          ._set_kind()          ._set_propagate(),          \"tree\": lambda gui, control_type, attrs: _Builder(              gui=gui,              control_type=control_type,              element_name=\"TreeView\",              attributes=attrs,          )          .set_value_and_default(with_default=False, var_type=PropertyType.lov_value)          .set_attributes(              [                  (\"active\", PropertyType.dynamic_boolean, True),                  (\"expanded\", PropertyType.boolean_or_list, True),                  (\"filter\", PropertyType.boolean),                  (\"hover_text\", PropertyType.dynamic_string),                  (\"height\", PropertyType.string_or_number),                  (\"id\",),                  (\"value_by_id\", PropertyType.boolean),                  (\"multiple\", PropertyType.boolean),                  (\"width\", PropertyType.string_or_number),                  (\"on_change\", PropertyType.function),                  (\"select_leafs_only\", PropertyType.boolean),                  (\"row_height\", PropertyType.string),                  (\"lov\", PropertyType.lov),              ]          )          ._set_propagate(),      }        # TODO: process \\\" in property value      _PROPERTY_RE = re.compile(r\"\\s+([a-zA-Z][\\.a-zA-Z_$0-9]*(?:\\[(?:.*?)\\])?)=\\\"((?:(?:(?<=\\\\)\\\")|[^\\\"])*)\\\"\")        @staticmethod      def set_library(library: \"ElementLibrary\"):          from ..extension.library import Element, ElementLibrary            if isinstance(library, ElementLibrary) and isinstance(library.get_name(), str) and library.get_elements():              elements = library.get_elements()              for name, element in elements.items():                  if isinstance(element, Element):                      element.check(name)              fact_lib = _Factory.__LIBRARIES.get(library.get_name())              if fact_lib is None:                  _Factory.__LIBRARIES.update({library.get_name(): [library]})              else:                  fact_lib.append(library)        @staticmethod      def get_default_property_name(control_name: str) -> t.Optional[str]:          name = (              control_name[: -len(_Factory._START_SUFFIX)]              if control_name.endswith(_Factory._START_SUFFIX)              else control_name[: -len(_Factory._END_SUFFIX)]              if control_name.endswith(_Factory._END_SUFFIX)              else control_name          )          name = name[len(_Factory.__TAIPY_NAME_SPACE) :] if name.startswith(_Factory.__TAIPY_NAME_SPACE) else name          prop = _Factory.__CONTROL_DEFAULT_PROP_NAME.get(name)          if prop is None:              _, _, element = _Factory.__get_library_element(name)              if element:                  prop = element.default_attribute          return prop        @staticmethod      def __get_library_element(name: str):          parts = name.split(\".\")          if len(parts) > 1:              element_name = \".\".join(parts[1:])              for lib in _Factory.__LIBRARIES.get(parts[0], []):                  elts = lib.get_elements()                  if isinstance(elts, dict):                      element = elts.get(element_name)                      if element:                          return lib, element_name, element          else:              element_name = name              for libs in list(_Factory.__LIBRARIES.values()):                  for lib in libs:                      elts = lib.get_elements()                      if isinstance(elts, dict):                          element = elts.get(element_name)                          if element:                              return lib, element_name, element          return None, None, None        @staticmethod      def call_builder(          gui: \"Gui\", name: str, all_properties: t.Optional[t.Dict[str, t.Any]] = None, is_html: t.Optional[bool] = False      ) -> t.Optional[t.Union[t.Any, t.Tuple[str, str]]]:          name = name[len(_Factory.__TAIPY_NAME_SPACE) :] if name.startswith(_Factory.__TAIPY_NAME_SPACE) else name          builder = _Factory.__CONTROL_BUILDERS.get(name)          built = None          if builder is None:              lib, element_name, element = _Factory.__get_library_element(name)              if lib:                  from ..extension.library import Element                    if isinstance(element, Element):                      return element._call_builder(element_name, gui, all_properties, lib, is_html)          else:              built = builder(gui, name, all_properties)          if isinstance(built, _Builder):              return built._build_to_string() if is_html else built.el          return None "}
{"text": "import contextlib  import json  import numbers  import time as _time  import typing as t  import xml.etree.ElementTree as etree  from datetime import date, datetime, time  from inspect import isclass  from urllib.parse import quote    from .._warnings import _warn  from ..gui_types import PropertyType, _get_taipy_type  from ..partial import Partial  from ..utils import (      _date_to_string,      _get_broadcast_var_name,      _get_client_var_name,      _get_data_type,      _get_expr_var_name,      _getscopeattr,      _getscopeattr_drill,      _is_boolean,      _is_boolean_true,      _MapDict,      _to_camel_case,  )  from ..utils.chart_config_builder import _CHART_NAMES, _build_chart_config  from ..utils.table_col_builder import _enhance_columns, _get_name_indexed_property  from ..utils.types import _TaipyBase, _TaipyData  from .json import _TaipyJsonEncoder  from .utils import _add_to_dict_and_get, _get_columns_dict, _get_tuple_val    if t.TYPE_CHECKING:      from ..gui import Gui      class _Builder:      \"\"\"      Constructs an XML node that can be rendered as a React node.        This class can only be instantiated internally by Taipy.      \"\"\"        __keys: t.Dict[str, int] = {}        __BLOCK_CONTROLS = [\"dialog\", \"expandable\", \"pane\", \"part\"]        __TABLE_COLUMNS_DEPS = [          \"data\",          \"columns\",          \"date_format\",          \"number_format\",          \"nan_value\",          \"width\",          \"filter\",          \"editable\",          \"group_by\",          \"apply\",          \"style\",          \"tooltip\",      ]        def __init__(          self,          gui: \"Gui\",          control_type: str,          element_name: str,          attributes: t.Optional[t.Dict[str, t.Any]],          hash_names: t.Dict[str, str] = {},          default_value=\"<Empty>\",          lib_name: str = \"taipy\",      ):          from ..gui import Gui          from .factory import _Factory            self.el = etree.Element(element_name)            self.__control_type = control_type          self.__element_name = element_name          self.__lib_name = lib_name          self.__attributes = attributes or {}          self.__hashes = hash_names.copy()          self.__update_vars: t.List[str] = []          self.__gui: Gui = gui            self.__default_property_name = _Factory.get_default_property_name(control_type) or \"\"          default_property_value = self.__attributes.get(self.__default_property_name, None)          if default_property_value is None and default_value is not None:              self.__attributes[self.__default_property_name] = default_value            # Bind properties dictionary to attributes if condition is matched (will          # leave the binding for function at the builder )          if \"properties\" in self.__attributes:              (prop_dict, prop_hash) = _Builder.__parse_attribute_value(gui, self.__attributes[\"properties\"])              if prop_hash is None:                  prop_hash = prop_dict                  prop_hash = self.__gui._bind_var(prop_hash)                  if hasattr(self.__gui._bindings(), prop_hash):                      prop_dict = _getscopeattr(self.__gui, prop_hash)              if isinstance(prop_dict, (dict, _MapDict)):                  # Iterate through prop_dict and append to self.attributes                  var_name, _ = gui._get_real_var_name(prop_hash)                  for k, v in prop_dict.items():                      (val, key_hash) = _Builder.__parse_attribute_value(gui, v)                      self.__attributes[k] = (                          f\"{{None if ({var_name}) is None else ({var_name}).get('{k}')}}\" if key_hash is None else v                      )              else:                  _warn(f\"{self.__control_type}.properties ({prop_hash}) must be a dict.\")            # Bind potential function and expressions in self.attributes          self.__hashes.update(_Builder._get_variable_hash_names(gui, self.__attributes, hash_names))            # set classname          self.__set_class_names()          # define a unique key          self.set_attribute(\"key\", _Builder._get_key(self.__element_name))        @staticmethod      def __parse_attribute_value(gui: \"Gui\", value) -> t.Tuple:          if isinstance(value, str) and gui._is_expression(value):              hash_value = gui._evaluate_expr(value)              try:                  func = gui._get_user_function(hash_value)                  if callable(func):                      return (func, hash_value)                  return (_getscopeattr_drill(gui, hash_value), hash_value)              except AttributeError:                  _warn(f\"Expression '{value}' cannot be evaluated.\")          return (value, None)        @staticmethod      def _get_variable_hash_names(          gui: \"Gui\", attributes: t.Dict[str, t.Any], hash_names: t.Dict[str, str] = {}      ) -> t.Dict[str, str]:          hashes = {}          # Bind potential function and expressions in self.attributes          for k, v in attributes.items():              val = v              hashname = hash_names.get(k)              if hashname is None:                  if callable(v):                      if v.__name__ == \"<lambda>\":                          hashname = _get_expr_var_name(v.__code__)                          gui._bind_var_val(hashname, v)                      else:                          hashname = _get_expr_var_name(v.__name__)                  elif isinstance(v, str):                      # need to unescape the double quotes that were escaped during preprocessing                      (val, hashname) = _Builder.__parse_attribute_value(gui, v.replace('\\\\\"', '\"'))                    if val is not None or hashname:                      attributes[k] = val                  if hashname:                      hashes[k] = hashname          return hashes        @staticmethod      def __to_string(x: t.Any) -> str:          return str(x)        @staticmethod      def _get_key(name: str) -> str:          key_index = _Builder.__keys.get(name, 0)          _Builder.__keys[name] = key_index + 1          return f\"{name}.{key_index}\"        @staticmethod      def _reset_key() -> None:          _Builder.__keys = {}        def __get_list_of_(self, name: str):          lof = self.__attributes.get(name)          if isinstance(lof, str):              lof = list(lof.split(\";\"))          return lof        def get_name_indexed_property(self, name: str) -> t.Dict[str, t.Any]:          \"\"\"          TODO-undocumented          Returns all properties defined as <property name>[<named index>] as a dict.            Arguments:                name (str): The property name.          \"\"\"          return _get_name_indexed_property(self.__attributes, name)        def __get_boolean_attribute(self, name: str, default_value=False):          boolattr = self.__attributes.get(name, default_value)          return _is_boolean_true(boolattr) if isinstance(boolattr, str) else bool(boolattr)        def set_boolean_attribute(self, name: str, value: bool):          \"\"\"          TODO-undocumented          Defines a React Boolean attribute (attr={true|false}).            Arguments:              name (str): The property name.              value (bool): the boolean value.          \"\"\"          return self.__set_react_attribute(_to_camel_case(name), value)        def set_dict_attribute(self, name: str, default_value: t.Optional[t.Dict[str, t.Any]] = None):          \"\"\"          TODO-undocumented          Defines a React attribute as a stringified json dict.          The original property can be a dict or a string formed as <key 1>:<value 1>;<key 2>:<value 2>.            Arguments:              name (str): The property name.              default value (dict): used if no value is specified.          \"\"\"          dict_attr = self.__attributes.get(name)          if dict_attr is None:              dict_attr = default_value          if dict_attr is not None:              if isinstance(dict_attr, str):                  vals = [x.strip().split(\":\") for x in dict_attr.split(\";\")]                  dict_attr = {val[0].strip(): val[1].strip() for val in vals if len(val) > 1}              if isinstance(dict_attr, (dict, _MapDict)):                  self.__set_json_attribute(_to_camel_case(name), dict_attr)              else:                  _warn(f\"{self.__element_name}: {name} should be a dict: '{str(dict_attr)}'.\")          return self        def set_dynamic_dict_attribute(self, name: str, default_value: t.Optional[t.Dict[str, t.Any]] = None):          \"\"\"          TODO-undocumented          Defines a React attribute as a stringified json dict.          The original property can be a dict or a string formed as <key 1>:<value 1>;<key 2>:<value 2>.            Arguments:              name (str): The property name.              default value (dict): used if no value is specified.          \"\"\"          dict_attr = self.__attributes.get(name)          if dict_attr is None:              dict_attr = default_value          if dict_attr is not None:              if isinstance(dict_attr, str):                  vals = [x.strip().split(\":\") for x in dict_attr.split(\";\")]                  dict_attr = {val[0].strip(): val[1].strip() for val in vals if len(val) > 1}              if isinstance(dict_attr, (dict, _MapDict)):                  self.__set_json_attribute(_to_camel_case(\"default_\" + name), dict_attr)              else:                  _warn(f\"{self.__element_name}: {name} should be a dict: '{str(dict_attr)}'.\")          if dict_hash := self.__hashes.get(name):              dict_hash = self.__get_typed_hash_name(dict_hash, PropertyType.dynamic_dict)              prop_name = _to_camel_case(name)              self.__update_vars.append(f\"{prop_name}={dict_hash}\")              self.__set_react_attribute(prop_name, dict_hash)          return self        def __set_json_attribute(self, name, value):          return self.set_attribute(name, json.dumps(value, cls=_TaipyJsonEncoder))        def __set_list_of_(self, name: str):          lof = self.__get_list_of_(name)          if not isinstance(lof, (list, tuple)):              if lof is not None:                  _warn(f\"{self.__element_name}: {name} should be a list.\")              return self          return self.__set_json_attribute(_to_camel_case(name), lof)        def set_number_attribute(self, name: str, default_value: t.Optional[str] = None, optional: t.Optional[bool] = True):          \"\"\"          TODO-undocumented          Defines a React number attribute (attr={<number>}).            Arguments:                name (str): The property name.              default_value (optional(str)): the default value as a string.              optional (bool): Default to True, the property is required if False.          \"\"\"          value = self.__attributes.get(name, default_value)          if value is None:              if not optional:                  _warn(f\"Property {name} is required for control {self.__control_type}.\")              return self          if isinstance(value, str):              try:                  val = float(value)              except ValueError:                  raise ValueError(f\"Property {name} expects a number for control {self.__control_type}\")          elif isinstance(value, numbers.Number):              val = value  # type: ignore          else:              raise ValueError(                  f\"Property {name} expects a number for control {self.__control_type}, received {type(value)}\"              )          return self.__set_react_attribute(_to_camel_case(name), val)        def __set_string_attribute(          self, name: str, default_value: t.Optional[str] = None, optional: t.Optional[bool] = True      ):          strattr = self.__attributes.get(name, default_value)          if strattr is None:              if not optional:                  _warn(f\"Property {name} is required for control {self.__control_type}.\")              return self          return self.set_attribute(_to_camel_case(name), str(strattr))        def __set_dynamic_string_attribute(          self,          name: str,          default_value: t.Optional[str] = None,          with_update: t.Optional[bool] = False,          dynamic_property_name: t.Optional[str] = None,      ):          str_val = self.__attributes.get(name, default_value)          if str_val is not None:              self.set_attribute(                  _to_camel_case(f\"default_{name}\" if dynamic_property_name is None else name), str(str_val)              )          if hash_name := self.__hashes.get(name):              prop_name = _to_camel_case(name if dynamic_property_name is None else dynamic_property_name)              if with_update:                  self.__update_vars.append(f\"{prop_name}={hash_name}\")              self.__set_react_attribute(prop_name, hash_name)          return self        def __set_function_attribute(          self, name: str, default_value: t.Optional[str] = None, optional: t.Optional[bool] = True      ):          strattr = self.__attributes.get(name, default_value)          if strattr is None:              if not optional:                  _warn(f\"Property {name} is required for control {self.__control_type}.\")              return self          elif callable(strattr):              strattr = self.__hashes.get(name)              if strattr is None:                  return self          elif strattr:              strattr = str(strattr)              func = self.__gui._get_user_function(strattr)              if func == strattr:                  _warn(f\"{self.__control_type}.{name}: {strattr} is not a function.\")          return self.set_attribute(_to_camel_case(name), strattr) if strattr else self        def __set_string_or_number_attribute(self, name: str, default_value: t.Optional[t.Any] = None):          attr = self.__attributes.get(name, default_value)          if attr is None:              return self          if isinstance(attr, numbers.Number):              return self.__set_react_attribute(_to_camel_case(name), attr)          else:              return self.set_attribute(_to_camel_case(name), attr)        def __set_react_attribute(self, name: str, value: t.Any):          return self.set_attribute(name, \"{!\" + (str(value).lower() if isinstance(value, bool) else str(value)) + \"!}\")        def _get_adapter(self, var_name: str, property_name: t.Optional[str] = None, multi_selection=True):  # noqa: C901          property_name = var_name if property_name is None else property_name          lov = self.__get_list_of_(var_name)          if isinstance(lov, list):              adapter = self.__attributes.get(\"adapter\")              if adapter and isinstance(adapter, str):                  adapter = self.__gui._get_user_function(adapter)              if adapter and not callable(adapter):                  _warn(\"'adapter' property value is invalid.\")                  adapter = None              var_type = self.__attributes.get(\"type\")              if isclass(var_type):                  var_type = var_type.__name__  # type: ignore              if not isinstance(var_type, str):                  elt = None                  if len(lov) == 0:                      value = self.__attributes.get(\"value\")                      if isinstance(value, list):                          if len(value) > 0:                              elt = value[0]                      else:                          elt = value                  else:                      elt = lov[0]                  var_type = self.__gui._get_unique_type_adapter(type(elt).__name__)              if adapter is None:                  adapter = self.__gui._get_adapter_for_type(var_type)              elif var_type == str.__name__ and callable(adapter):                  var_type += (                      _get_expr_var_name(str(adapter.__code__))                      if adapter.__name__ == \"<lambda>\"                      else _get_expr_var_name(adapter.__name__)                  )              if lov_name := self.__hashes.get(var_name):                  if adapter is None:                      adapter = self.__gui._get_adapter_for_type(lov_name)                  else:                      self.__gui._add_type_for_var(lov_name, var_type)              if value_name := self.__hashes.get(\"value\"):                  if adapter is None:                      adapter = self.__gui._get_adapter_for_type(value_name)                  else:                      self.__gui._add_type_for_var(value_name, var_type)              if adapter is not None:                  self.__gui._add_adapter_for_type(var_type, adapter)  # type: ignore                ret_list = []              if len(lov) > 0:                  for elt in lov:                      ret = self.__gui._run_adapter(                          t.cast(t.Callable, adapter), elt, adapter.__name__ if callable(adapter) else \"adapter\"                      )  # type: ignore                      if ret is not None:                          ret_list.append(ret)              self.__attributes[f\"default_{property_name}\"] = ret_list                ret_list = []              value = self.__attributes.get(\"value\")              val_list = value if isinstance(value, list) else [value]              for val in val_list:                  ret = self.__gui._run_adapter(                      t.cast(t.Callable, adapter), val, adapter.__name__ if callable(adapter) else \"adapter\", id_only=True                  )  # type: ignore                  if ret is not None:                      ret_list.append(ret)              if multi_selection:                  self.__set_default_value(\"value\", ret_list)              else:                  ret_val = ret_list[0] if len(ret_list) else \"\"                  if ret_val == \"-1\" and self.__attributes.get(\"unselected_value\") is not None:                      ret_val = str(self.__attributes.get(\"unselected_value\", \"\"))                  self.__set_default_value(\"value\", ret_val)          return self        def __filter_attribute_names(self, names: t.Iterable[str]):          return [k for k in self.__attributes if k in names or any(k.startswith(n + \"[\") for n in names)]        def __get_holded_name(self, key: str):          name = self.__hashes.get(key)          if name:              v = self.__attributes.get(key)              if isinstance(v, _TaipyBase):                  return name[: len(v.get_hash()) + 1]          return name        def __filter_attributes_hashes(self, keys: t.List[str]):          hash_names = [k for k in self.__hashes if k in keys]          attr_names = [k for k in keys if k not in hash_names]          return (              {k: v for k, v in self.__attributes.items() if k in attr_names},              {k: self.__get_holded_name(k) for k in self.__hashes if k in hash_names},          )        def __build_rebuild_fn(self, fn_name: str, attribute_names: t.Iterable[str]):          rebuild = self.__attributes.get(\"rebuild\", False)          rebuild_hash = self.__hashes.get(\"rebuild\")          if rebuild_hash or rebuild:              attributes, hashes = self.__filter_attributes_hashes(self.__filter_attribute_names(attribute_names))              rebuild_name = f\"bool({self.__gui._get_real_var_name(rebuild_hash)[0]})\" if rebuild_hash else \"None\"              try:                  self.__gui._set_building(True)                  return self.__gui._evaluate_expr(                      \"{\"                      + f'{fn_name}({rebuild}, {rebuild_name}, \"{quote(json.dumps(attributes))}\", \"{quote(json.dumps(hashes))}\", {\", \".join([f\"{k}={v2}\" for k, v2 in {v: self.__gui._get_real_var_name(v)[0] for v in hashes.values()}.items()])})'  # noqa: E501                      + \"}\"                  )              finally:                  self.__gui._set_building(False)          return None        def _get_dataframe_attributes(self) -> \"_Builder\":          date_format = _add_to_dict_and_get(self.__attributes, \"date_format\", \"MM/dd/yyyy\")          data = self.__attributes.get(\"data\")          data_hash = self.__hashes.get(\"data\", \"\")          col_types = self.__gui._accessors._get_col_types(data_hash, _TaipyData(data, data_hash))          col_dict = _get_columns_dict(              data, self.__attributes.get(\"columns\", {}), col_types, date_format, self.__attributes.get(\"number_format\")          )            rebuild_fn_hash = self.__build_rebuild_fn(              self.__gui._get_rebuild_fn_name(\"_tbl_cols\"), _Builder.__TABLE_COLUMNS_DEPS          )          if rebuild_fn_hash:              self.__set_react_attribute(\"columns\", rebuild_fn_hash)          if col_dict is not None:              _enhance_columns(self.__attributes, self.__hashes, col_dict, self.__element_name)              self.__set_json_attribute(\"defaultColumns\", col_dict)          if line_style := self.__attributes.get(\"style\"):              if callable(line_style):                  value = self.__hashes.get(\"style\")              elif isinstance(line_style, str):                  value = line_style.strip()              else:                  value = None              if value in col_types.keys():                  _warn(f\"{self.__element_name}: style={value} must not be a column name.\")              elif value:                  self.set_attribute(\"lineStyle\", value)          if tooltip := self.__attributes.get(\"tooltip\"):              if callable(tooltip):                  value = self.__hashes.get(\"tooltip\")              elif isinstance(tooltip, str):                  value = tooltip.strip()              else:                  value = None              if value in col_types.keys():                  _warn(f\"{self.__element_name}: tooltip={value} must not be a column name.\")              elif value:                  self.set_attribute(\"tooltip\", value)          return self        def _get_chart_config(self, default_type: str, default_mode: str):          self.__attributes[\"_default_type\"] = default_type          self.__attributes[\"_default_mode\"] = default_mode          rebuild_fn_hash = self.__build_rebuild_fn(              self.__gui._get_rebuild_fn_name(\"_chart_conf\"), _CHART_NAMES + (\"_default_type\", \"_default_mode\", \"data\")          )          if rebuild_fn_hash:              self.__set_react_attribute(\"config\", rebuild_fn_hash)            # read column definitions          data = self.__attributes.get(\"data\")          data_hash = self.__hashes.get(\"data\", \"\")          col_types = self.__gui._accessors._get_col_types(data_hash, _TaipyData(data, data_hash))            config = _build_chart_config(self.__gui, self.__attributes, col_types)            self.__set_json_attribute(\"defaultConfig\", config)          self._set_chart_selected(max=len(config.get(\"traces\", \"\")))          self.__set_refresh_on_update()          return self        def _set_string_with_check(self, var_name: str, values: t.List[str], default_value: t.Optional[str] = None):          value = self.__attributes.get(var_name, default_value)          if value is not None:              value = str(value).lower()              self.__attributes[var_name] = value              if value not in values:                  _warn(f\"{self.__element_name}: {var_name}={value} should be in {values}.\")              else:                  self.__set_string_attribute(var_name, default_value)          return self        def __set_list_attribute(          self, name: str, hash_name: t.Optional[str], val: t.Any, elt_type: t.Type, dynamic=True      ) -> t.List[str]:          if not hash_name and isinstance(val, str):              val = [elt_type(t.strip()) for t in val.split(\";\")]          if isinstance(val, list):              if hash_name and dynamic:                  self.__set_react_attribute(name, hash_name)                  return [f\"{name}={hash_name}\"]              else:                  self.__set_json_attribute(name, val)          elif val is not None:              _warn(f\"{self.__element_name}: {name} should be a list of {elt_type}.\")          return []        def _set_chart_selected(self, max=0):          name = \"selected\"          default_sel = self.__attributes.get(name)          idx = 1          name_idx = f\"{name}[{idx}]\"          sel = self.__attributes.get(name_idx)          while idx <= max:              if sel is not None or default_sel is not None:                  self.__update_vars.extend(                      self.__set_list_attribute(                          f\"{name}{idx - 1}\",                          self.__hashes.get(name_idx if sel is not None else name),                          sel if sel is not None else default_sel,                          int,                      )                  )              idx += 1              name_idx = f\"{name}[{idx}]\"              sel = self.__attributes.get(name_idx)        def _get_list_attribute(self, name: str, list_type: PropertyType):          varname = self.__hashes.get(name)          if varname is None:              list_val = self.__attributes.get(name)              if isinstance(list_val, str):                  list_val = list(list_val.split(\";\"))              if isinstance(list_val, list):                  # TODO catch the cast exception                  if list_type.value == PropertyType.number.value:                      list_val = [int(v) for v in list_val]                  else:                      list_val = [int(v) for v in list_val]              else:                  if list_val is not None:                      _warn(f\"{self.__element_name}: {name} should be a list.\")                  list_val = []              self.__set_react_attribute(_to_camel_case(name), list_val)          else:              self.__set_react_attribute(_to_camel_case(name), varname)          return self        def __set_class_names(self):          self.set_attribute(\"libClassName\", self.__lib_name + \"-\" + self.__control_type.replace(\"_\", \"-\"))          return self.__set_dynamic_string_attribute(\"class_name\", dynamic_property_name=\"dynamic_class_name\")        def _set_dataType(self):          value = self.__attributes.get(\"value\")          return self.set_attribute(\"dataType\", _get_data_type(value))        def _set_file_content(self, var_name: str = \"content\"):          if hash_name := self.__hashes.get(var_name):              self.__set_update_var_name(hash_name)          else:              _warn(f\"file_selector: {var_name} should be bound.\")          return self        def _set_content(self, var_name: str = \"content\", image=True):          content = self.__attributes.get(var_name)          hash_name = self.__hashes.get(var_name)          if content is None and hash_name is None:              return self          value = self.__gui._get_content(hash_name or var_name, content, image)          if hash_name:              hash_name = self.__get_typed_hash_name(hash_name, PropertyType.image if image else PropertyType.content)          if hash_name:              self.__set_react_attribute(                  var_name,                  _get_client_var_name(hash_name),              )          return self.set_attribute(_to_camel_case(f\"default_{var_name}\"), value)        def _set_lov(self, var_name=\"lov\", property_name: t.Optional[str] = None):          property_name = var_name if property_name is None else property_name          self.__set_list_of_(f\"default_{property_name}\")          if hash_name := self.__hashes.get(var_name):              hash_name = self.__get_typed_hash_name(hash_name, PropertyType.lov)              self.__update_vars.append(f\"{property_name}={hash_name}\")              self.__set_react_attribute(property_name, hash_name)          return self        def __set_dynamic_string_list(self, var_name: str, default_value: t.Any):          hash_name = self.__hashes.get(var_name)          loi = self.__attributes.get(var_name)          if loi is None:              loi = default_value          if isinstance(loi, str):              loi = [s.strip() for s in loi.split(\";\") if s.strip()]          if isinstance(loi, list):              self.__set_json_attribute(_to_camel_case(f\"default_{var_name}\"), loi)          if hash_name:              self.__update_vars.append(f\"{var_name}={hash_name}\")              self.__set_react_attribute(var_name, hash_name)          return self        def __set_dynamic_number_attribute(self, var_name: str, default_value: t.Any):          hash_name = self.__hashes.get(var_name)          numVal = self.__attributes.get(var_name)          if numVal is None:              numVal = default_value          if isinstance(numVal, str):              try:                  numVal = float(numVal)              except Exception as e:                  _warn(f\"{self.__element_name}: {var_name} cannot be transformed into a number\", e)                  numVal = 0          if isinstance(numVal, numbers.Number):              self.__set_react_attribute(_to_camel_case(f\"default_{var_name}\"), numVal)          elif numVal is not None:              _warn(f\"{self.__element_name}: {var_name} value is not valid ({numVal}).\")          if hash_name:              hash_name = self.__get_typed_hash_name(hash_name, PropertyType.number)              self.__update_vars.append(f\"{var_name}={hash_name}\")              self.__set_react_attribute(var_name, hash_name)          return self        def __set_default_value(          self,          var_name: str,          value: t.Optional[t.Any] = None,          native_type: bool = False,          var_type: t.Optional[PropertyType] = None,      ):          if value is None:              value = self.__attributes.get(var_name)          default_var_name = _to_camel_case(f\"default_{var_name}\")          if isinstance(value, (datetime, date, time)):              return self.set_attribute(default_var_name, _date_to_string(value))          elif isinstance(value, str):              return self.set_attribute(default_var_name, value)          elif native_type and isinstance(value, numbers.Number):              return self.__set_react_attribute(default_var_name, value)          elif value is None:              return self.__set_react_attribute(default_var_name, \"null\")          elif var_type == PropertyType.lov_value:              # Done by _get_adapter              return self          elif isclass(var_type) and issubclass(var_type, _TaipyBase):  # type: ignore              return self.__set_default_value(var_name, t.cast(t.Callable, var_type)(value, \"\").get())          else:              return self.__set_json_attribute(default_var_name, value)        def __set_update_var_name(self, hash_name: str):          return self.set_attribute(\"updateVarName\", hash_name)        def set_value_and_default(          self,          var_name: t.Optional[str] = None,          with_update=True,          with_default=True,          native_type=False,          var_type: t.Optional[PropertyType] = None,          default_val: t.Any = None,      ):          \"\"\"          TODO-undocumented          Sets the value associated with the default property.            Arguments:                var_name (str): The property name (default to default property name).              with_update (optional(bool)): Should the attribute be dynamic (default True).              with_default (optional(bool)): Should a default attribute be set (default True).              native_type (optional(bool)): If var_type == dynamic_number, parse the value to number.              var_type (optional(PropertyType)): the property type (default to string).              default_val (optional(Any)): the default value.          \"\"\"          var_name = self.__default_property_name if var_name is None else var_name          if var_type == PropertyType.slider_value:              if self.__attributes.get(\"lov\"):                  var_type = PropertyType.lov_value                  native_type = False              else:                  var_type = (                      PropertyType.dynamic_lo_numbers                      if isinstance(self.__attributes.get(\"value\"), list)                      else PropertyType.dynamic_number                  )                  native_type = True          if var_type == PropertyType.dynamic_boolean:              return self.set_attributes([(var_name, var_type, bool(default_val), with_update)])          if hash_name := self.__hashes.get(var_name):              hash_name = self.__get_typed_hash_name(hash_name, var_type)              self.__set_react_attribute(                  _to_camel_case(var_name),                  _get_client_var_name(hash_name),              )              if with_update:                  self.__set_update_var_name(hash_name)              if with_default:                  if native_type:                      val = self.__attributes.get(var_name)                      if native_type and isinstance(val, str):                          with contextlib.suppress(Exception):                              val = float(val)                      self.__set_default_value(var_name, val, native_type=native_type)                  else:                      self.__set_default_value(var_name, var_type=var_type)          else:              value = self.__attributes.get(var_name)              if value is not None:                  if native_type:                      if isinstance(value, str):                          with contextlib.suppress(Exception):                              value = float(value)                      if isinstance(value, (int, float)):                          return self.__set_react_attribute(_to_camel_case(var_name), value)                  self.set_attribute(_to_camel_case(var_name), value)          return self        def _set_labels(self, var_name: str = \"labels\"):          if value := self.__attributes.get(var_name):              if _is_boolean_true(value):                  return self.__set_react_attribute(_to_camel_case(var_name), True)              elif isinstance(value, (dict, _MapDict)):                  return self.set_dict_attribute(var_name)          return self        def _set_partial(self):          if self.__control_type not in _Builder.__BLOCK_CONTROLS:              return self          if partial := self.__attributes.get(\"partial\"):              if self.__attributes.get(\"page\"):                  _warn(f\"{self.__element_name} control: page and partial should not be both defined.\")              if isinstance(partial, Partial):                  self.__attributes[\"page\"] = partial._route                  self.__set_react_attribute(\"partial\", partial._route)                  self.__set_react_attribute(\"defaultPartial\", True)          return self        def _set_propagate(self):          val = self.__get_boolean_attribute(\"propagate\", self.__gui._config.config.get(\"propagate\"))          return self if val else self.set_boolean_attribute(\"propagate\", False)        def __set_refresh_on_update(self):          if self.__update_vars:              self.set_attribute(\"updateVars\", \";\".join(self.__update_vars))          return self        def _set_table_pagesize_options(self, default_size=[50, 100, 500]):          page_size_options = self.__attributes.get(\"page_size_options\", default_size)          if isinstance(page_size_options, str):              try:                  page_size_options = [int(s.strip()) for s in page_size_options.split(\";\")]              except Exception as e:                  _warn(f\"{self.__element_name}: page_size_options value is invalid ({page_size_options})\", e)          if isinstance(page_size_options, list):              self.__set_json_attribute(\"pageSizeOptions\", page_size_options)          else:              _warn(f\"{self.__element_name}: page_size_options should be a list.\")          return self        def _set_input_type(self, type_name: str, allow_password=False):          if allow_password and self.__get_boolean_attribute(\"password\", False):              return self.set_attribute(\"type\", \"password\")          return self.set_attribute(\"type\", type_name)        def _set_kind(self):          if self.__attributes.get(\"theme\", False):              self.set_attribute(\"kind\", \"theme\")          return self        def __get_typed_hash_name(self, hash_name: str, var_type: t.Optional[PropertyType]) -> str:          if taipy_type := _get_taipy_type(var_type):              expr = self.__gui._get_expr_from_hash(hash_name)              hash_name = self.__gui._evaluate_bind_holder(taipy_type, expr)          return hash_name        def __set_dynamic_bool_attribute(self, name: str, def_val: t.Any, with_update: bool, update_main=True):          hash_name = self.__hashes.get(name)          val = self.__get_boolean_attribute(name, def_val)          default_name = f\"default_{name}\" if hash_name is not None else name          if val != def_val:              self.set_boolean_attribute(default_name, val)          if hash_name is not None:              hash_name = self.__get_typed_hash_name(hash_name, PropertyType.dynamic_boolean)              self.__set_react_attribute(_to_camel_case(name), _get_client_var_name(hash_name))              if with_update:                  if update_main:                      self.__set_update_var_name(hash_name)                  else:                      self.__update_vars.append(f\"{_to_camel_case(name)}={hash_name}\")        def __set_dynamic_property_without_default(          self, name: str, property_type: PropertyType, optional: t.Optional[bool] = False      ):          hash_name = self.__hashes.get(name)          if hash_name is None:              if not optional:                  _warn(f\"{self.__element_name}.{name} should be bound.\")          else:              hash_name = self.__get_typed_hash_name(hash_name, property_type)              self.__update_vars.append(f\"{_to_camel_case(name)}={hash_name}\")              self.__set_react_attribute(_to_camel_case(name), _get_client_var_name(hash_name))          return self        def __set_html_content(self, name: str, property_name: str, property_type: PropertyType):          hash_name = self.__hashes.get(name)          if not hash_name:              return self          front_var = self.__get_typed_hash_name(hash_name, property_type)          self.set_attribute(              _to_camel_case(f\"default_{property_name}\"),              self.__gui._get_user_content_url(                  None,                  {                      \"variable_name\": front_var,                      self.__gui._HTML_CONTENT_KEY: str(_time.time()),                  },              ),          )          return self.__set_react_attribute(_to_camel_case(property_name), _get_client_var_name(front_var))        def set_attributes(self, attributes: t.List[tuple]):  # noqa: C901          \"\"\"          TODO-undocumented          Sets the attributes from the property with type and default value.            Arguments:                attributes (list(tuple)): The list of attributes as (property name, property type, default value).          \"\"\"          for attr in attributes:              if not isinstance(attr, tuple):                  attr = (attr,)              var_type = _get_tuple_val(attr, 1, PropertyType.string)              if var_type == PropertyType.boolean:                  def_val = _get_tuple_val(attr, 2, False)                  val = self.__get_boolean_attribute(attr[0], def_val)                  if val != def_val:                      self.set_boolean_attribute(attr[0], val)              elif var_type == PropertyType.dynamic_boolean:                  self.__set_dynamic_bool_attribute(                      attr[0],                      _get_tuple_val(attr, 2, False),                      _get_tuple_val(attr, 3, False),                      _get_tuple_val(attr, 4, True),                  )              elif var_type == PropertyType.number:                  self.set_number_attribute(attr[0], _get_tuple_val(attr, 2, None))              elif var_type == PropertyType.dynamic_number:                  self.__set_dynamic_number_attribute(attr[0], _get_tuple_val(attr, 2, None))              elif var_type == PropertyType.string:                  self.__set_string_attribute(attr[0], _get_tuple_val(attr, 2, None), _get_tuple_val(attr, 3, True))              elif var_type == PropertyType.dynamic_string:                  self.__set_dynamic_string_attribute(                      attr[0], _get_tuple_val(attr, 2, None), _get_tuple_val(attr, 3, False)                  )              elif var_type == PropertyType.string_list:                  self.__set_list_attribute(                      attr[0], self.__hashes.get(attr[0]), self.__attributes.get(attr[0]), str, False                  )              elif var_type == PropertyType.function:                  self.__set_function_attribute(attr[0], _get_tuple_val(attr, 2, None), _get_tuple_val(attr, 3, True))              elif var_type == PropertyType.react:                  prop_name = _to_camel_case(attr[0])                  if hash_name := self.__hashes.get(attr[0]):                      self.__update_vars.append(f\"{prop_name}={hash_name}\")                      self.__set_react_attribute(prop_name, hash_name)                  else:                      self.__set_react_attribute(prop_name, self.__attributes.get(attr[0], _get_tuple_val(attr, 2, None)))              elif var_type == PropertyType.broadcast:                  self.__set_react_attribute(                      _to_camel_case(attr[0]), _get_broadcast_var_name(_get_tuple_val(attr, 2, None))                  )              elif var_type == PropertyType.string_or_number:                  self.__set_string_or_number_attribute(attr[0], _get_tuple_val(attr, 2, None))              elif var_type == PropertyType.dict:                  self.set_dict_attribute(attr[0], _get_tuple_val(attr, 2, None))              elif var_type == PropertyType.dynamic_dict:                  self.set_dynamic_dict_attribute(attr[0], _get_tuple_val(attr, 2, None))              elif var_type == PropertyType.dynamic_list:                  self.__set_dynamic_string_list(attr[0], _get_tuple_val(attr, 2, None))              elif var_type == PropertyType.boolean_or_list:                  if _is_boolean(self.__attributes.get(attr[0])):                      self.__set_dynamic_bool_attribute(attr[0], _get_tuple_val(attr, 2, False), True, update_main=False)                  else:                      self.__set_dynamic_string_list(attr[0], _get_tuple_val(attr, 2, None))              elif var_type == PropertyType.data:                  self.__set_dynamic_property_without_default(attr[0], var_type)              elif var_type == PropertyType.lov:                  self._get_adapter(attr[0])  # need to be called before set_lov                  self._set_lov(attr[0])              elif var_type == PropertyType.lov_value:                  self.__set_dynamic_property_without_default(                      attr[0], var_type, _get_tuple_val(attr, 2, None) == \"optional\"                  )              elif var_type == PropertyType.toHtmlContent:                  self.__set_html_content(attr[0], \"page\", var_type)              elif isclass(var_type) and issubclass(var_type, _TaipyBase):                  if hash_name := self.__hashes.get(attr[0]):                      prop_name = _to_camel_case(attr[0])                      expr = self.__gui._get_expr_from_hash(hash_name)                      hash_name = self.__gui._evaluate_bind_holder(var_type, expr)                      self.__update_vars.append(f\"{prop_name}={hash_name}\")                      self.__set_react_attribute(prop_name, hash_name)                self.__set_refresh_on_update()          return self        def set_attribute(self, name: str, value: t.Any):          \"\"\"          TODO-undocumented          Sets an attribute.            Arguments:                name (str): The name of the attribute.              value (Any): The value of the attribute (must be json serializable).          \"\"\"          self.el.set(name, value)          return self        def get_element(self):          \"\"\"          TODO-undocumented          Returns the xml.etree.ElementTree.Element          \"\"\"          return self.el        def _build_to_string(self):          el_str = str(etree.tostring(self.el, encoding=\"utf8\").decode(\"utf8\"))          el_str = el_str.replace(\"<?xml version='1.0' encoding='utf8'?>\\n\", \"\")          el_str = el_str.replace(\"/>\", \">\")          return el_str, self.__element_name "}
{"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": "import re  import typing as t  from typing import Any, List, Tuple    from markdown.preprocessors import Preprocessor as MdPreprocessor    from ..._warnings import _warn  from ..builder import _Builder  from .factory import _MarkdownFactory    if t.TYPE_CHECKING:      from ...gui import Gui      class _Preprocessor(MdPreprocessor):      # ----------------------------------------------------------------------      # Finds, in the Markdown text, control declaration constructs:      #     <|<some value>|>      # or      #     <|<some value>|<control_type>|>      # or      #     <|<some value>|<control_type>|<prop_name[=propvalue]>>      # or      #     <|<control_type>|<prop_name[=propvalue]>>      #      # These constructs are converted a fragment that the ControlPattern      # processes to create the components that get generated.      #     <control_type> prop_name=\"prop_value\" ...      # Note that if a value is provided before the control_type, it is set      # as the default property value for that control type.      # The default control type is 'text'.      # ----------------------------------------------------------------------      # Control in Markdown      __CONTROL_RE = re.compile(r\"<\\|(.*?)\\|>\")      # Opening tag      __OPENING_TAG_RE = re.compile(r\"<([0-9a-zA-Z\\_\\.]*)\\|((?:(?!\\|>).)*)\\s*$\")      # Closing tag      __CLOSING_TAG_RE = re.compile(r\"^\\s*\\|([0-9a-zA-Z\\_\\.]*)>\")      # Link in Markdown      __LINK_RE = re.compile(r\"(\\[[^\\]]*?\\]\\([^\\)]*?\\))\")      # Split properties and control type      __SPLIT_RE = re.compile(r\"(?<!\\\\\\\\)\\|\")      # Property syntax: '<prop_name>[=<prop_value>]'      #   If <prop_value> is omitted:      #     '<prop_name>' is equivalent to '<prop_name>=true'      #     'not <prop_name>' is equivalent to '<prop_name>=false'      #       'not', 'dont', 'don't' are equivalent in this context      #  Note 1: 'not <prop_name>=<prop_value>' is an invalid syntax      #  Note 2: Space characters after the equal sign are significative      __PROPERTY_RE = re.compile(r\"((?:don'?t|not)\\s+)?([a-zA-Z][\\.a-zA-Z_$0-9]*(?:\\[(?:.*?)\\])?)\\s*(?:=(.*))?$\")        _gui: \"Gui\"        @staticmethod      def extend(md, gui, priority):          instance = _Preprocessor(md)          md.preprocessors.register(instance, \"taipy\", priority)          instance._gui = gui        def _make_prop_pair(self, prop_name: str, prop_value: str) -> Tuple[str, str]:          # Un-escape pipe character in property value          return (prop_name, prop_value.replace(\"\\\\|\", \"|\"))        def run(self, lines: List[str]) -> List[str]:          new_lines = []          tag_queue = []          for line_count, line in enumerate(lines, start=1):              new_line = \"\"              last_index = 0              # Opening tags              m = _Preprocessor.__OPENING_TAG_RE.search(line)              if m is not None:                  tag = \"part\"                  properties: List[Tuple[str, str]] = []                  if m.group(2):                      tag, properties = self._process_control(m.group(2), line_count, tag)                  if tag in _MarkdownFactory._TAIPY_BLOCK_TAGS:                      tag_queue.append((tag, line_count, m.group(1) or None))                      new_line_delimeter = \"\\n\" if line.startswith(\"<|\") else \"\\n\\n\"                      line = (                          line[: m.start()]                          + new_line_delimeter                          + _MarkdownFactory._TAIPY_START                          + tag                          + _MarkdownFactory._START_SUFFIX                      )                      for property in properties:                          prop_value = property[1].replace('\"', '\\\\\"')                          line += f' {property[0]}=\"{prop_value}\"'                      line += _MarkdownFactory._TAIPY_END + new_line_delimeter                  else:                      _warn(f\"Invalid tag name '{tag}' in line {line_count}.\")              # Other controls              for m in _Preprocessor.__CONTROL_RE.finditer(line):                  control_name, properties = self._process_control(m.group(1), line_count)                  new_line += line[last_index : m.start()]                  control_text = _MarkdownFactory._TAIPY_START + control_name                  for property in properties:                      prop_value = property[1].replace('\"', '\\\\\"')                      control_text += f' {property[0]}=\"{prop_value}\"'                  control_text += _MarkdownFactory._TAIPY_END                  new_line += control_text                  last_index = m.end()              new_line = line if last_index == 0 else new_line + line[last_index:]              # Add key attribute to links              line = new_line              new_line = \"\"              last_index = 0              for m in _Preprocessor.__LINK_RE.finditer(line):                  new_line += line[last_index : m.end()]                  new_line += \"{: key=\" + _Builder._get_key(\"link\") + \"}\"                  last_index = m.end()              new_line = line if last_index == 0 else new_line + line[last_index:]              # Look for a closing tag              m = _Preprocessor.__CLOSING_TAG_RE.search(new_line)              if m is not None:                  if len(tag_queue):                      open_tag, open_tag_line_count, open_tag_identifier = tag_queue.pop()                      close_tag_identifier = m.group(1)                      if close_tag_identifier and not open_tag_identifier:                          _warn(                              f\"Missing opening '{open_tag}' tag identifier '{close_tag_identifier}' in line {open_tag_line_count}.\"  # noqa: E501                          )                      if open_tag_identifier and not close_tag_identifier:                          _warn(                              f\"Missing closing '{open_tag}' tag identifier '{open_tag_identifier}' in line {line_count}.\"                          )                      if close_tag_identifier and open_tag_identifier and close_tag_identifier != open_tag_identifier:                          _warn(                              f\"Unmatched '{open_tag}' tag identifier in line {open_tag_line_count} and line {line_count}.\"  # noqa: E501                          )                      new_line = (                          new_line[: m.start()]                          + _MarkdownFactory._TAIPY_START                          + open_tag                          + _MarkdownFactory._END_SUFFIX                          + _MarkdownFactory._TAIPY_END                          + \"\\n\"                          + new_line[m.end() :]                      )                  else:                      new_line = (                          new_line[: m.start()]                          + f\"<div>No matching opened tag on line {line_count}</div>\"                          + new_line[m.end() :]                      )                      _warn(f\"Line {line_count} has an unmatched closing tag.\")              # append the new line              new_lines.append(new_line)          # Issue #337: add an empty string at the beginning of new_lines list if there is not one          # so that markdown extension would be able to render properly          if new_lines and new_lines[0] != \"\":              new_lines.insert(0, \"\")          # Check for tags left unclosed (but close them anyway)          for tag, line_no, _ in tag_queue:              new_lines.append(                  _MarkdownFactory._TAIPY_START + tag + _MarkdownFactory._END_SUFFIX + _MarkdownFactory._TAIPY_END              )              _warn(f\"Opened tag {tag} in line {line_no} is not closed.\")          return new_lines        def _process_control(          self, prop_string: str, line_count: int, default_control_name: str = _MarkdownFactory.DEFAULT_CONTROL      ) -> Tuple[str, List[Tuple[str, str]]]:          fragments = [f for f in _Preprocessor.__SPLIT_RE.split(prop_string) if f]          control_name = None          default_prop_name = None          default_prop_value = None          properties: List[Tuple[str, Any]] = []          for fragment in fragments:              if control_name is None and _MarkdownFactory.get_default_property_name(fragment):                  control_name = fragment              elif control_name is None and default_prop_value is None:                  default_prop_value = fragment              elif prop_match := _Preprocessor.__PROPERTY_RE.match(fragment):                  not_prefix = prop_match.group(1)                  prop_name = prop_match.group(2)                  val = prop_match.group(3)                  if not_prefix and val:                      _warn(f\"Negated property {prop_name} value ignored at {line_count}.\")                  prop_value = \"True\"                  if not_prefix:                      prop_value = \"False\"                  elif val:                      prop_value = val                  properties.append(self._make_prop_pair(prop_name, prop_value))              elif len(fragment) > 1 and fragment[0] == \"{\" and fragment[-1] == \"}\":                  properties.append(self._make_prop_pair(fragment[1:-1], fragment))              else:                  _warn(f\"Bad Taipy property format at line {line_count}: '{fragment}'.\")          if control_name is None:              if properties and all(attribute != properties[0][0] for attribute in _MarkdownFactory._TEXT_ATTRIBUTES):                  control_name = properties[0][0]                  properties = properties[1:]                  _warn(f'Unrecognized control {control_name} at line {line_count}: \"<|{prop_string}|>\".')              else:                  control_name = default_control_name          if default_prop_value is not None:              default_prop_name = _MarkdownFactory.get_default_property_name(control_name)              # Set property only if it is not already defined              if default_prop_name and default_prop_name not in [x[0] for x in properties]:                  properties.insert(0, self._make_prop_pair(default_prop_name, default_prop_value))          return control_name, properties "}
{"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": "import os    import pytest  from cookiecutter.exceptions import FailedHookException  from cookiecutter.main import cookiecutter    from .utils import _run_template      def test_default_answer(tmpdir):      cookiecutter(          template=\"src/taipy/templates/default\",          output_dir=str(tmpdir),          no_input=True,      )        assert os.listdir(tmpdir) == [\"taipy_application\"]      assert (          os.listdir(os.path.join(tmpdir, \"taipy_application\")).sort() == [\"requirements.txt\", \"main.py\", \"images\"].sort()      )      with open(os.path.join(tmpdir, \"taipy_application\", \"requirements.txt\")) as requirements_file:          # Assert post_gen_project hook is successful          assert \"taipy==\" in requirements_file.read()        oldpwd = os.getcwd()      os.chdir(os.path.join(tmpdir, \"taipy_application\"))      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\")      def test_main_file_with_and_without_extension(tmpdir):      cookiecutter(          template=\"src/taipy/templates/default\",          output_dir=str(tmpdir),          no_input=True,          extra_context={              \"Application main Python file\": \"app.py\",          },      )      assert (          os.listdir(os.path.join(tmpdir, \"taipy_application\")).sort() == [\"requirements.txt\", \"app.py\", \"images\"].sort()      )        cookiecutter(          template=\"src/taipy/templates/default\",          output_dir=str(tmpdir),          no_input=True,          extra_context={              \"Application root folder name\": \"foo_app\",              \"Application main Python file\": \"app\",          },      )      assert os.listdir(os.path.join(tmpdir, \"foo_app\")).sort() == [\"requirements.txt\", \"app.py\", \"images\"].sort()      def test_with_core_service(tmpdir):      cookiecutter(          template=\"src/taipy/templates/default\",          output_dir=str(tmpdir),          no_input=True,          extra_context={              \"Does the application use scenario management or version management?\": \"y\",              \"Does the application use Rest API?\": \"no\",          },      )        assert (          os.listdir(os.path.join(tmpdir, \"taipy_application\")).sort()          == [\"requirements.txt\", \"main.py\", \"images\", \"configuration\", \"algorithms\"].sort()      )      with open(os.path.join(tmpdir, \"taipy_application\", \"main.py\")) as main_file:          assert \"core = Core()\" in main_file.read()        oldpwd = os.getcwd()      os.chdir(os.path.join(tmpdir, \"taipy_application\"))      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\")      assert \"[Taipy][INFO] Development mode: \" in str(stdout, \"utf-8\")      def test_with_rest_service(tmpdir):      cookiecutter(          template=\"src/taipy/templates/default\",          output_dir=str(tmpdir),          no_input=True,          extra_context={              \"Does the application use scenario management or version management?\": \"n\",              \"Does the application use Rest API?\": \"yes\",          },      )        assert (          os.listdir(os.path.join(tmpdir, \"taipy_application\")).sort() == [\"requirements.txt\", \"main.py\", \"images\"].sort()      )      with open(os.path.join(tmpdir, \"taipy_application\", \"main.py\")) as main_file:          assert \"rest = Rest()\" in main_file.read()        oldpwd = os.getcwd()      os.chdir(os.path.join(tmpdir, \"taipy_application\"))      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\")      assert \"[Taipy][INFO] Development mode: \" in str(stdout, \"utf-8\")      def test_with_both_core_rest_services(tmpdir):      cookiecutter(          template=\"src/taipy/templates/default\",          output_dir=str(tmpdir),          no_input=True,          extra_context={              \"Does the application use scenario management or version management?\": \"n\",              \"Does the application use Rest API?\": \"yes\",          },      )        assert (          os.listdir(os.path.join(tmpdir, \"taipy_application\")).sort()          == [\"requirements.txt\", \"main.py\", \"images\", \"configuration\", \"algorithms\"].sort()      )      with open(os.path.join(tmpdir, \"taipy_application\", \"main.py\")) as main_file:          assert \"rest = Rest()\" in main_file.read()          assert \"core = Core()\" not in main_file.read()        oldpwd = os.getcwd()      os.chdir(os.path.join(tmpdir, \"taipy_application\"))      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\")      assert \"[Taipy][INFO] Development mode: \" in str(stdout, \"utf-8\")      def test_multipage_gui_template(tmpdir):      cookiecutter(          template=\"src/taipy/templates/default\",          output_dir=str(tmpdir),          no_input=True,          extra_context={              \"Application root folder name\": \"foo_app\",              \"Page names in multi-page application?\": \"name_1 name_2 name_3\",          },      )        assert (          os.listdir(os.path.join(tmpdir, \"foo_app\")).sort() == [\"requirements.txt\", \"main.py\", \"pages\", \"images\"].sort()      )      assert (          os.listdir(os.path.join(tmpdir, \"foo_app\", \"pages\")).sort()          == [\"name_1\", \"name_2\", \"name_3\", \"root.md\", \"root.py\", \"__init__.py\"].sort()      )        oldpwd = os.getcwd()      os.chdir(os.path.join(tmpdir, \"foo_app\"))      stdout = _run_template(\"main.py\")      os.chdir(oldpwd)      assert \"[Taipy][INFO]  * Server starting on\" in str(stdout, \"utf-8\")      def test_multipage_gui_template_with_invalid_page_name(tmpdir, capfd):      with pytest.raises(FailedHookException):          cookiecutter(              template=\"src/taipy/templates/default\",              output_dir=str(tmpdir),              no_input=True,              extra_context={                  \"Application root folder name\": \"foo_app\",                  \"Page names in multi-page application?\": \"valid_var_name 1_invalid_var_name\",              },          )        _, stderr = capfd.readouterr()      assert 'Page name \"1_invalid_var_name\" is not a valid Python identifier' in stderr        assert not os.path.exists(os.path.join(tmpdir, \"foo_app\")) "}
{"text": "#  # Licensed under the Apache License, Version 2.0 (the \"License\"); you may not use this file except in compliance with  # the License. You may obtain a copy of the License at  #  #        http://www.apache.org/licenses/LICENSE-2.0  #  # Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on  # an \"AS IS\" BASIS, WITHOUT 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": "import os  import shutil    import taipy      def handle_services(use_rest, use_core):      if use_core or use_rest:          # Write \"import taipy as tp\" at the third line of the import.txt file          with open(os.path.join(os.getcwd(), \"sections\", \"import.txt\"), \"r\") as import_file:              import_lines = import_file.readlines()              import_lines[0] = \"import taipy as tp\\n\" + import_lines[0] + \"\\n\"          with open(os.path.join(os.getcwd(), \"sections\", \"import.txt\"), \"w\") as import_file:              import_file.writelines(import_lines)        # Import the necessary services      if use_core and use_rest:          with open(os.path.join(os.getcwd(), \"sections\", \"import.txt\"), \"a\") as import_file:              import_file.write(\"from taipy import Core, Rest\\n\")      elif use_core:          with open(os.path.join(os.getcwd(), \"sections\", \"import.txt\"), \"a\") as import_file:              import_file.write(\"from taipy import Core\\n\")      elif use_rest:          with open(os.path.join(os.getcwd(), \"sections\", \"import.txt\"), \"a\") as import_file:              import_file.write(\"from taipy import Rest\\n\")        # Start the Rest service      if use_rest:          with open(os.path.join(os.getcwd(), \"sections\", \"main.txt\"), \"a\") as main_file:              main_file.write(\"    rest = Rest()\\n\")        if use_core:          # Create and submit the placeholder scenario          with open(os.path.join(os.getcwd(), \"sections\", \"main.txt\"), \"a\") as main_file:              main_file.write(\"    core = Core()\\n\")              main_file.write(\"    core.run()\\n\")              main_file.write(\"    # #############################################################################\\n\")              main_file.write(\"    # PLACEHOLDER: Create and submit your scenario here                           #\\n\")              main_file.write(\"    #                                                                             #\\n\")              main_file.write(\"    # Example:                                                                    #\\n\")              main_file.write(\"    # from configuration import scenario_config                                   #\\n\")              main_file.write(\"    # scenario = tp.create_scenario(scenario_config)                              #\\n\")              main_file.write(\"    # scenario.submit()                                                           #\\n\")              main_file.write(\"    # Comment, remove or replace the previous lines with your own use case        #\\n\")              main_file.write(\"    # #############################################################################\\n\")      else:          shutil.rmtree(os.path.join(os.getcwd(), \"algorithms\"))          shutil.rmtree(os.path.join(os.getcwd(), \"configuration\"))      def handle_run_service():      with open(os.path.join(os.getcwd(), \"sections\", \"main.txt\"), \"a+\") as main_file:          main_file.seek(0)          main_content = main_file.read()          # Run Rest service along with the GUI service          if \"rest = Rest()\" in main_content:              main_file.write('    tp.run(gui, rest, title=\"{{cookiecutter.__application_title}}\")\\n')          else:              main_file.write('    gui.run(title=\"{{cookiecutter.__application_title}}\")\\n')      def handle_single_page_app():      shutil.rmtree(os.path.join(os.getcwd(), \"pages\"))        with open(os.path.join(os.getcwd(), \"sections\", \"main.txt\"), \"a\") as main_file:          main_file.write(\"\\n\")          main_file.write(\"    gui = Gui(page=page)\\n\")        handle_run_service()        with open(os.path.join(os.getcwd(), \"sections\", \"page_content.txt\"), \"a\") as page_content_file:          page_content_file.write(              '''  page = \"\"\"  <center>  <|navbar|lov={[(\"home\", \"Homepage\")]}|>  </center>    \"\"\"  '''          )      def handle_multi_page_app(pages):      for page_name in pages:          os.mkdir(os.path.join(os.getcwd(), \"pages\", page_name))          with open(os.path.join(os.getcwd(), \"pages\", \"page_example\", \"page_example.md\"), \"r\") as page_md_file:              page_md_content = page_md_file.read()          page_md_content = page_md_content.replace(\"Page example\", page_name.replace(\"_\", \" \").title())          with open(os.path.join(os.getcwd(), \"pages\", page_name, page_name + \".md\"), \"w\") as page_md_file:              page_md_file.write(page_md_content)            with open(os.path.join(os.getcwd(), \"pages\", \"page_example\", \"page_example.py\"), \"r\") as page_content_file:              page_py_content = page_content_file.read()          page_py_content = page_py_content.replace(\"page_example\", page_name)          with open(os.path.join(os.getcwd(), \"pages\", page_name, page_name + \".py\"), \"w\") as page_content_file:              page_content_file.write(page_py_content)        with open(os.path.join(os.getcwd(), \"pages\", \"__init__.py\"), \"a\") as page_init_file:          for page_name in pages:              page_init_file.write(f\"from .{page_name}.{page_name} import {page_name}\\n\")        shutil.rmtree(os.path.join(os.getcwd(), \"pages\", \"page_example\"))        newline = \",\\n\\t\"      user_page_dict = newline.join(f'\"{page_name}\": {page_name}' for page_name in pages)      page_dict = \"\"\"  pages = {      \"/\": root_page,      {pages}  }  \"\"\"      with open(os.path.join(os.getcwd(), \"sections\", \"page_content.txt\"), \"a\") as page_content_file:          page_content_file.write(page_dict.replace(\"{pages}\", user_page_dict))        with open(os.path.join(os.getcwd(), \"sections\", \"import.txt\"), \"a\") as import_file:          import_file.write(\"from pages import *\\n\")        with open(os.path.join(os.getcwd(), \"sections\", \"main.txt\"), \"a\") as main_file:          main_file.write(\"\\n\")          main_file.write(\"    gui = Gui(pages=pages)\\n\")        handle_run_service()      def generate_main_file():      with open(os.path.join(os.getcwd(), \"sections\", \"import.txt\"), \"r\") as import_file:          import_lines = import_file.read()      with open(os.path.join(os.getcwd(), \"sections\", \"page_content.txt\"), \"r\") as page_content_file:          page_content = page_content_file.read()      with open(os.path.join(os.getcwd(), \"sections\", \"main.txt\"), \"r\") as main_file:          main_lines = main_file.read()        with open(os.path.join(os.getcwd(), \"{{cookiecutter.__main_file}}.py\"), \"a\") as app_main_file:          app_main_file.write(import_lines)          app_main_file.write(\"\\n\")          app_main_file.write(page_content)          app_main_file.write(\"\\n\\n\")          app_main_file.write(main_lines)      with open(os.path.join(os.getcwd(), \"requirements.txt\"), \"a\") as requirement_file:      requirement_file.write(f\"taipy=={taipy.version._get_version()}\\n\")    use_core = \"{{ cookiecutter.__core }}\".upper()  use_rest = \"{{ cookiecutter.__rest }}\".upper()  handle_services(use_rest in [\"YES\", \"Y\"], use_core in [\"YES\", \"Y\"])    pages = \"{{ cookiecutter.__pages }}\".split(\" \")  # Remove empty string from pages list  pages = [page for page in pages if page != \"\"]  if len(pages) == 0:      handle_single_page_app()  else:      handle_multi_page_app(pages)    generate_main_file()    # Remove the sections folder  shutil.rmtree(os.path.join(os.getcwd(), \"sections\"))    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": "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 typing as t  from datetime import datetime    from taipy.gui import Gui, State  from taipy.gui.extension import Element, ElementLibrary, ElementProperty, PropertyType    from ..version import _get_version  from ._adapters import _GuiCoreDatanodeAdapter, _GuiCoreScenarioAdapter, _GuiCoreScenarioDagAdapter  from ._context import _GuiCoreContext      class _GuiCore(ElementLibrary):      __LIB_NAME = \"taipy_gui_core\"      __CTX_VAR_NAME = f\"__{__LIB_NAME}_Ctx\"      __SCENARIO_ADAPTER = \"tgc_scenario\"      __DATANODE_ADAPTER = \"tgc_datanode\"      __JOB_ADAPTER = \"tgc_job\"        __elts = {          \"scenario_selector\": Element(              \"value\",              {                  \"id\": ElementProperty(PropertyType.string),                  \"show_add_button\": ElementProperty(PropertyType.boolean, True),                  \"display_cycles\": ElementProperty(PropertyType.boolean, True),                  \"show_primary_flag\": ElementProperty(PropertyType.boolean, True),                  \"value\": ElementProperty(PropertyType.lov_value),                  \"on_change\": ElementProperty(PropertyType.function),                  \"height\": ElementProperty(PropertyType.string, \"50vh\"),                  \"class_name\": ElementProperty(PropertyType.dynamic_string),                  \"show_pins\": ElementProperty(PropertyType.boolean, False),                  \"on_creation\": ElementProperty(PropertyType.function),              },              inner_properties={                  \"scenarios\": ElementProperty(PropertyType.lov, f\"{{{__CTX_VAR_NAME}.get_scenarios()}}\"),                  \"on_scenario_crud\": ElementProperty(PropertyType.function, f\"{{{__CTX_VAR_NAME}.crud_scenario}}\"),                  \"configs\": ElementProperty(PropertyType.react, f\"{{{__CTX_VAR_NAME}.get_scenario_configs()}}\"),                  \"core_changed\": ElementProperty(PropertyType.broadcast, _GuiCoreContext._CORE_CHANGED_NAME),                  \"error\": ElementProperty(PropertyType.react, f\"{{{_GuiCoreContext._SCENARIO_SELECTOR_ERROR_VAR}}}\"),                  \"type\": ElementProperty(PropertyType.inner, __SCENARIO_ADAPTER),                  \"scenario_edit\": ElementProperty(                      _GuiCoreScenarioAdapter,                      f\"{{{__CTX_VAR_NAME}.get_scenario_by_id({_GuiCoreContext._SCENARIO_SELECTOR_ID_VAR})}}\",                  ),                  \"on_scenario_select\": ElementProperty(PropertyType.function, f\"{{{__CTX_VAR_NAME}.select_scenario}}\"),              },          ),          \"scenario\": Element(              \"scenario\",              {                  \"id\": ElementProperty(PropertyType.string),                  \"scenario\": ElementProperty(_GuiCoreScenarioAdapter),                  \"active\": ElementProperty(PropertyType.dynamic_boolean, True),                  \"expandable\": ElementProperty(PropertyType.boolean, True),                  \"expanded\": ElementProperty(PropertyType.boolean, True),                  \"show_submit\": ElementProperty(PropertyType.boolean, True),                  \"show_delete\": ElementProperty(PropertyType.boolean, True),                  \"show_config\": ElementProperty(PropertyType.boolean, False),                  \"show_cycle\": ElementProperty(PropertyType.boolean, False),                  \"show_tags\": ElementProperty(PropertyType.boolean, True),                  \"show_properties\": ElementProperty(PropertyType.boolean, True),                  \"show_sequences\": ElementProperty(PropertyType.boolean, True),                  \"show_submit_sequences\": ElementProperty(PropertyType.boolean, True),                  \"class_name\": ElementProperty(PropertyType.dynamic_string),                  \"on_submission_change\": ElementProperty(PropertyType.function),              },              inner_properties={                  \"on_edit\": ElementProperty(PropertyType.function, f\"{{{__CTX_VAR_NAME}.edit_entity}}\"),                  \"on_submit\": ElementProperty(PropertyType.function, f\"{{{__CTX_VAR_NAME}.submit_entity}}\"),                  \"on_delete\": ElementProperty(PropertyType.function, f\"{{{__CTX_VAR_NAME}.crud_scenario}}\"),                  \"core_changed\": ElementProperty(PropertyType.broadcast, _GuiCoreContext._CORE_CHANGED_NAME),                  \"error\": ElementProperty(PropertyType.react, f\"{{{_GuiCoreContext._SCENARIO_VIZ_ERROR_VAR}}}\"),              },          ),          \"scenario_dag\": Element(              \"scenario\",              {                  \"id\": ElementProperty(PropertyType.string),                  \"scenario\": ElementProperty(_GuiCoreScenarioDagAdapter),                  \"render\": ElementProperty(PropertyType.dynamic_boolean, True),                  \"show_toolbar\": ElementProperty(PropertyType.boolean, True),                  \"width\": ElementProperty(PropertyType.string),                  \"height\": ElementProperty(PropertyType.string),                  \"class_name\": ElementProperty(PropertyType.dynamic_string),              },              inner_properties={                  \"core_changed\": ElementProperty(PropertyType.broadcast, _GuiCoreContext._CORE_CHANGED_NAME),              },          ),          \"data_node_selector\": Element(              \"value\",              {                  \"id\": ElementProperty(PropertyType.string),                  \"display_cycles\": ElementProperty(PropertyType.boolean, True),                  \"show_primary_flag\": ElementProperty(PropertyType.boolean, True),                  \"value\": ElementProperty(PropertyType.lov_value),                  \"on_change\": ElementProperty(PropertyType.function),                  \"height\": ElementProperty(PropertyType.string, \"50vh\"),                  \"class_name\": ElementProperty(PropertyType.dynamic_string),                  \"show_pins\": ElementProperty(PropertyType.boolean, True),              },              inner_properties={                  \"datanodes\": ElementProperty(PropertyType.lov, f\"{{{__CTX_VAR_NAME}.get_datanodes_tree()}}\"),                  \"core_changed\": ElementProperty(PropertyType.broadcast, _GuiCoreContext._CORE_CHANGED_NAME),                  \"type\": ElementProperty(PropertyType.inner, __DATANODE_ADAPTER),              },          ),          \"data_node\": Element(              _GuiCoreContext._DATANODE_VIZ_DATA_NODE_PROP,              {                  \"id\": ElementProperty(PropertyType.string),                  _GuiCoreContext._DATANODE_VIZ_DATA_NODE_PROP: ElementProperty(_GuiCoreDatanodeAdapter),                  \"active\": ElementProperty(PropertyType.dynamic_boolean, True),                  \"expandable\": ElementProperty(PropertyType.boolean, True),                  \"expanded\": ElementProperty(PropertyType.boolean, True),                  \"show_config\": ElementProperty(PropertyType.boolean, False),                  \"show_owner\": ElementProperty(PropertyType.boolean, True),                  \"show_edit_date\": ElementProperty(PropertyType.boolean, False),                  \"show_expiration_date\": ElementProperty(PropertyType.boolean, False),                  \"show_properties\": ElementProperty(PropertyType.boolean, True),                  \"show_history\": ElementProperty(PropertyType.boolean, True),                  \"show_data\": ElementProperty(PropertyType.boolean, True),                  \"chart_config\": ElementProperty(PropertyType.dict),                  \"class_name\": ElementProperty(PropertyType.dynamic_string),                  \"scenario\": ElementProperty(PropertyType.lov_value, \"optional\"),                  \"width\": ElementProperty(PropertyType.string),              },              inner_properties={                  \"on_edit\": ElementProperty(PropertyType.function, f\"{{{__CTX_VAR_NAME}.edit_data_node}}\"),                  \"core_changed\": ElementProperty(PropertyType.broadcast, _GuiCoreContext._CORE_CHANGED_NAME),                  \"error\": ElementProperty(PropertyType.react, f\"{{{_GuiCoreContext._DATANODE_VIZ_ERROR_VAR}}}\"),                  \"scenarios\": ElementProperty(                      PropertyType.lov,                      f\"{{{__CTX_VAR_NAME}.get_scenarios_for_owner({_GuiCoreContext._DATANODE_VIZ_OWNER_ID_VAR})}}\",                  ),                  \"type\": ElementProperty(PropertyType.inner, __SCENARIO_ADAPTER),                  \"on_id_select\": ElementProperty(PropertyType.function, f\"{{{__CTX_VAR_NAME}.select_id}}\"),                  \"history\": ElementProperty(                      PropertyType.react,                      f\"{{{__CTX_VAR_NAME}.get_data_node_history(\"                      + f\"<tp:prop:{_GuiCoreContext._DATANODE_VIZ_DATA_NODE_PROP}>, \"                      + f\"{_GuiCoreContext._DATANODE_VIZ_HISTORY_ID_VAR})}}\",                  ),                  \"data\": ElementProperty(                      PropertyType.react,                      f\"{{{__CTX_VAR_NAME}.get_data_node_data(<tp:prop:{_GuiCoreContext._DATANODE_VIZ_DATA_NODE_PROP}>,\"                      + f\" {_GuiCoreContext._DATANODE_VIZ_DATA_ID_VAR})}}\",                  ),                  \"tabular_data\": ElementProperty(                      PropertyType.data,                      f\"{{{__CTX_VAR_NAME}.get_data_node_tabular_data(\"                      + f\"<tp:prop:{_GuiCoreContext._DATANODE_VIZ_DATA_NODE_PROP}>, \"                      + f\"{_GuiCoreContext._DATANODE_VIZ_DATA_ID_VAR})}}\",                  ),                  \"tabular_columns\": ElementProperty(                      PropertyType.dynamic_string,                      f\"{{{__CTX_VAR_NAME}.get_data_node_tabular_columns(\"                      + f\"<tp:prop:{_GuiCoreContext._DATANODE_VIZ_DATA_NODE_PROP}>, \"                      + f\"{_GuiCoreContext._DATANODE_VIZ_DATA_ID_VAR})}}\",                  ),                  \"chart_config\": ElementProperty(                      PropertyType.dynamic_string,                      f\"{{{__CTX_VAR_NAME}.get_data_node_chart_config(\"                      + f\"<tp:prop:{_GuiCoreContext._DATANODE_VIZ_DATA_NODE_PROP}>, \"                      + f\"{_GuiCoreContext._DATANODE_VIZ_DATA_CHART_ID_VAR})}}\",                  ),                  \"on_data_value\": ElementProperty(PropertyType.function, f\"{{{__CTX_VAR_NAME}.update_data}}\"),                  \"on_tabular_data_edit\": ElementProperty(                      PropertyType.function, f\"{{{__CTX_VAR_NAME}.tabular_data_edit}}\"                  ),                  \"on_lock\": ElementProperty(PropertyType.function, f\"{{{__CTX_VAR_NAME}.lock_datanode_for_edit}}\"),              },          ),          \"job_selector\": Element(              \"value\",              {                  \"id\": ElementProperty(PropertyType.string),                  \"class_name\": ElementProperty(PropertyType.dynamic_string),                  \"value\": ElementProperty(PropertyType.lov_value),                  \"show_id\": ElementProperty(PropertyType.boolean, True),                  \"show_submitted_label\": ElementProperty(PropertyType.boolean, True),                  \"show_submitted_id\": ElementProperty(PropertyType.boolean, False),                  \"show_submission_id\": ElementProperty(PropertyType.boolean, False),                  \"show_date\": ElementProperty(PropertyType.boolean, True),                  \"show_cancel\": ElementProperty(PropertyType.boolean, True),                  \"show_delete\": ElementProperty(PropertyType.boolean, True),                  \"on_change\": ElementProperty(PropertyType.function),                  \"height\": ElementProperty(PropertyType.string, \"50vh\"),              },              inner_properties={                  \"jobs\": ElementProperty(PropertyType.lov, f\"{{{__CTX_VAR_NAME}.get_jobs_list()}}\"),                  \"core_changed\": ElementProperty(PropertyType.broadcast, _GuiCoreContext._CORE_CHANGED_NAME),                  \"type\": ElementProperty(PropertyType.inner, __JOB_ADAPTER),                  \"on_job_action\": ElementProperty(PropertyType.function, f\"{{{__CTX_VAR_NAME}.act_on_jobs}}\"),                  \"error\": ElementProperty(PropertyType.dynamic_string, f\"{{{_GuiCoreContext._JOB_SELECTOR_ERROR_VAR}}}\"),              },          ),      }        def get_name(self) -> str:          return _GuiCore.__LIB_NAME        def get_elements(self) -> t.Dict[str, Element]:          return _GuiCore.__elts        def get_scripts(self) -> t.List[str]:          return [\"lib/taipy-gui-core.js\"]        def on_init(self, gui: Gui) -> t.Optional[t.Tuple[str, t.Any]]:          gui._get_default_locals_bind().update(              {                  _GuiCoreContext._SCENARIO_SELECTOR_ERROR_VAR: \"\",                  _GuiCoreContext._SCENARIO_SELECTOR_ID_VAR: \"\",                  _GuiCoreContext._SCENARIO_VIZ_ERROR_VAR: \"\",                  _GuiCoreContext._JOB_SELECTOR_ERROR_VAR: \"\",                  _GuiCoreContext._DATANODE_VIZ_ERROR_VAR: \"\",                  _GuiCoreContext._DATANODE_VIZ_OWNER_ID_VAR: \"\",                  _GuiCoreContext._DATANODE_VIZ_HISTORY_ID_VAR: \"\",                  _GuiCoreContext._DATANODE_VIZ_DATA_ID_VAR: \"\",                  _GuiCoreContext._DATANODE_VIZ_DATA_CHART_ID_VAR: \"\",              }          )          ctx = _GuiCoreContext(gui)          gui._add_adapter_for_type(_GuiCore.__SCENARIO_ADAPTER, ctx.scenario_adapter)          gui._add_adapter_for_type(_GuiCore.__DATANODE_ADAPTER, ctx.data_node_adapter)          gui._add_adapter_for_type(_GuiCore.__JOB_ADAPTER, ctx.job_adapter)          return _GuiCore.__CTX_VAR_NAME, ctx        def on_user_init(self, state: State):          for var in [              _GuiCoreContext._SCENARIO_SELECTOR_ERROR_VAR,              _GuiCoreContext._SCENARIO_SELECTOR_ID_VAR,              _GuiCoreContext._SCENARIO_VIZ_ERROR_VAR,              _GuiCoreContext._JOB_SELECTOR_ERROR_VAR,              _GuiCoreContext._DATANODE_VIZ_ERROR_VAR,              _GuiCoreContext._DATANODE_VIZ_OWNER_ID_VAR,              _GuiCoreContext._DATANODE_VIZ_HISTORY_ID_VAR,              _GuiCoreContext._DATANODE_VIZ_DATA_ID_VAR,              _GuiCoreContext._DATANODE_VIZ_DATA_CHART_ID_VAR,          ]:              state._add_attribute(var, \"\")        def get_version(self) -> str:          if not hasattr(self, \"version\"):              self.version = _get_version() + str(datetime.now().timestamp())          return self.version "}
{"text": "import json  import typing as t  from collections import defaultdict  from enum import Enum  from numbers import Number  from threading import Lock    try:      import zoneinfo  except ImportError:      from backports import zoneinfo  # type: ignore[no-redef]    import pandas as pd  from dateutil import parser    from taipy.config import Config  from taipy.core import Cycle, DataNode, Job, Scenario, Sequence, cancel_job, create_scenario  from taipy.core import delete as core_delete  from taipy.core import delete_job  from taipy.core import get as core_get  from taipy.core import (      get_cycles_scenarios,      get_data_nodes,      get_jobs,      is_deletable,      is_editable,      is_promotable,      is_readable,      is_submittable,      set_primary,  )  from taipy.core import submit as core_submit  from taipy.core.data._abstract_tabular import _AbstractTabularDataNode  from taipy.core.notification import CoreEventConsumerBase, EventEntityType  from taipy.core.notification.event import Event, EventOperation  from taipy.core.notification.notifier import Notifier  from taipy.gui import Gui, State  from taipy.gui._warnings import _warn  from taipy.gui.gui import _DoNotUpdate    from ._adapters import _EntityType      class _SubmissionStatus(Enum):      SUBMITTED = 0      COMPLETED = 1      CANCELED = 2      FAILED = 3      BLOCKED = 4      WAITING = 5      RUNNING = 6      UNDEFINED = 7      class _SubmissionDetails:      def __init__(          self,          client_id: str,          module_context: str,          callback: t.Callable,          entity_id: str,          status: _SubmissionStatus,          jobs: t.List[Job],      ) -> None:          self.client_id = client_id          self.module_context = module_context          self.callback = callback          self.entity_id = entity_id          self.status = status          self.jobs = jobs        def set_status(self, status: _SubmissionStatus):          self.status = status          return self      class _GuiCoreContext(CoreEventConsumerBase):      __PROP_ENTITY_ID = \"id\"      __PROP_ENTITY_COMMENT = \"comment\"      __PROP_CONFIG_ID = \"config\"      __PROP_DATE = \"date\"      __PROP_ENTITY_NAME = \"name\"      __PROP_SCENARIO_PRIMARY = \"primary\"      __PROP_SCENARIO_TAGS = \"tags\"      __ENTITY_PROPS = (__PROP_CONFIG_ID, __PROP_DATE, __PROP_ENTITY_NAME)      __ACTION = \"action\"      _CORE_CHANGED_NAME = \"core_changed\"      _SCENARIO_SELECTOR_ERROR_VAR = \"gui_core_sc_error\"      _SCENARIO_SELECTOR_ID_VAR = \"gui_core_sc_id\"      _SCENARIO_VIZ_ERROR_VAR = \"gui_core_sv_error\"      _JOB_SELECTOR_ERROR_VAR = \"gui_core_js_error\"      _DATANODE_VIZ_ERROR_VAR = \"gui_core_dv_error\"      _DATANODE_VIZ_OWNER_ID_VAR = \"gui_core_dv_owner_id\"      _DATANODE_VIZ_HISTORY_ID_VAR = \"gui_core_dv_history_id\"      _DATANODE_VIZ_DATA_ID_VAR = \"gui_core_dv_data_id\"      _DATANODE_VIZ_DATA_CHART_ID_VAR = \"gui_core_dv_data_chart_id\"      _DATANODE_VIZ_DATA_NODE_PROP = \"data_node\"        def __init__(self, gui: Gui) -> None:          self.gui = gui          self.scenario_by_cycle: t.Optional[t.Dict[t.Optional[Cycle], t.List[Scenario]]] = None          self.data_nodes_by_owner: t.Optional[t.Dict[t.Optional[str], DataNode]] = None          self.scenario_configs: t.Optional[t.List[t.Tuple[str, str]]] = None          self.jobs_list: t.Optional[t.List[Job]] = None          self.client_jobs_by_submission: t.Dict[str, _SubmissionDetails] = dict()          # register to taipy core notification          reg_id, reg_queue = Notifier.register()          # locks          self.lock = Lock()          self.submissions_lock = Lock()          # super          super().__init__(reg_id, reg_queue)          self.start()        def process_event(self, event: Event):          if event.entity_type == EventEntityType.SCENARIO:              if event.operation == EventOperation.SUBMISSION:                  self.scenario_status_callback(event.attribute_name, True)                  return              self.scenario_refresh(                  event.entity_id if event.operation != EventOperation.DELETION and is_readable(event.entity_id) else None              )          elif event.entity_type == EventEntityType.SEQUENCE and event.entity_id:              sequence = None              try:                  sequence = (                      core_get(event.entity_id)                      if event.operation != EventOperation.DELETION and is_readable(event.entity_id)                      else None                  )                  if sequence and hasattr(sequence, \"parent_ids\") and sequence.parent_ids:                      self.gui._broadcast(                          _GuiCoreContext._CORE_CHANGED_NAME, {\"scenario\": [x for x in sequence.parent_ids]}                      )              except Exception as e:                  _warn(f\"Access to sequence {event.entity_id} failed\", e)          elif event.entity_type == EventEntityType.JOB:              with self.lock:                  self.jobs_list = None              self.scenario_status_callback(event.entity_id)          elif event.entity_type == EventEntityType.DATA_NODE:              with self.lock:                  self.data_nodes_by_owner = None              self.gui._broadcast(                  _GuiCoreContext._CORE_CHANGED_NAME,                  {\"datanode\": event.entity_id if event.operation != EventOperation.DELETION else True},              )        def scenario_refresh(self, scenario_id: t.Optional[str]):          with self.lock:              self.scenario_by_cycle = None              self.data_nodes_by_owner = None          self.gui._broadcast(              _GuiCoreContext._CORE_CHANGED_NAME,              {\"scenario\": scenario_id or True},          )        def scenario_status_callback(self, job_id: str, is_submission: t.Optional[bool] = False):          if not job_id or not (is_submission or is_readable(job_id)):              return          try:              if is_submission:                  sub_id = job_id                  job = None              else:                  job = core_get(job_id)                  if not job:                      return                  sub_id = job.submit_id              sub_details = self.client_jobs_by_submission.get(sub_id)              if not sub_details:                  return                if not sub_details.client_id or not sub_details.entity_id or not sub_details.jobs:                  return                entity = core_get(sub_details.entity_id)              if not entity:                  return                new_status = self._get_submittable_status(sub_details.jobs)              if sub_details.status != new_status:                  # callback                  self.gui._call_user_callback(                      sub_details.client_id,                      sub_details.callback,                      [entity, {\"submission_status\": new_status.name, \"job\": job}],                      sub_details.module_context,                  )              with self.submissions_lock:                  if new_status in (                      _SubmissionStatus.COMPLETED,                      _SubmissionStatus.FAILED,                      _SubmissionStatus.CANCELED,                  ):                      self.client_jobs_by_submission.pop(sub_id, None)                  else:                      self.client_jobs_by_submission[sub_id] = sub_details.set_status(new_status)            except Exception as e:              _warn(f\"Job ({job_id}) is not available\", e)            finally:              self.gui._broadcast(_GuiCoreContext._CORE_CHANGED_NAME, {\"jobs\": True})        def scenario_adapter(self, scenario_or_cycle):          try:              if (                  hasattr(scenario_or_cycle, \"id\")                  and is_readable(scenario_or_cycle.id)                  and core_get(scenario_or_cycle.id) is not None              ):                  if self.scenario_by_cycle and isinstance(scenario_or_cycle, Cycle):                      return (                          scenario_or_cycle.id,                          scenario_or_cycle.get_simple_label(),                          self.scenario_by_cycle.get(scenario_or_cycle),                          _EntityType.CYCLE.value,                          False,                      )                  elif isinstance(scenario_or_cycle, Scenario):                      return (                          scenario_or_cycle.id,                          scenario_or_cycle.get_simple_label(),                          None,                          _EntityType.SCENARIO.value,                          scenario_or_cycle.is_primary,                      )          except Exception as e:              _warn(                  f\"Access to {type(scenario_or_cycle)} \"                  + f\"({scenario_or_cycle.id if hasattr(scenario_or_cycle, 'id') else 'No_id'})\"                  + \" failed\",                  e,              )          return None        def get_scenarios(self):          cycles_scenarios = []          with self.lock:              if self.scenario_by_cycle is None:                  self.scenario_by_cycle = get_cycles_scenarios()              for cycle, scenarios in self.scenario_by_cycle.items():                  if cycle is None:                      cycles_scenarios.extend(scenarios)                  else:                      cycles_scenarios.append(cycle)          return cycles_scenarios        def select_scenario(self, state: State, id: str, payload: t.Dict[str, str]):          args = payload.get(\"args\")          if args is None or not isinstance(args, list) or len(args) == 0:              return          state.assign(_GuiCoreContext._SCENARIO_SELECTOR_ID_VAR, args[0])        def get_scenario_by_id(self, id: str) -> t.Optional[Scenario]:          if not id or not is_readable(id):              return None          try:              return core_get(id)          except Exception:              return None        def get_scenario_configs(self):          with self.lock:              if self.scenario_configs is None:                  configs = Config.scenarios                  if isinstance(configs, dict):                      self.scenario_configs = [(id, f\"{c.id}\") for id, c in configs.items() if id != \"default\"]              return self.scenario_configs        def crud_scenario(self, state: State, id: str, payload: t.Dict[str, str]):  # noqa: C901          args = payload.get(\"args\")          if (              args is None              or not isinstance(args, list)              or len(args) < 3              or not isinstance(args[0], bool)              or not isinstance(args[1], bool)              or not isinstance(args[2], dict)          ):              return          update = args[0]          delete = args[1]          data = args[2]          scenario = None            name = data.get(_GuiCoreContext.__PROP_ENTITY_NAME)          if update:              scenario_id = data.get(_GuiCoreContext.__PROP_ENTITY_ID)              if delete:                  if not is_deletable(scenario_id):                      state.assign(                          _GuiCoreContext._SCENARIO_SELECTOR_ERROR_VAR, f\"Scenario. {scenario_id} is not deletable.\"                      )                      return                  try:                      core_delete(scenario_id)                  except Exception as e:                      state.assign(_GuiCoreContext._SCENARIO_SELECTOR_ERROR_VAR, f\"Error deleting Scenario. {e}\")              else:                  if not self.__check_readable_editable(                      state, scenario_id, \"Scenario\", _GuiCoreContext._SCENARIO_SELECTOR_ERROR_VAR                  ):                      return                  scenario = core_get(scenario_id)          else:              config_id = data.get(_GuiCoreContext.__PROP_CONFIG_ID)              scenario_config = Config.scenarios.get(config_id)              if scenario_config is None:                  state.assign(_GuiCoreContext._SCENARIO_SELECTOR_ERROR_VAR, f\"Invalid configuration id ({config_id})\")                  return              date_str = data.get(_GuiCoreContext.__PROP_DATE)              try:                  date = parser.parse(date_str) if isinstance(date_str, str) else None              except Exception as e:                  state.assign(_GuiCoreContext._SCENARIO_SELECTOR_ERROR_VAR, f\"Invalid date ({date_str}).{e}\")                  return              scenario_id = None              try:                  gui: Gui = state._gui                  on_creation = args[3] if len(args) > 3 and isinstance(args[3], str) else None                  on_creation_function = gui._get_user_function(on_creation) if on_creation else None                  if callable(on_creation_function):                      try:                          res = gui._call_function_with_state(                              on_creation_function,                              [                                  id,                                  {                                      \"action\": on_creation,                                      \"config\": scenario_config,                                      \"date\": date,                                      \"label\": name,                                      \"properties\": {                                          v.get(\"key\"): v.get(\"value\") for v in data.get(\"properties\", dict())                                      },                                  },                              ],                          )                          if isinstance(res, Scenario):                              # everything's fine                              scenario_id = res.id                              state.assign(_GuiCoreContext._SCENARIO_SELECTOR_ERROR_VAR, \"\")                              return                          if res:                              # do not create                              state.assign(_GuiCoreContext._SCENARIO_SELECTOR_ERROR_VAR, f\"{res}\")                              return                      except Exception as e:  # pragma: no cover                          if not gui._call_on_exception(on_creation, e):                              _warn(f\"on_creation(): Exception raised in '{on_creation}()'\", e)                          state.assign(                              _GuiCoreContext._SCENARIO_SELECTOR_ERROR_VAR,                              f\"Error creating Scenario with '{on_creation}()'. {e}\",                          )                          return                  elif on_creation is not None:                      _warn(f\"on_creation(): '{on_creation}' is not a function.\")                  scenario = create_scenario(scenario_config, date, name)                  scenario_id = scenario.id              except Exception as e:                  state.assign(_GuiCoreContext._SCENARIO_SELECTOR_ERROR_VAR, f\"Error creating Scenario. {e}\")              finally:                  self.scenario_refresh(scenario_id)          if scenario:              if not is_editable(scenario):                  state.assign(                      _GuiCoreContext._SCENARIO_SELECTOR_ERROR_VAR, f\"Scenario {scenario_id or name} is not editable.\"                  )                  return              with scenario as sc:                  sc.properties[_GuiCoreContext.__PROP_ENTITY_NAME] = name                  if props := data.get(\"properties\"):                      try:                          new_keys = [prop.get(\"key\") for prop in props]                          for key in t.cast(dict, sc.properties).keys():                              if key and key not in _GuiCoreContext.__ENTITY_PROPS and key not in new_keys:                                  t.cast(dict, sc.properties).pop(key, None)                          for prop in props:                              key = prop.get(\"key\")                              if key and key not in _GuiCoreContext.__ENTITY_PROPS:                                  sc._properties[key] = prop.get(\"value\")                          state.assign(_GuiCoreContext._SCENARIO_SELECTOR_ERROR_VAR, \"\")                      except Exception as e:                          state.assign(_GuiCoreContext._SCENARIO_SELECTOR_ERROR_VAR, f\"Error creating Scenario. {e}\")        def edit_entity(self, state: State, id: str, payload: t.Dict[str, str]):          args = payload.get(\"args\")          if args is None or not isinstance(args, list) or len(args) < 1 or not isinstance(args[0], dict):              return          data = args[0]          entity_id = data.get(_GuiCoreContext.__PROP_ENTITY_ID)          if not self.__check_readable_editable(              state, entity_id, data.get(\"type\", \"Scenario\"), _GuiCoreContext._SCENARIO_VIZ_ERROR_VAR          ):              return          entity: t.Union[Scenario, Sequence] = core_get(entity_id)          if entity:              try:                  if isinstance(entity, Scenario):                      primary = data.get(_GuiCoreContext.__PROP_SCENARIO_PRIMARY)                      if primary is True:                          if not is_promotable(entity):                              state.assign(                                  _GuiCoreContext._SCENARIO_VIZ_ERROR_VAR, f\"Scenario {entity_id} is not promotable.\"                              )                              return                          set_primary(entity)                  self.__edit_properties(entity, data)                  state.assign(_GuiCoreContext._SCENARIO_VIZ_ERROR_VAR, \"\")              except Exception as e:                  state.assign(_GuiCoreContext._SCENARIO_VIZ_ERROR_VAR, f\"Error updating Scenario. {e}\")        def submit_entity(self, state: State, id: str, payload: t.Dict[str, str]):          args = payload.get(\"args\")          if args is None or not isinstance(args, list) or len(args) < 1 or not isinstance(args[0], dict):              return          data = args[0]          entity_id = data.get(_GuiCoreContext.__PROP_ENTITY_ID)          if not is_submittable(entity_id):              state.assign(                  _GuiCoreContext._SCENARIO_VIZ_ERROR_VAR,                  f\"{data.get('type', 'Scenario')} {entity_id} is not submittable.\",              )              return          entity = core_get(entity_id)          if entity:              try:                  jobs = core_submit(entity)                  if submission_cb := data.get(\"on_submission_change\"):                      submission_fn = self.gui._get_user_function(submission_cb)                      if callable(submission_fn):                          job_ids = [j.id for j in (jobs if isinstance(jobs, list) else [jobs])]                          client_id = self.gui._get_client_id()                          module_context = self.gui._get_locals_context()                          sub_id = jobs[0].submit_id if isinstance(jobs, list) else jobs.submit_id                          with self.submissions_lock:                              self.client_jobs_by_submission[sub_id] = _SubmissionDetails(                                  client_id,                                  module_context,                                  submission_fn,                                  entity_id,                                  _SubmissionStatus.SUBMITTED,                                  job_ids,                              )                      else:                          _warn(f\"on_submission_change(): '{submission_cb}' is not a valid function.\")                  self.scenario_status_callback(jobs[0].id if len(jobs) else \"\" if isinstance(jobs, list) else jobs.id)                  state.assign(_GuiCoreContext._SCENARIO_VIZ_ERROR_VAR, \"\")              except Exception as e:                  state.assign(_GuiCoreContext._SCENARIO_VIZ_ERROR_VAR, f\"Error submitting entity. {e}\")        def _get_submittable_status(self, jobs_ids: t.List[str]) -> _SubmissionStatus:          abandoned = False          canceled = False          blocked = False          waiting = False          running = False          completed = False          for id in jobs_ids:              job = core_get(id)              if not job:                  continue              if job.is_failed():                  return _SubmissionStatus.FAILED              if job.is_canceled():                  canceled = True              if job.is_blocked():                  blocked = True                  continue              if job.is_pending() or job.is_submitted():                  waiting = True                  continue              if job.is_running():                  running = True                  continue              if job.is_completed() or job.is_skipped():                  completed = True                  continue              if job.is_abandoned():                  abandoned = True          if canceled:              return _SubmissionStatus.CANCELED          if abandoned:              return _SubmissionStatus.UNDEFINED          if running:              return _SubmissionStatus.RUNNING          if waiting:              return _SubmissionStatus.WAITING          if blocked:              return _SubmissionStatus.BLOCKED          if completed:              return _SubmissionStatus.COMPLETED          return _SubmissionStatus.UNDEFINED        def __do_datanodes_tree(self):          if self.data_nodes_by_owner is None:              self.data_nodes_by_owner = defaultdict(list)              for dn in get_data_nodes():                  self.data_nodes_by_owner[dn.owner_id].append(dn)        def get_datanodes_tree(self):          with self.lock:              self.__do_datanodes_tree()          return self.data_nodes_by_owner.get(None, []) + self.get_scenarios()        def data_node_adapter(self, data):          try:              if hasattr(data, \"id\") and is_readable(data.id) and core_get(data.id) is not None:                  if isinstance(data, DataNode):                      return (data.id, data.get_simple_label(), None, _EntityType.DATANODE.value, False)                  else:                      with self.lock:                          self.__do_datanodes_tree()                          if self.data_nodes_by_owner:                              if isinstance(data, Cycle):                                  return (                                      data.id,                                      data.get_simple_label(),                                      self.data_nodes_by_owner[data.id] + self.scenario_by_cycle.get(data, []),                                      _EntityType.CYCLE.value,                                      False,                                  )                              elif isinstance(data, Scenario):                                  return (                                      data.id,                                      data.get_simple_label(),                                      self.data_nodes_by_owner[data.id] + list(data.sequences.values()),                                      _EntityType.SCENARIO.value,                                      data.is_primary,                                  )                              elif isinstance(data, Sequence):                                  if datanodes := self.data_nodes_by_owner.get(data.id):                                      return (                                          data.id,                                          data.get_simple_label(),                                          datanodes,                                          _EntityType.SEQUENCE.value,                                          False,                                      )          except Exception as e:              _warn(                  f\"Access to {type(data)} ({data.id if hasattr(data, 'id') else 'No_id'}) failed\",                  e,              )            return None        def get_jobs_list(self):          with self.lock:              if self.jobs_list is None:                  self.jobs_list = get_jobs()              return self.jobs_list        def job_adapter(self, job):          try:              if hasattr(job, \"id\") and is_readable(job.id) and core_get(job.id) is not None:                  if isinstance(job, Job):                      entity = core_get(job.owner_id)                      return (                          job.id,                          job.get_simple_label(),                          [],                          entity.get_simple_label() if entity else \"\",                          entity.id if entity else \"\",                          job.submit_id,                          job.creation_date,                          job.status.value,                          is_deletable(job),                          is_readable(job),                          is_editable(job),                      )          except Exception as e:              _warn(f\"Access to job ({job.id if hasattr(job, 'id') else 'No_id'}) failed\", e)          return None        def act_on_jobs(self, state: State, id: str, payload: t.Dict[str, str]):          args = payload.get(\"args\")          if args is None or not isinstance(args, list) or len(args) < 1 or not isinstance(args[0], dict):              return          data = args[0]          job_ids = data.get(_GuiCoreContext.__PROP_ENTITY_ID)          job_action = data.get(_GuiCoreContext.__ACTION)          if job_action and isinstance(job_ids, list):              errs = []              if job_action == \"delete\":                  for job_id in job_ids:                      if not is_readable(job_id):                          errs.append(f\"Job {job_id} is not readable.\")                          continue                      if not is_deletable(job_id):                          errs.append(f\"Job {job_id} is not deletable.\")                          continue                      try:                          delete_job(core_get(job_id))                      except Exception as e:                          errs.append(f\"Error deleting job. {e}\")              elif job_action == \"cancel\":                  for job_id in job_ids:                      if not is_readable(job_id):                          errs.append(f\"Job {job_id} is not readable.\")                          continue                      if not is_editable(job_id):                          errs.append(f\"Job {job_id} is not cancelable.\")                          continue                      try:                          cancel_job(job_id)                      except Exception as e:                          errs.append(f\"Error canceling job. {e}\")              state.assign(_GuiCoreContext._JOB_SELECTOR_ERROR_VAR, \"<br/>\".join(errs) if errs else \"\")        def edit_data_node(self, state: State, id: str, payload: t.Dict[str, str]):          args = payload.get(\"args\")          if args is None or not isinstance(args, list) or len(args) < 1 or not isinstance(args[0], dict):              return          data = args[0]          entity_id = data.get(_GuiCoreContext.__PROP_ENTITY_ID)          if not self.__check_readable_editable(state, entity_id, \"DataNode\", _GuiCoreContext._DATANODE_VIZ_ERROR_VAR):              return          entity: DataNode = core_get(entity_id)          if isinstance(entity, DataNode):              try:                  self.__edit_properties(entity, data)                  state.assign(_GuiCoreContext._DATANODE_VIZ_ERROR_VAR, \"\")              except Exception as e:                  state.assign(_GuiCoreContext._DATANODE_VIZ_ERROR_VAR, f\"Error updating Datanode. {e}\")        def lock_datanode_for_edit(self, state: State, id: str, payload: t.Dict[str, str]):          args = payload.get(\"args\")          if args is None or not isinstance(args, list) or len(args) < 1 or not isinstance(args[0], dict):              return          data = args[0]          entity_id = data.get(_GuiCoreContext.__PROP_ENTITY_ID)          if not self.__check_readable_editable(state, entity_id, \"Datanode\", _GuiCoreContext._DATANODE_VIZ_ERROR_VAR):              return          lock = data.get(\"lock\", True)          entity: DataNode = core_get(entity_id)          if isinstance(entity, DataNode):              try:                  if lock:                      entity.lock_edit(self.gui._get_client_id())                  else:                      entity.unlock_edit(self.gui._get_client_id())                  state.assign(_GuiCoreContext._DATANODE_VIZ_ERROR_VAR, \"\")              except Exception as e:                  state.assign(_GuiCoreContext._DATANODE_VIZ_ERROR_VAR, f\"Error locking Datanode. {e}\")        def __edit_properties(self, entity: t.Union[Scenario, Sequence, DataNode], data: t.Dict[str, str]):          with entity as ent:              if isinstance(ent, Scenario):                  tags = data.get(_GuiCoreContext.__PROP_SCENARIO_TAGS)                  if isinstance(tags, (list, tuple)):                      ent.tags = {t for t in tags}              name = data.get(_GuiCoreContext.__PROP_ENTITY_NAME)              if isinstance(name, str):                  ent.properties[_GuiCoreContext.__PROP_ENTITY_NAME] = name              props = data.get(\"properties\")              if isinstance(props, (list, tuple)):                  for prop in props:                      key = prop.get(\"key\")                      if key and key not in _GuiCoreContext.__ENTITY_PROPS:                          ent.properties[key] = prop.get(\"value\")              deleted_props = data.get(\"deleted_properties\")              if isinstance(deleted_props, (list, tuple)):                  for prop in deleted_props:                      key = prop.get(\"key\")                      if key and key not in _GuiCoreContext.__ENTITY_PROPS:                          ent.properties.pop(key, None)        def get_scenarios_for_owner(self, owner_id: str):          cycles_scenarios: t.List[t.Union[Scenario, Cycle]] = []          with self.lock:              if self.scenario_by_cycle is None:                  self.scenario_by_cycle = get_cycles_scenarios()              if owner_id:                  if owner_id == \"GLOBAL\":                      for cycle, scenarios in self.scenario_by_cycle.items():                          if cycle is None:                              cycles_scenarios.extend(scenarios)                          else:                              cycles_scenarios.append(cycle)                  elif is_readable(owner_id):                      entity = core_get(owner_id)                      if entity and (scenarios := self.scenario_by_cycle.get(entity)):                          cycles_scenarios.extend(scenarios)                      elif isinstance(entity, Scenario):                          cycles_scenarios.append(entity)          return cycles_scenarios        def get_data_node_history(self, datanode: DataNode, id: str):          if (              id              and isinstance(datanode, DataNode)              and id == datanode.id              and (dn := core_get(id))              and isinstance(dn, DataNode)          ):              res = []              for e in dn.edits:                  job_id = e.get(\"job_id\")                  job: Job = None                  if job_id:                      if not is_readable(job_id):                          job_id += \" not readable\"                      else:                          job = core_get(job_id)                  res.append(                      (                          e.get(\"timestamp\"),                          job_id if job_id else e.get(\"writer_identifier\", \"\"),                          f\"Execution of task {job.task.get_simple_label()}.\"                          if job and job.task                          else e.get(\"comment\", \"\"),                      )                  )              return list(reversed(sorted(res, key=lambda r: r[0])))          return _DoNotUpdate()        def get_data_node_data(self, datanode: DataNode, id: str):          if (              id              and isinstance(datanode, DataNode)              and id == datanode.id              and (dn := core_get(id))              and isinstance(dn, DataNode)          ):              if dn._last_edit_date:                  if isinstance(dn, _AbstractTabularDataNode):                      return (None, None, True, None)                  try:                      value = dn.read()                      if isinstance(value, (pd.DataFrame, pd.Series)):                          return (None, None, True, None)                      return (                          value,                          \"date\"                          if \"date\" in type(value).__name__                          else type(value).__name__                          if isinstance(value, Number)                          else None,                          None,                          None,                      )                  except Exception as e:                      return (None, None, None, f\"read data_node: {e}\")              return (None, None, None, f\"Data unavailable for {dn.get_simple_label()}\")          return _DoNotUpdate()        def __check_readable_editable(self, state: State, id: str, type: str, var: str):          if not is_readable(id):              state.assign(var, f\"{type} {id} is not readable.\")              return False          if not is_editable(id):              state.assign(var, f\"{type} {id} is not editable.\")              return False          return True        def update_data(self, state: State, id: str, payload: t.Dict[str, str]):          args = payload.get(\"args\")          if args is None or not isinstance(args, list) or len(args) < 1 or not isinstance(args[0], dict):              return          data = args[0]          entity_id = data.get(_GuiCoreContext.__PROP_ENTITY_ID)          if not self.__check_readable_editable(state, entity_id, \"DataNode\", _GuiCoreContext._DATANODE_VIZ_ERROR_VAR):              return          entity: DataNode = core_get(entity_id)          if isinstance(entity, DataNode):              try:                  entity.write(                      parser.parse(data.get(\"value\"))                      if data.get(\"type\") == \"date\"                      else int(data.get(\"value\"))                      if data.get(\"type\") == \"int\"                      else float(data.get(\"value\"))                      if data.get(\"type\") == \"float\"                      else data.get(\"value\"),                      comment=data.get(_GuiCoreContext.__PROP_ENTITY_COMMENT),                  )                  entity.unlock_edit(self.gui._get_client_id())                  state.assign(_GuiCoreContext._DATANODE_VIZ_ERROR_VAR, \"\")              except Exception as e:                  state.assign(_GuiCoreContext._DATANODE_VIZ_ERROR_VAR, f\"Error updating Datanode value. {e}\")              state.assign(_GuiCoreContext._DATANODE_VIZ_DATA_ID_VAR, entity_id)  # this will update the data value        def tabular_data_edit(self, state: State, var_name: str, payload: dict):          user_data = payload.get(\"user_data\", {})          dn_id = user_data.get(\"dn_id\")          if not self.__check_readable_editable(state, dn_id, \"DataNode\", _GuiCoreContext._DATANODE_VIZ_ERROR_VAR):              return          datanode = core_get(dn_id) if dn_id else None          if isinstance(datanode, DataNode):              try:                  idx = payload.get(\"index\")                  col = payload.get(\"col\")                  tz = payload.get(\"tz\")                  val = (                      parser.parse(str(payload.get(\"value\"))).astimezone(zoneinfo.ZoneInfo(tz)).replace(tzinfo=None)                      if tz is not None                      else payload.get(\"value\")                  )                  # user_value = payload.get(\"user_value\")                  data = self.__read_tabular_data(datanode)                  if hasattr(data, \"at\"):                      data.at[idx, col] = val                      datanode.write(data, comment=user_data.get(_GuiCoreContext.__PROP_ENTITY_COMMENT))                      state.assign(_GuiCoreContext._DATANODE_VIZ_ERROR_VAR, \"\")                  else:                      state.assign(                          _GuiCoreContext._DATANODE_VIZ_ERROR_VAR,                          \"Error updating Datanode tabular value: type does not support at[] indexer.\",                      )              except Exception as e:                  state.assign(_GuiCoreContext._DATANODE_VIZ_ERROR_VAR, f\"Error updating Datanode tabular value. {e}\")          setattr(state, _GuiCoreContext._DATANODE_VIZ_DATA_ID_VAR, dn_id)        def __read_tabular_data(self, datanode: DataNode):          return datanode.read()        def get_data_node_tabular_data(self, datanode: DataNode, id: str):          if (              id              and isinstance(datanode, DataNode)              and id == datanode.id              and is_readable(id)              and (dn := core_get(id))              and isinstance(dn, DataNode)              and dn.is_ready_for_reading          ):              try:                  return self.__read_tabular_data(dn)              except Exception:                  return None          return None        def get_data_node_tabular_columns(self, datanode: DataNode, id: str):          if (              id              and isinstance(datanode, DataNode)              and id == datanode.id              and is_readable(id)              and (dn := core_get(id))              and isinstance(dn, DataNode)              and dn.is_ready_for_reading          ):              try:                  return self.gui._tbl_cols(                      True, True, \"{}\", json.dumps({\"data\": \"tabular_data\"}), tabular_data=self.__read_tabular_data(dn)                  )              except Exception:                  return None          return None        def get_data_node_chart_config(self, datanode: DataNode, id: str):          if (              id              and isinstance(datanode, DataNode)              and id == datanode.id              and is_readable(id)              and (dn := core_get(id))              and isinstance(dn, DataNode)              and dn.is_ready_for_reading          ):              try:                  return self.gui._chart_conf(                      True, True, \"{}\", json.dumps({\"data\": \"tabular_data\"}), tabular_data=self.__read_tabular_data(dn)                  )              except Exception:                  return None          return None        def select_id(self, state: State, id: str, payload: t.Dict[str, str]):          args = payload.get(\"args\")          if args is None or not isinstance(args, list) or len(args) == 0 and isinstance(args[0], dict):              return          data = args[0]          if owner_id := data.get(\"owner_id\"):              state.assign(_GuiCoreContext._DATANODE_VIZ_OWNER_ID_VAR, owner_id)          elif history_id := data.get(\"history_id\"):              state.assign(_GuiCoreContext._DATANODE_VIZ_HISTORY_ID_VAR, history_id)          elif data_id := data.get(\"data_id\"):              state.assign(_GuiCoreContext._DATANODE_VIZ_DATA_ID_VAR, data_id)          elif chart_id := data.get(\"chart_id\"):              state.assign(_GuiCoreContext._DATANODE_VIZ_DATA_CHART_ID_VAR, chart_id) "}
{"text": "import typing as t  from enum import Enum    from taipy.core import Cycle, DataNode, Job, Scenario, Sequence, Task  from taipy.core import get as core_get  from taipy.core import is_deletable, is_editable, is_promotable, is_readable, is_submittable  from taipy.gui._warnings import _warn  from taipy.gui.gui import _DoNotUpdate  from taipy.gui.utils import _TaipyBase      # prevent gui from trying to push scenario instances to the front-end  class _GCDoNotUpdate(_DoNotUpdate):      def __repr__(self):          return self.get_label() if hasattr(self, \"get_label\") else super().__repr__()      Scenario.__bases__ += (_GCDoNotUpdate,)  Sequence.__bases__ += (_GCDoNotUpdate,)  DataNode.__bases__ += (_GCDoNotUpdate,)  Cycle.__bases__ += (_GCDoNotUpdate,)  Job.__bases__ += (_GCDoNotUpdate,)  Task.__bases__ += (_GCDoNotUpdate,)      class _EntityType(Enum):      CYCLE = 0      SCENARIO = 1      SEQUENCE = 2      DATANODE = 3      class _GuiCoreScenarioAdapter(_TaipyBase):      __INNER_PROPS = [\"name\"]        def get(self):          data = super().get()          if isinstance(data, Scenario):              try:                  scenario = core_get(data.id)                  if scenario:                      return [                          scenario.id,                          scenario.is_primary,                          scenario.config_id,                          scenario.creation_date.isoformat(),                          scenario.cycle.get_simple_label() if scenario.cycle else \"\",                          scenario.get_simple_label(),                          list(scenario.tags) if scenario.tags else [],                          [                              (k, v)                              for k, v in scenario.properties.items()                              if k not in _GuiCoreScenarioAdapter.__INNER_PROPS                          ]                          if scenario.properties                          else [],                          [                              (p.id, p.get_simple_label(), is_submittable(p), is_editable(p))                              for p in scenario.sequences.values()                          ]                          if hasattr(scenario, \"sequences\") and scenario.sequences                          else [],                          list(scenario.properties.get(\"authorized_tags\", [])) if scenario.properties else [],                          is_deletable(scenario),                          is_promotable(scenario),                          is_submittable(scenario),                          is_readable(scenario),                          is_editable(scenario),                      ]              except Exception as e:                  _warn(f\"Access to scenario ({data.id if hasattr(data, 'id') else 'No_id'}) failed\", e)            return None        @staticmethod      def get_hash():          return _TaipyBase._HOLDER_PREFIX + \"Sc\"      class _GuiCoreScenarioDagAdapter(_TaipyBase):      @staticmethod      def get_entity_type(node: t.Any):          return DataNode.__name__ if isinstance(node.entity, DataNode) else node.type        def get(self):          data = super().get()          if isinstance(data, Scenario):              try:                  scenario = core_get(data.id)                  if scenario:                      dag = data._get_dag()                      nodes = dict()                      for id, node in dag.nodes.items():                          entityType = _GuiCoreScenarioDagAdapter.get_entity_type(node)                          cat = nodes.get(entityType)                          if cat is None:                              cat = dict()                              nodes[entityType] = cat                          cat[id] = {                              \"name\": node.entity.get_simple_label(),                              \"type\": node.entity.storage_type() if hasattr(node.entity, \"storage_type\") else None,                          }                      return [                          data.id,                          nodes,                          [                              (                                  _GuiCoreScenarioDagAdapter.get_entity_type(e.src),                                  e.src.entity.id,                                  _GuiCoreScenarioDagAdapter.get_entity_type(e.dest),                                  e.dest.entity.id,                              )                              for e in dag.edges                          ],                      ]              except Exception as e:                  _warn(f\"Access to scenario ({data.id if hasattr(data, 'id') else 'No_id'}) failed\", e)            return None        @staticmethod      def get_hash():          return _TaipyBase._HOLDER_PREFIX + \"ScG\"      class _GuiCoreDatanodeAdapter(_TaipyBase):      __INNER_PROPS = [\"name\"]        def get(self):          data = super().get()          if isinstance(data, DataNode):              try:                  datanode = core_get(data.id)                  if datanode:                      owner = core_get(datanode.owner_id) if datanode.owner_id else None                      return [                          datanode.id,                          datanode.storage_type() if hasattr(datanode, \"storage_type\") else \"\",                          datanode.config_id,                          f\"{datanode.last_edit_date}\" if datanode.last_edit_date else \"\",                          f\"{datanode.expiration_date}\" if datanode.last_edit_date else \"\",                          datanode.get_simple_label(),                          datanode.owner_id or \"\",                          owner.get_simple_label() if owner else \"GLOBAL\",                          _EntityType.CYCLE.value                          if isinstance(owner, Cycle)                          else _EntityType.SCENARIO.value                          if isinstance(owner, Scenario)                          else -1,                          [                              (k, f\"{v}\")                              for k, v in datanode._get_user_properties().items()                              if k not in _GuiCoreDatanodeAdapter.__INNER_PROPS                          ],                          datanode._edit_in_progress,                          datanode._editor_id,                          is_readable(datanode),                          is_editable(datanode),                      ]              except Exception as e:                  _warn(f\"Access to datanode ({data.id if hasattr(data, 'id') else 'No_id'}) failed\", e)            return None        @staticmethod      def get_hash():          return _TaipyBase._HOLDER_PREFIX + \"Dn\" "}
{"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 datetime import datetime    from flask import request  from flask_restful import Resource    from taipy.config.common.frequency import Frequency  from taipy.core import Cycle  from taipy.core.cycle._cycle_manager_factory import _CycleManagerFactory  from taipy.core.exceptions.exceptions import NonExistingCycle    from ...commons.to_from_model import _to_model  from ..middlewares._middleware import _middleware  from ..schemas import CycleResponseSchema, CycleSchema    REPOSITORY = \"cycle\"      def _get_or_raise(cycle_id: str) -> None:      manager = _CycleManagerFactory._build_manager()      cycle = manager._get(cycle_id)      if not cycle:          raise NonExistingCycle(cycle_id)      return cycle      class CycleResource(Resource):      \"\"\"Single object resource        ---      get:        tags:          - api        description: |          Returns a `CycleSchema^` representing the unique `Cycle^` identified by the *cycle_id*          given as parameter. If no cycle corresponds to *cycle_id*, a `404` error is returned.            !!! Example                === \"Curl\"                  ```shell                      curl -X GET http://localhost:5000/api/v1/cycles/CYCLE_223894_e0fab919-b50b-4b9f-ac09-52f77474fa7a                  ```                  In this example the REST API is served on port 5000 on localhost. We are using curl command line                  client.                    `CYCLE_223894_e0fab919-b50b-4b9f-ac09-52f77474fa7a` is the value of the *cycle_id* parameter. It                  represents the identifier of the Cycle we want to retrieve.                    In case of success here is an example of the response:                  ``` JSON                  {\"cycle\": {                      \"frequency\": \"Frequency.DAILY\",                      \"creation_date\": \"2022-08-04T17:13:32.797384\",                      \"id\": \"CYCLE_223894_e0fab919-b50b-4b9f-ac09-52f77474fa7a\",                      \"start_date\": \"2022-08-04T00:00:00\",                      \"end_date\": \"2022-08-04T23:59:59.999999\",                      \"name\": \"Frequency.DAILY_2022-08-04T17:13:32.797384\"                  ```                    In case of failure here is an example of the response:                  ``` JSON                  {\"message\": \"Cycle CYCLE_223894_e0fab919-b50b-4b9f-ac09-52f77474fa7a not found.\"}                  ```                === \"Python\"                  This Python example requires the 'requests' package to be installed (`pip install requests`).                  ```python                  import requests                      response = requests.get(\"http://localhost:5000/api/v1/cycles/CYCLE_223894_e019-b50b-4b9f-ac09-527a\")                      print(response)                      print(response.json())                  ```                  `CYCLE_223894_e0fab919-b50b-4b9f-ac09-52f77474fa7a` is the value of the  *cycle_id* parameter. It                  represents the identifier of the Cycle we want to retrieve.                    In case of success here is an output example:                  ```                  <Response [200]>                  {'cycle': {                      'frequency': 'Frequency.DAILY',                      'creation_date': '2022-08-04T17:13:32.797384',                      'id': 'CYCLE_223894_e0fab919-b50b-4b9f-ac09-52f77474fa7a',                      'start_date': '2022-08-04T00:00:00',                      'end_date': '2022-08-04T23:59:59.999999',                      'name': 'Frequency.DAILY_2022-08-04T17:13:32.797384'                  ```                    In case of failure here is an output example:                  ```                  <Response [404]>                  {'message': 'Cycle CYCLE_223894_e0fab919-b50b-4b9f-ac09-52f77474fa7a not found.'}                    ```            !!! Note            When the authorization feature is activated (available in Taipy Enterprise edition only), this endpoint              requires the `TAIPY_READER` role.          parameters:          - in: path            name: cycle_id            schema:              type: string            description: The identifier of the cycle to retrieve.        responses:          200:            content:              application/json:                schema:                  type: object                  properties:                    cycle: CycleSchema          404:            description: No cycle has the *cycle_id* identifier.      delete:        tags:          - api        description: |          Deletes the `Cycle^` identified by the  *cycle_id* given as parameter. If the cycle does not exist,          a 404 error is returned.            !!! Example                === \"Curl\"                  ```shell                      curl -X DELETE http://localhost:5000/api/v1/cycles/CYCLE_223894_e0fab919-b50b-4b9f-ac09-52f77474fa7a                  ```                  In this example the REST API is served on port 5000 on localhost. We are using curl command line                  client.                    `CYCLE_223894_e0fab919-b50b-4b9f-ac09-52f77474fa7a` is the value of the  *cycle_id* parameter. It                  represents the identifier of the Cycle we want to delete.                    In case of success here is an example of the response:                  ``` JSON                  {\"message\": \"Cycle CYCLE_223894_e0fab919-b50b-4b9f-ac09-52f77474fa7a was deleted.\"}                  ```                    In case of failure here is an example of the response:                  ``` JSON                  {\"message\": \"Cycle CYCLE_223894_e0fab919-b50b-4b9f-ac09-52f77474fa7a not found.\"}                  ```                === \"Python\"                  This Python example requires the 'requests' package to be installed (`pip install requests`).                  ```python                  import requests                  response = requests.delete(\"http://localhost:5000/api/v1/cycles/CYCLE_794_ef21-af91-4f41-b6e8-7648eda\")                  print(response)                  print(response.json())                  ```                  `CYCLE_223894_e0fab919-b50b-4b9f-ac09-52f77474fa7a` is the value of the  *cycle_id* parameter. It                  represents the identifier of the Cycle we want to delete.                    In case of success here is an output example:                  ```                  <Response [200]>                  {\"message\": \"Cycle CYCLE_223894_e0fab919-b50b-4b9f-ac09-52f77474fa7a was deleted.\"}                  ```                    In case of failure here is an output example:                  ```                  <Response [404]>                  {'message': 'Cycle CYCLE_223894_e0fab919-b50b-4b9f-ac09-52f77474fa7a not found.'}                    ```            !!! Note              When the authorization feature is activated (available in Taipy Enterprise edition only), this endpoint              requires the `TAIPY_EDITOR` role.          parameters:          - in: path            name: cycle_id            schema:              type: string            description: The id of the cycle to delete.        responses:          200:            content:              application/json:                schema:                  type: object                  properties:                    message:                      type: string                      description: Status message.          404:            description: No cycle has the  *cycle_id* identifier.      \"\"\"        def __init__(self, **kwargs):          self.logger = kwargs.get(\"logger\")        @_middleware      def get(self, cycle_id):          schema = CycleResponseSchema()          cycle = _get_or_raise(cycle_id)          return {\"cycle\": schema.dump(_to_model(REPOSITORY, cycle))}        @_middleware      def delete(self, cycle_id):          manager = _CycleManagerFactory._build_manager()          _get_or_raise(cycle_id)          manager._delete(cycle_id)          return {\"message\": f\"Cycle {cycle_id} was deleted.\"}      class CycleList(Resource):      \"\"\"Creation and get_all        ---      get:        tags:          - api        description: |          Returns a `CycleSchema^` list representing all existing Cycles.            !!! Example                === \"Curl\"                  ```shell                      curl -X GET http://localhost:5000/api/v1/cycles                  ```                  In this example the REST API is served on port 5000 on localhost. We are using curl command line                  client.                    Here is an example of the response:                  ``` JSON                  [                      {                      \"frequency\": \"Frequency.DAILY\",                      \"end_date\": \"2022-08-06T23:59:59.999999\",                      \"creation_date\": \"2022-08-06T15:45:50.223894\",                      \"start_date\": \"2022-08-06T00:00:00\",                      \"id\": \"CYCLE_223894_e0fab919-b50b-4b9f-ac09-52f77474fa7a\",                      \"name\": \"Frequency.DAILY_2022-08-06T15:45:50.223894\"                      }                  ]                  ```                    If there is no cycle, the response is an empty list as follows:                  ``` JSON                  []                  ```                === \"Python\"                  This Python example requires the 'requests' package to be installed (`pip install requests`).                  ```python                  import requests                      response = requests.get(\"http://localhost:5000/api/v1/cycles\")                      print(response)                      print(response.json())                  ```                    In case of success here is an output example:                  ```                  <Response [200]>                  [{                      \"frequency\": \"Frequency.DAILY\",                      \"end_date\": \"2022-08-06T23:59:59.999999\",                      \"creation_date\": \"2022-08-06T15:45:50.223894\",                      \"start_date\": \"2022-08-06T00:00:00\",                      \"id\": \"CYCLE_223894_e0fab919-b50b-4b9f-ac09-52f77474fa7a\",                      \"name\": \"Frequency.DAILY_2022-08-06T15:45:50.223894\"                      }                  ]                  ```                    If there is no cycle, the response is an empty list as follows:                  ```                  <Response [200]>                  []                  ```            !!! Note              When the authorization feature is activated (available in Taipy Enterprise edition only), this endpoint              requires the `TAIPY_READER` role.          responses:          200:            content:              application/json:                schema:                  allOf:                    - type: object                      properties:                        results:                          type: array                          items:                            $ref: '#/components/schemas/CycleSchema'      post:        tags:          - api        description: |          Creates a new cycle from the `CycleSchema^` given in the request body.            !!! Example                === \"Curl\"                  ```shell                      curl -X POST -H \"Content-Type: application/json\"\\                      -d '{\"frequency\": \"DAILY\", \"properties\": {}, \"creation_date\": \"2020-01-01T00:00:00\",\\                      \"start_date\": \"2020-01-01T00:00:00\", \"end_date\": \"2020-01-01T00:00:00\"}'\\                      http://localhost:5000/api/v1/cycles                  ```                  In this example the REST API is served on port 5000 on localhost. We are using curl command line                  client.                    In the curl command line, a `CycleSchema^` is provided as JSON dictionary parameter with the curl                  option -d (--data) to specify the various attributes of the `Cycle^` to create:                  ``` JSON                  {                      \"frequency\": \"DAILY\",                      \"properties\": {},                      \"creation_date\": \"2020-01-01T00:00:00\",                      \"start_date\": \"2020-01-01T00:00:00\",                      \"end_date\": \"2020-01-01T00:00:00\"                  }                  ```                === \"Python\"                  This Python example requires the 'requests' package to be installed (`pip install requests`).                  ```python                  import requests                      cycle_schema = {                          \"frequency\": \"DAILY\",                          \"properties\": {},                          \"creation_date\": \"2020-01-01T00:00:00\",                          \"start_date\": \"2020-01-01T00:00:00\",                          \"end_date\": \"2020-01-01T00:00:00\"                      }                      response = requests.post(\"http://localhost:5000/api/v1/cycles\", json=cycle_schema)                      print(response)                      print(response.json())                  ```                  A `CycleSchema^` is provided as a dictionary to specify the various attributes of the `Cycle^` to                  create.                    Here is the output example:                  ```                  <Response [201]>                  {                      'message': 'Cycle was created.',                      'cycle': {                          'frequency': 'Frequency.DAILY',                          'end_date': '2020-01-01T00:00:00',                          'creation_date': '2020-01-01T00:00:00',                          'start_date': '2020-01-01T00:00:00',                          'id': 'CYCLE_c9cc527f-a8c8-4238-8f31-42166a9817db',                          'name': 'Frequency.DAILY_2020-01-01T00:00:00',                          'properties': {}}}                  ```            !!! Note              When the authorization feature is activated (available in Taipy Enterprise edition only), this endpoint              requires the `TAIPY_EDITOR` role.          requestBody:          required: true          content:            application/json:              schema:                CycleSchema        responses:          201:            content:              application/json:                schema:                  type: object                  properties:                    message:                      type: string                      description: Status message.                    cycle: CycleSchema      \"\"\"        def __init__(self, **kwargs):          self.logger = kwargs.get(\"logger\")        @_middleware      def get(self):          schema = CycleResponseSchema(many=True)          manager = _CycleManagerFactory._build_manager()          cycles = [_to_model(REPOSITORY, cycle) for cycle in manager._get_all()]          return schema.dump(cycles)        @_middleware      def post(self):          schema = CycleResponseSchema()          manager = _CycleManagerFactory._build_manager()            cycle = self.__create_cycle_from_schema(schema.load(request.json))          manager._set(cycle)            return {              \"message\": \"Cycle was created.\",              \"cycle\": schema.dump(_to_model(REPOSITORY, cycle)),          }, 201        def __create_cycle_from_schema(self, cycle_schema: CycleSchema):          return Cycle(              id=cycle_schema.get(\"id\"),              frequency=Frequency(getattr(Frequency, cycle_schema.get(\"frequency\", \"\").upper())),              properties=cycle_schema.get(\"properties\", {}),              creation_date=datetime.fromisoformat(cycle_schema.get(\"creation_date\")),              start_date=datetime.fromisoformat(cycle_schema.get(\"start_date\")),              end_date=datetime.fromisoformat(cycle_schema.get(\"end_date\")),          ) "}
{"text": "from flask import request  from flask_restful import Resource    from taipy.config.config import Config  from taipy.core.exceptions.exceptions import NonExistingTask, NonExistingTaskConfig  from taipy.core.task._task_manager_factory import _TaskManagerFactory    from ...commons.to_from_model import _to_model  from ..exceptions.exceptions import ConfigIdMissingException  from ..middlewares._middleware import _middleware  from ..schemas import TaskSchema      def _get_or_raise(task_id: str):      manager = _TaskManagerFactory._build_manager()      task = manager._get(task_id)      if task is None:          raise NonExistingTask(task_id)      return task      REPOSITORY = \"task\"      class TaskResource(Resource):      \"\"\"Single object resource        ---      get:        tags:          - api        summary: Get a task.        description: |          Return a single task by *task_id*. If the task does not exist, a 404 error is returned.            !!! Note            When the authorization feature is activated (available in the **Enterprise** edition only), this endpoint            requires `TAIPY_READER` role.            Code example:            ```shell            curl -X GET http://localhost:5000/api/v1/tasks/TASK_my_config_75750ed8-4e09-4e00-958d-e352ee426cc9          ```          parameters:          - in: path            name: task_id            schema:              type: string            description: The identifier of the task.        responses:          200:            content:              application/json:                schema:                  type: object                  properties:                    task: TaskSchema          404:            description: No task has the *task_id* identifier.      delete:        tags:          - api        summary: Delete a task.        description: |          Delete a task. If the task does not exist, a 404 error is returned.            !!! Note            When the authorization feature is activated (available in the **Enterprise** edition only), this endpoint            requires `TAIPY_EDITOR` role.            Code example:            ```shell            curl -X DELETE http://localhost:5000/api/v1/tasks/TASK_my_config_75750ed8-4e09-4e00-958d-e352ee426cc9          ```        parameters:          - in: path            name: task_id            schema:              type: string            description: The identifier of the task.        responses:          200:            content:              application/json:                schema:                  type: object                  properties:                    message:                      type: string                      description: Status message.          404:            description: No task has the *task_id* identifier.      \"\"\"        def __init__(self, **kwargs):          self.logger = kwargs.get(\"logger\")        @_middleware      def get(self, task_id):          schema = TaskSchema()          task = _get_or_raise(task_id)          return {\"task\": schema.dump(_to_model(REPOSITORY, task))}        @_middleware      def delete(self, task_id):          manager = _TaskManagerFactory._build_manager()          _get_or_raise(task_id)          manager._delete(task_id)          return {\"message\": f\"Task {task_id} was deleted.\"}      class TaskList(Resource):      \"\"\"Creation and get_all        ---      get:        tags:          - api        summary: Get all tasks.        description: |          Return an array of all tasks.            !!! Note            When the authorization feature is activated (available in the **Enterprise** edition only), this endpoint            requires `TAIPY_READER` role.            Code example:            ```shell            curl -X GET http://localhost:5000/api/v1/tasks          ```          responses:          200:            content:              application/json:                schema:                  allOf:                    - type: object                      properties:                        results:                          type: array                          items:                            $ref: '#/components/schemas/TaskSchema'      post:        tags:          - api        summary: Create a task.        description: |          Create a new task from its *config_id*. If the config does not exist, a 404 error is returned.            !!! Note            When the authorization feature is activated (available in the **Enterprise** edition only), this endpoint            requires `TAIPY_EDITOR` role.            Code example:            ```shell            curl -X POST http://localhost:5000/api/v1/tasks?config_id=my_task_config          ```        parameters:          - in: query            name: config_id            schema:              type: string            description: The identifier of the task configuration.        responses:          201:            content:              application/json:                schema:                  type: object                  properties:                    message:                      type: string                      description: Status message.                    task: TaskSchema      \"\"\"        def __init__(self, **kwargs):          self.logger = kwargs.get(\"logger\")        def fetch_config(self, config_id):          config = Config.tasks.get(config_id)          if not config:              raise NonExistingTaskConfig(config_id)          return config        @_middleware      def get(self):          schema = TaskSchema(many=True)          manager = _TaskManagerFactory._build_manager()          tasks = [_to_model(REPOSITORY, task) for task in manager._get_all()]          return schema.dump(tasks)        @_middleware      def post(self):          args = request.args          config_id = args.get(\"config_id\")            schema = TaskSchema()          manager = _TaskManagerFactory._build_manager()          if not config_id:              raise ConfigIdMissingException            config = self.fetch_config(config_id)          task = manager._bulk_get_or_create([config])[0]            return {              \"message\": \"Task was created.\",              \"task\": schema.dump(_to_model(REPOSITORY, task)),          }, 201      class TaskExecutor(Resource):      \"\"\"Execute a task        ---      post:        tags:          - api        summary: Execute a task.        description: |          Execute a task by *task_id*. If the task does not exist, a 404 error is returned.            !!! Note            When the authorization feature is activated (available in the **Enterprise** edition only), this endpoint            requires `TAIPY_EXECUTOR` role.            Code example:            ```shell            curl -X POST http://localhost:5000/api/v1/tasks/submit/TASK_my_config_75750ed8-4e09-4e00-958d-e352ee426cc9          ```          parameters:          - in: path            name: task_id            schema:              type: string        responses:          204:            content:              application/json:                schema:                  type: object                  properties:                    message:                      type: string                      description: Status message.                    task: TaskSchema          404:            description: No task has the *task_id* identifier.      \"\"\"        def __init__(self, **kwargs):          self.logger = kwargs.get(\"logger\")        @_middleware      def post(self, task_id):          manager = _TaskManagerFactory._build_manager()          task = _get_or_raise(task_id)          manager._orchestrator().submit_task(task)          return {\"message\": f\"Task {task_id} was submitted.\"} "}
{"text": "import uuid  from typing import Optional    from flask import request  from flask_restful import Resource    from taipy.config.config import Config  from taipy.core import Job, JobId  from taipy.core.exceptions.exceptions import NonExistingJob, NonExistingTaskConfig  from taipy.core.job._job_manager_factory import _JobManagerFactory  from taipy.core.task._task_manager_factory import _TaskManagerFactory    from ..exceptions.exceptions import ConfigIdMissingException  from ..middlewares._middleware import _middleware  from ..schemas import JobSchema      def _get_or_raise(job_id: str):      manager = _JobManagerFactory._build_manager()      job = manager._get(job_id)      if job is None:          raise NonExistingJob(job_id)      return job      class JobResource(Resource):      \"\"\"Single object resource        ---      get:        tags:          - api        summary: Get a job.        description: |          Return a single job by *job_id*. If the job does not exist, a 404 error is returned.            !!! Note            When the authorization feature is activated (available in the **Enterprise** edition only), the            endpoint requires `TAIPY_READER` role.            Code example:            ```shell            curl -X GET http://localhost:5000/api/v1/jobs/JOB_my_task_config_75750ed8-4e09-4e00-958d-e352ee426cc9          ```          parameters:          - in: path            name: job_id            schema:              type: string            description: The identifier of the job.        responses:          200:            content:              application/json:                schema:                  type: object                  properties:                    job: JobSchema          404:            description: No job has the *job_id* identifier.      delete:        tags:          - api        summary: Delete a job.        description: |          Delete a job. If the job does not exist, a 404 error is returned.            !!! Note            When the authorization feature is activated (available in the **Enterprise** edition only), the endpoint            requires `TAIPY_EDITOR` role.            Code example:            ```shell            curl -X DELETE http://localhost:5000/api/v1/jobs/JOB_my_task_config_75750ed8-4e09-4e00-958d-e352ee426cc9          ```          parameters:          - in: path            name: job_id            schema:              type: string            description: The identifier of the job.        responses:          200:            content:              application/json:                schema:                  type: object                  properties:                    message:                      type: string                      description: Status message.          404:            description: No job has the *job_id* identifier.      \"\"\"        def __init__(self, **kwargs):          self.logger = kwargs.get(\"logger\")        @_middleware      def get(self, job_id):          schema = JobSchema()          job = _get_or_raise(job_id)          return {\"job\": schema.dump(job)}        @_middleware      def delete(self, job_id):          manager = _JobManagerFactory._build_manager()          job = _get_or_raise(job_id)          manager._delete(job)          return {\"message\": f\"Job {job_id} was deleted.\"}      class JobList(Resource):      \"\"\"Creation and get_all        ---      get:        tags:          - api        summary: Get all jobs.        description: |          Return an array of all jobs.            !!! Note            When the authorization feature is activated (available in the **Enterprise** edition only), the endpoint            requires `TAIPY_READER` role.            Code example:            ```shell            curl -X GET http://localhost:5000/api/v1/jobs          ```          responses:          200:            content:              application/json:                schema:                  allOf:                    - type: object                      properties:                        results:                          type: array                          items:                            $ref: '#/components/schemas/JobSchema'      post:        tags:          - api        summary: Create a job.        description: |          Create a job from a task *config_id*. If the config does not exist, a 404 error is returned.            !!! Note            When the authorization feature is activated (available in the **Enterprise** edition only), the endpoint            requires `TAIPY_EDITOR` role.            Code example:            ```shell            curl -X POST http://localhost:5000/api/v1/jobs?task_id=TASK_my_config_75750ed8-4e09-4e00-958d-e352ee426cc9          ```          parameters:          - in: query            name: task_id            schema:              type: string            description: The identifier of the task configuration.        responses:          201:            content:              application/json:                schema:                  type: object                  properties:                    message:                      type: string                      description: Status message.                    job: JobSchema      \"\"\"        def __init__(self, **kwargs):          self.logger = kwargs.get(\"logger\")        def fetch_config(self, config_id):          config = Config.tasks.get(config_id)          if not config:              raise NonExistingTaskConfig(config_id)          return config        @_middleware      def get(self):          schema = JobSchema(many=True)          manager = _JobManagerFactory._build_manager()          jobs = manager._get_all()          return schema.dump(jobs)        @_middleware      def post(self):          args = request.args          task_config_id = args.get(\"task_id\")            if not task_config_id:              raise ConfigIdMissingException            manager = _JobManagerFactory._build_manager()          schema = JobSchema()          job = self.__create_job_from_schema(task_config_id)          manager._set(job)          return {              \"message\": \"Job was created.\",              \"job\": schema.dump(job),          }, 201        def __create_job_from_schema(self, task_config_id: str) -> Optional[Job]:          task_manager = _TaskManagerFactory._build_manager()          task = task_manager._bulk_get_or_create([self.fetch_config(task_config_id)])[0]          return Job(              id=JobId(f\"JOB_{uuid.uuid4()}\"), task=task, submit_id=f\"SUBMISSION_{uuid.uuid4()}\", submit_entity_id=task.id          )      class JobExecutor(Resource):      \"\"\"Cancel a job        ---      post:        tags:          - api        summary: Cancel a job.        description: |          Cancel a job by *job_id*. If the job does not exist, a 404 error is returned.            !!! Note            When the authorization feature is activated (available in the **Enterprise** edition only), the endpoint            requires `TAIPY_EXECUTOR` role.            Code example:            ```shell            curl -X POST http://localhost:5000/api/v1/jobs/cancel/JOB_my_task_config_75750ed8-4e09-4e00-958d-e352ee426cc9          ```          parameters:          - in: path            name: job_id            schema:              type: string        responses:          204:            content:              application/json:                schema:                  type: object                  properties:                    message:                      type: string                      description: Status message.                    job: JobSchema          404:            description: No job has the *job_id* identifier.      \"\"\"        def __init__(self, **kwargs):          self.logger = kwargs.get(\"logger\")        @_middleware      def post(self, job_id):          manager = _JobManagerFactory._build_manager()          job = _get_or_raise(job_id)          manager._cancel(job)          return {\"message\": f\"Job {job_id} was cancelled.\"} "}
{"text": "  from flask import request  from flask_restful import Resource    from taipy.core.exceptions.exceptions import NonExistingScenario, NonExistingSequence  from taipy.core.scenario._scenario_manager_factory import _ScenarioManagerFactory  from taipy.core.sequence._sequence_manager_factory import _SequenceManagerFactory    from ...commons.to_from_model import _to_model  from ..exceptions.exceptions import ScenarioIdMissingException, SequenceNameMissingException  from ..middlewares._middleware import _middleware  from ..schemas import SequenceResponseSchema      def _get_or_raise(sequence_id: str):      manager = _SequenceManagerFactory._build_manager()      sequence = manager._get(sequence_id)      if sequence is None:          raise NonExistingSequence(sequence_id)      return sequence      REPOSITORY = \"sequence\"      class SequenceResource(Resource):      \"\"\"Single object resource        ---      get:        tags:          - api        summary: Get a sequence.        description: |          Return a single sequence by sequence_id. If the sequence does not exist, a 404 error is returned.            !!! Note            When the authorization feature is activated (available in the **Enterprise** edition only), this endpoint            requires _TAIPY_READER_ role.            Code example:            ```shell            curl -X GET http://localhost:5000/api/v1/sequences/SEQUENCE_my_config_75750ed8-4e09-4e00-958d-e352ee426cc9          ```          parameters:          - in: path            name: sequence_id            schema:              type: string            description: The identifier of the sequence.        responses:          200:            content:              application/json:                schema:                  type: object                  properties:                    sequence: SequenceSchema          404:            description: No sequence has the *sequence_id* identifier.      delete:        tags:          - api        summary: Delete a sequence.        description: |          Delete a sequence. If the sequence does not exist, a 404 error is returned.            !!! Note            When the authorization feature is activated (available in the **Enterprise** edition only), this endpoint            requires _TAIPY_EDITOR_ role.            Code example:            ```shell            curl -X DELETE http://localhost:5000/api/v1/sequences/SEQUENCE_my_config_75750ed8-4e09-4e00-958d-e352ee426cc9          ```          parameters:          - in: path            name: sequence_id            schema:              type: string            description: The identifier of the sequence.        responses:          200:            content:              application/json:                schema:                  type: object                  properties:                    message:                      type: string                      description: Status message.          404:            description: No sequence has the *sequence_id* identifier.      \"\"\"        def __init__(self, **kwargs):          self.logger = kwargs.get(\"logger\")        @_middleware      def get(self, sequence_id):          schema = SequenceResponseSchema()          sequence = _get_or_raise(sequence_id)          return {\"sequence\": schema.dump(_to_model(REPOSITORY, sequence))}        @_middleware      def delete(self, sequence_id):          manager = _SequenceManagerFactory._build_manager()          _get_or_raise(sequence_id)          manager._delete(sequence_id)          return {\"message\": f\"Sequence {sequence_id} was deleted.\"}      class SequenceList(Resource):      \"\"\"Creation and get_all        ---      get:        tags:          - api        summary: Get all sequences.        description: |          Return an array of all sequences.            !!! Note            When the authorization feature is activated (available in the **Enterprise** edition only), this endpoint            requires _TAIPY_READER_ role.            Code example:            ```shell            curl -X GET http://localhost:5000/api/v1/sequences          ```          responses:          200:            content:              application/json:                schema:                  allOf:                    - type: object                      properties:                        results:                          type: array                          items:                            $ref: '#/components/schemas/SequenceSchema'      post:        tags:          - api        summary: Create a sequence.        description: |          Create a sequence from scenario_id, sequence_name and task_ids. If the scenario_id does not exist or          sequence_name is not provided, a 404 error is returned.          !!! Note            When the authorization feature is activated (available in the **Enterprise** edition only), this endpoint            requires _TAIPY_EDITOR_ role.            Code example:            ```shell            curl -X POST --data '{\"scenario_id\": \"SCENARIO_scenario_id\", \"sequence_name\": \"sequence\", \"tasks\": []}' \\\\             http://localhost:5000/api/v1/sequences          ```          parameters:          - in: query            name: scenario_id            schema:              type: string            description: The Scenario the Sequence belongs to.            name: sequence_name            schema:              type: string            description: The name of the Sequence.            name: tasks            schema:              type: list[string]            description: A list of task id of the Sequence.          responses:          201:            content:              application/json:                schema:                  type: object                  properties:                    message:                      type: string                      description: Status message.                    sequence: SequenceSchema      \"\"\"        def __init__(self, **kwargs):          self.logger = kwargs.get(\"logger\")        @_middleware      def get(self):          schema = SequenceResponseSchema(many=True)          manager = _SequenceManagerFactory._build_manager()          sequences = [_to_model(REPOSITORY, sequence) for sequence in manager._get_all()]          return schema.dump(sequences)        @_middleware      def post(self):          sequence_data = request.json          scenario_id = sequence_data.get(\"scenario_id\")          sequence_name = sequence_data.get(\"sequence_name\")          sequence_task_ids = sequence_data.get(\"task_ids\", [])            response_schema = SequenceResponseSchema()          if not scenario_id:              raise ScenarioIdMissingException          if not sequence_name:              raise SequenceNameMissingException            scenario = _ScenarioManagerFactory._build_manager()._get(scenario_id)          if not scenario:              raise NonExistingScenario(scenario_id=scenario_id)            scenario.add_sequence(sequence_name, sequence_task_ids)          sequence = scenario.sequences[sequence_name]            return {              \"message\": \"Sequence was created.\",              \"sequence\": response_schema.dump(_to_model(REPOSITORY, sequence)),          }, 201      class SequenceExecutor(Resource):      \"\"\"Execute a sequence        ---      post:        tags:          - api        summary: Execute a sequence.        description: |          Execute a sequence from sequence_id. If the sequence does not exist, a 404 error is returned.            !!! Note            When the authorization feature is activated (available in the **Enterprise** edition only), This endpoint            requires _TAIPY_EXECUTOR_ role.            Code example:            ```shell            curl -X POST http://localhost:5000/api/v1/sequences/submit/SEQUENCE_my_config_7575-4e09-4e00-958d-e352ee426cc9          ```          parameters:          - in: path            name: sequence_id            schema:              type: string        responses:          204:            content:              application/json:                schema:                  type: object                  properties:                    message:                      type: string                      description: Status message.                    sequence: SequenceSchema          404:              description: No sequence has the *sequence_id* identifier.      \"\"\"        def __init__(self, **kwargs):          self.logger = kwargs.get(\"logger\")        @_middleware      def post(self, sequence_id):          _get_or_raise(sequence_id)          manager = _SequenceManagerFactory._build_manager()          manager._submit(sequence_id)          return {\"message\": f\"Sequence {sequence_id} was submitted.\"} "}
{"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": "from typing import List    import numpy as np  import pandas as pd  from flask import request  from flask_restful import Resource    from taipy.config.config import Config  from taipy.core.data._data_manager_factory import _DataManagerFactory  from taipy.core.data.operator import Operator  from taipy.core.exceptions.exceptions import NonExistingDataNode, NonExistingDataNodeConfig    from ...commons.to_from_model import _to_model  from ..exceptions.exceptions import ConfigIdMissingException  from ..middlewares._middleware import _middleware  from ..schemas import (      CSVDataNodeConfigSchema,      DataNodeFilterSchema,      DataNodeSchema,      ExcelDataNodeConfigSchema,      GenericDataNodeConfigSchema,      InMemoryDataNodeConfigSchema,      JSONDataNodeConfigSchema,      MongoCollectionDataNodeConfigSchema,      PickleDataNodeConfigSchema,      SQLDataNodeConfigSchema,      SQLTableDataNodeConfigSchema,  )    ds_schema_map = {      \"csv\": CSVDataNodeConfigSchema,      \"pickle\": PickleDataNodeConfigSchema,      \"in_memory\": InMemoryDataNodeConfigSchema,      \"sql_table\": SQLTableDataNodeConfigSchema,      \"sql\": SQLDataNodeConfigSchema,      \"mongo_collection\": MongoCollectionDataNodeConfigSchema,      \"excel\": ExcelDataNodeConfigSchema,      \"generic\": GenericDataNodeConfigSchema,      \"json\": JSONDataNodeConfigSchema,  }    REPOSITORY = \"data\"      def _get_or_raise(data_node_id: str) -> None:      manager = _DataManagerFactory._build_manager()      data_node = manager._get(data_node_id)      if not data_node:          raise NonExistingDataNode(data_node_id)      return data_node      class DataNodeResource(Resource):      \"\"\"Single object resource        ---      get:        tags:          - api        description: |          Returns a `DataNodeSchema^` representing the unique `DataNode^` identified by the *datanode_id*          given as parameter. If no data node corresponds to *datanode_id*, a `404` error is returned.            !!! Example                === \"Curl\"                  ```shell                      curl -X GET http://localhost:5000/api/v1/datanodes/DATANODE_hist_cfg_75750ed8-4e09-4e00-958d                      -e352ee426cc9                  ```                  In this example the REST API is served on port 5000 on localhost. We are using curl command line                  client.                    `DATANODE_hist_cfg_75750ed8-4e09-4e00-958d-e352ee426cc9` is the value of the *datanode_id* parameter. It                  represents the identifier of the data node we want to retrieve.                    In case of success here is an example of the response:                  ``` JSON                  {\"datanode\": {                      \"id\": \"DATANODE_historical_data_set_9db1b542-2e45-44e7-8a85-03ef9ead173d\",                      \"config_id\": \"historical_data_set\",                      \"scope\": \"<Scope.SCENARIO: 2>\",                      \"storage_type\": \"csv\",                      \"name\": \"Name of my historical data node\",                      \"owner_id\": \"SCENARIO_my_awesome_scenario_97f3fd67-8556-4c62-9b3b-ef189a599a38\",                      \"last_edit_date\": \"2022-08-10T16:03:40.855082\",                      \"job_ids\": [],                      \"version\": \"latest\",                      \"cacheable\": false,                      \"validity_days\": null,                      \"validity_seconds\": null,                      \"edit_in_progress\": false,                      \"data_node_properties\": {                          \"path\": \"daily-min-temperatures.csv\",                          \"has_header\": true}                      }}                  ```                    In case of failure here is an example of the response:                  ``` JSON                  {\"message\":\"DataNode DATANODE_historical_data_set_9db1b542-2e45-44e7-8a85-03ef9ead173d not found\"}                  ```                === \"Python\"                  This Python example requires the 'requests' package to be installed (`pip install requests`).                  ```python                  import requests                      response = requests.get(                      \"http://localhost:5000/api/v1/datanodes/DATANODE_historical_data_set_9db1b542-2e45-44e7-8a85-03ef9ead173d\")                      print(response)                      print(response.json())                  ```                  `DATANODE_hist_cfg_75750ed8-4e09-4e00-958d-e352ee426cc9` is the value of the *datanode_id* parameter. It                  represents the identifier of the data node we want to retrieve.                    In case of success here is an output example:                  ```                  <Response [200]>                  {\"datanode\": {                      \"id\": \"DATANODE_historical_data_set_9db1b542-2e45-44e7-8a85-03ef9ead173d\",                      \"config_id\": \"historical_data_set\",                      \"scope\": \"<Scope.SCENARIO: 2>\",                      \"storage_type\": \"csv\",                      \"name\": \"Name of my historical data node\",                      \"owner_id\": \"SCENARIO_my_awesome_scenario_97f3fd67-8556-4c62-9b3b-ef189a599a38\",                      \"last_edit_date\": \"2022-08-10T16:03:40.855082\",                      \"job_ids\": [],                      \"version\": \"latest\",                      \"cacheable\": false,                      \"validity_days\": null,                      \"validity_seconds\": null,                      \"edit_in_progress\": false,                      \"data_node_properties\": {                          \"path\": \"daily-min-temperatures.csv\",                          \"has_header\": true}                      }}                  ```                    In case of failure here is an output example:                  ```                  <Response [404]>                  {\"message\":\"DataNode DATANODE_historical_data_set_9db1b542-2e45-44e7-8a85-03ef9ead173d not found\"}                    ```            !!! Note            When the authorization feature is activated (available in Taipy Enterprise edition only), this endpoint              requires the `TAIPY_READER` role.          parameters:          - in: path            name: datanode_id            schema:              type: string            description: The identifier of the data node to retrieve.          responses:          200:            content:              application/json:                schema:                  type: object                  properties:                    datanode: DataNodeSchema          404:            description: No data node has the *datanode_id* identifier.      delete:        tags:          - api        summary: Delete a data node.        description: |          Deletes the `DataNode^` identified by the  *datanode_id* given as parameter. If the data node does not exist,          a 404 error is returned.            !!! Example                === \"Curl\"                  ```shell                      curl -X DELETE \\                      http://localhost:5000/api/v1/datanodes/DATANODE_historical_data_set_9db1b542-2e45-44e7-8a85-03ef9ead173d                  ```                  In this example the REST API is served on port 5000 on localhost. We are using curl command line                  client.                    `DATANODE_historical_data_set_9db1b542-2e45-44e7-8a85-03ef9ead173d` is the value of the                  *datanode_id* parameter. It represents the identifier of the data node we want to delete.                    In case of success here is an example of the response:                  ``` JSON                  {\"msg\": \"datanode DATANODE_historical_data_set_9db1b542-2e45-44e7-8a85-03ef9ead173d deleted\"}                  ```                    In case of failure here is an example of the response:                  ``` JSON                  {\"message\": \"Data node DATANODE_historical_data_set_9db1b542-2e45-44e7-8a85-03ef9ead173d not found.\"}                  ```                === \"Python\"                  This Python example requires the 'requests' package to be installed (`pip install requests`).                  ```python                  import requests                      response = requests.delete(                      \"http://localhost:5000/api/v1/datanodes/DATANODE_historical_data_set_9db1b542-2e45-44e7-8a85-03ef9ead173d\")                      print(response)                      print(response.json())                  ```                  `DATANODE_historical_data_set_9db1b542-2e45-44e7-8a85-03ef9ead173d` is the value of the                  *datanode_id* parameter. It represents the identifier of the Cycle we want to delete.                    In case of success here is an output example:                  ```                  <Response [200]>                  {\"msg\": \"Data node DATANODE_historical_data_set_9db1b542-2e45-44e7-8a85-03ef9ead173d deleted.\"}                  ```                    In case of failure here is an output example:                  ```                  <Response [404]>                  {'message': 'Data node DATANODE_historical_data_set_9db1b542-2e45-44e7-8a85-03ef9ead173d not found.'}                    ```            !!! Note              When the authorization feature is activated (available in Taipy Enterprise edition only), this endpoint              requires the `TAIPY_EDITOR` role.          parameters:          - in: path            name: datanode_id            schema:              type: string            description: The identifier of the data node to delete.        responses:          200:            content:              application/json:                schema:                  type: object                  properties:                    message:                      type: string                      description: Status message.          404:            description: No data node has the *datanode_id* identifier.      \"\"\"        def __init__(self, **kwargs):          self.logger = kwargs.get(\"logger\")        @_middleware      def get(self, datanode_id):          schema = DataNodeSchema()          datanode = _get_or_raise(datanode_id)          return {\"datanode\": schema.dump(_to_model(REPOSITORY, datanode))}        @_middleware      def delete(self, datanode_id):          _get_or_raise(datanode_id)          manager = _DataManagerFactory._build_manager()          manager._delete(datanode_id)          return {\"message\": f\"Data node {datanode_id} was deleted.\"}      class DataNodeList(Resource):      \"\"\"Creation and get_all        ---      get:        tags:          - api        description: |          Returns a `DataNodeSchema^` list representing all existing data nodes.            !!! Example                === \"Curl\"                  ```shell                      curl -X GET http://localhost:5000/api/v1/datanodes                  ```                  In this example the REST API is served on port 5000 on localhost. We are using curl command line                  client.                    Here is an example of the response:                  ``` JSON                  [                      {\"datanode\": {                          \"id\": \"DATANODE_historical_data_set_9db1b542-2e45-44e7-8a85-03ef9ead173d\",                          \"config_id\": \"historical_data_set\",                          \"scope\": \"<Scope.SCENARIO: 2>\",                          \"storage_type\": \"csv\",                          \"name\": \"Name of my historical data node\",                          \"owner_id\": \"SCENARIO_my_awesome_scenario_97f3fd67-8556-4c62-9b3b-ef189a599a38\",                          \"last_edit_date\": \"2022-08-10T16:03:40.855082\",                          \"job_ids\": [],                          \"version\": \"latest\",                          \"cacheable\": false,                          \"validity_days\": null,                          \"validity_seconds\": null,                          \"edit_in_progress\": false,                          \"data_node_properties\": {                              \"path\": \"daily-min-temperatures.csv\",                              \"has_header\": true}                      }}                  ]                  ```                    If there is no data node, the response is an empty list as follows:                  ``` JSON                  []                  ```                === \"Python\"                  This Python example requires the 'requests' package to be installed (`pip install requests`).                  ```python                  import requests                      response = requests.get(\"http://localhost:5000/api/v1/datanodes\")                      print(response)                      print(response.json())                  ```                    In case of success here is an output example:                  ```                  <Response [200]>                  [                      {\"datanode\": {                          \"id\": \"DATANODE_historical_data_set_9db1b542-2e45-44e7-8a85-03ef9ead173d\",                          \"config_id\": \"historical_data_set\",                          \"scope\": \"<Scope.SCENARIO: 2>\",                          \"storage_type\": \"csv\",                          \"name\": \"Name of my historical data node\",                          \"owner_id\": \"SCENARIO_my_awesome_scenario_97f3fd67-8556-4c62-9b3b-ef189a599a38\",                          \"last_edit_date\": \"2022-08-10T16:03:40.855082\",                          \"job_ids\": [],                          \"version\": \"latest\",                          \"cacheable\": false,                          \"validity_days\": null,                          \"validity_seconds\": null,                          \"edit_in_progress\": false,                          \"data_node_properties\": {                              \"path\": \"daily-min-temperatures.csv\",                              \"has_header\": true}                      }}                  ]                  ```                    If there is no data node, the response is an empty list as follows:                  ```                  <Response [200]>                  []                  ```            !!! Note              When the authorization feature is activated (available in Taipy Enterprise edition only), this endpoint              requires the `TAIPY_READER` role.          responses:          200:            content:              application/json:                schema:                  allOf:                    - type: object                      properties:                        results:                          type: array                          items:                            $ref: '#/components/schemas/DataNodeSchema'      post:        tags:          - api        description: |          Creates a new data node from the *config_id* given as parameter.            !!! Example                === \"Curl\"                  ```shell                      curl -X POST http://localhost:5000/api/v1/datanodes?config_id=historical_data_set                  ```                  In this example the REST API is served on port 5000 on localhost. We are using curl command line                  client.                    In this example the *config_id* value (\"historical_data_set\") is given as parameter directly in the                  url. A corresponding `DataNodeConfig^` must exist and must have been configured before.                    Here is the output message example:                  ```                  {\"msg\": \"datanode created\",                  \"datanode\": {                      \"default_path\": null,                      \"path\": \"daily-min-temperatures.csv\",                      \"name\": null,                      \"storage_type\": \"csv\",                      \"scope\": 2,                      \"has_header\": true}                  }                  ```                === \"Python\"                  This Python example requires the 'requests' package to be installed (`pip install requests`).                  ```python                  import requests                      response = requests.post(\"http://localhost:5000/api/v1/datanodes?config_id=historical_data_set\")                      print(response)                      print(response.json())                  ```                  In this example the *config_id* value (\"historical_data_set\") is given as parameter directly in the                  url. A corresponding `DataNodeConfig^` must exist and must have been configured before.                    Here is the output example:                  ```                  <Response [201]>                  {'msg': 'datanode created',                  'datanode': {                      'name': None,                      'scope': 2,                      'path': 'daily-min-temperatures.csv',                      'storage_type': 'csv',                      'default_path': None,                      'has_header': True}}                  ```            !!! Note              When the authorization feature is activated (available in Taipy Enterprise edition only), this endpoint              requires the `TAIPY_EDITOR` role.          parameters:          - in: query            name: config_id            schema:              type: string            description: The identifier of the data node configuration.        responses:          201:            content:              application/json:                schema:                  type: object                  properties:                    message:                      type: string                      description: Status message.                    datanode: DataNodeSchema      \"\"\"        def __init__(self, **kwargs):          self.logger = kwargs.get(\"logger\")        def fetch_config(self, config_id):          config = Config.data_nodes.get(config_id)          if not config:              raise NonExistingDataNodeConfig(config_id)          return config        @_middleware      def get(self):          schema = DataNodeSchema(many=True)          manager = _DataManagerFactory._build_manager()          datanodes = [_to_model(REPOSITORY, datanode) for datanode in manager._get_all()]          return schema.dump(datanodes)        @_middleware      def post(self):          args = request.args          config_id = args.get(\"config_id\")            if not config_id:              raise ConfigIdMissingException            config = self.fetch_config(config_id)          schema = ds_schema_map.get(config.storage_type)()          manager = _DataManagerFactory._build_manager()          manager._bulk_get_or_create({config})          return {              \"message\": \"Data node was created.\",              \"datanode\": schema.dump(config),          }, 201      class DataNodeReader(Resource):      \"\"\"Single object resource        ---      get:        tags:          - api        description: |          Returns the data read from the data node identified by *datanode_id*. If the data node does not exist,          a 404 error is returned.            !!! Example                === \"Curl\"                    ```shell                    curl -X GET \\                    http://localhost:5000/api/v1/datanodes/DATANODE_historical_data_set_9db1b542-2e45-44e7-8a85-03ef9ead173d/read                  ```                    `DATANODE_historical_data_set_9db1b542-2e45-44e7-8a85-03ef9ead173d` is the *datanode_id*                  parameter. It represents the identifier of the data node to read.                    Here is an output example. In this case, the storage type of the data node to read is `csv`,                  and no exposed type is specified. The data is exposed as a list of dictionaries, each dictionary                  representing a raw of the csv file.                  ```                  {\"data\": [                      {\"Date\": \"1981-01-01\", \"Temp\": 20.7}, {\"Date\": \"1981-01-02\", \"Temp\": 17.9},                      {\"Date\": \"1981-01-03\", \"Temp\": 18.8}, {\"Date\": \"1981-01-04\", \"Temp\": 14.6},                      {\"Date\": \"1981-01-05\", \"Temp\": 15.8}, {\"Date\": \"1981-01-06\", \"Temp\": 15.8},                      {\"Date\": \"1981-01-07\", \"Temp\": 15.8}                      ]}                  ```                === \"Python\"                  This Python example requires the 'requests' package to be installed (`pip install requests`).                  ```python                  import requests                      response = requests.get(                      \"http://localhost:5000/api/v1/datanodes/DATANODE_historical_data_set_9db1b542-2e45-44e7-8a85-03ef9ead173d/read\")                      print(response)                      print(response.json())                  ```                  `DATANODE_historical_data_set_9db1b542-2e45-44e7-8a85-03ef9ead173d` is the *datanode_id*                  parameter. It represents the identifier of the data node to read.                    Here is an output example. In this case, the storage type of the data node to read is `csv`,                  and no exposed type is specified. The data is exposed as a list of dictionaries, each dictionary                  representing a raw of the csv file.                  ```                  {\"data\": [                      {\"Date\": \"1981-01-01\", \"Temp\": 20.7}, {\"Date\": \"1981-01-02\", \"Temp\": 17.9},                      {\"Date\": \"1981-01-03\", \"Temp\": 18.8}, {\"Date\": \"1981-01-04\", \"Temp\": 14.6},                      {\"Date\": \"1981-01-05\", \"Temp\": 15.8}, {\"Date\": \"1981-01-06\", \"Temp\": 15.8},                      {\"Date\": \"1981-01-07\", \"Temp\": 15.8}                      ]}                  ```            !!! Note              When the authorization feature is activated (available in Taipy Enterprise edition only), this endpoint              requires the `TAIPY_READER` role.          parameters:          - in: path            name: datanode_id            schema:              type: string            description: The id of the data node to read.        requestBody:          content:            application/json:              schema:                DataNodeFilterSchema        responses:          200:            content:              application/json:                schema:                  type: object                  properties:                    data:                      type: Any                      description: The data read from the data node.          404:            description: No data node has the *datanode_id* identifier.      \"\"\"        def __init__(self, **kwargs):          self.logger = kwargs.get(\"logger\")        def __make_operators(self, schema: DataNodeFilterSchema) -> List:          return [              (                  x.get(\"key\"),                  x.get(\"value\"),                  Operator(getattr(Operator, x.get(\"operator\", \"\").upper())),              )              for x in schema.get(\"operators\")          ]        @_middleware      def get(self, datanode_id):          schema = DataNodeFilterSchema()          data = request.get_json(silent=True)          data_node = _get_or_raise(datanode_id)          operators = self.__make_operators(schema.load(data)) if data else []          data = data_node.filter(operators)          if isinstance(data, pd.DataFrame):              data = data.to_dict(orient=\"records\")          elif isinstance(data, np.ndarray):              data = list(data)          return {\"data\": data}      class DataNodeWriter(Resource):      \"\"\"Single object resource        ---      put:        tags:          - api        summary: Write into a data node.        description: |          Write data from request body into a data node by *datanode_id*. If the data node does not exist, a 404 error is          returned.            !!! Note            When the authorization feature is activated (available in the **Enterprise** edition only), this endpoint            requires `TAIPY_EDITOR` role.            Code example:            ```shell            curl -X PUT -d '[{\"path\": \"/abc\", \"type\": 1}, {\"path\": \"/def\", \"type\": 2}]' \\\\            -H 'Content-Type: application/json' \\\\             http://localhost:5000/api/v1/datanodes/DATANODE_my_config_75750ed8-4e09-4e00-958d-e352ee426cc9/write          ```          parameters:          - in: path            name: datanode_id            schema:              type: string        requestBody:          content:            application/json:              schema:                Any        responses:          200:            content:              application/json:                schema:                  type: object                  properties:                    message:                      type: string                      description: Status message.          404:            description: No data node has the *datanode_id* identifier.      \"\"\"        def __init__(self, **kwargs):          self.logger = kwargs.get(\"logger\")        @_middleware      def put(self, datanode_id):          data = request.json          data_node = _get_or_raise(datanode_id)          data_node.write(data)          return {\"message\": f\"Data node {datanode_id} was successfully written.\"} "}
{"text": "from flask import request  from flask_restful import Resource    from taipy.config.config import Config  from taipy.core.exceptions.exceptions import NonExistingScenario, NonExistingScenarioConfig  from taipy.core.scenario._scenario_manager_factory import _ScenarioManagerFactory    from ...commons.to_from_model import _to_model  from ..exceptions.exceptions import ConfigIdMissingException  from ..middlewares._middleware import _middleware  from ..schemas import ScenarioResponseSchema      def _get_or_raise(scenario_id: str):      manager = _ScenarioManagerFactory._build_manager()      scenario = manager._get(scenario_id)      if scenario is None:          raise NonExistingScenario(scenario_id)      return scenario      REPOSITORY = \"scenario\"      class ScenarioResource(Resource):      \"\"\"Single object resource        ---      get:        tags:          - api        description: |          Returns a `ScenarioSchema^` representing the unique scenario identified by *scenario_id*. If no scenario          corresponds to *scenario_id*, a `404` error is returned.            !!! Example                === \"Curl\"                  ```shell                      curl -X GET http://localhost:5000/api/v1/scenarios/SCENARIO_63cb358d-5834-4d73-84e4-a6343df5e08c                  ```                  In this example the REST API is served on port 5000 on localhost. We are using curl command line                  client.                    `SCENARIO_63cb358d-5834-4d73-84e4-a6343df5e08c` is the value of the *scenario_id* parameter. It                  represents the identifier of the Scenario we want to retrieve.                    In case of success here is an example of the response:                  ``` JSON                  {\"scenario\": {                      \"cycle\": \"CYCLE_863418_fdd1499a-8925-4540-93fd-9dbfb4f0846d\",                      \"id\": \"SCENARIO_63cb358d-5834-4d73-84e4-a6343df5e08c\",                      \"properties\": {},                      \"tags\": [],                      \"version\": \"latest\",                      \"sequences\": [                          \"SEQUENCE_mean_baseline_5af317c9-34df-48b4-8a8a-bf4007e1de99\",                          \"SEQUENCE_arima_90aef6b9-8922-4a0c-b625-b2c6f3d19fa4\"],                      \"subscribers\": [],                      \"creation_date\": \"2022-08-15T19:21:01.871587\",                      \"primary_scenario\": true}}                  ```                    In case of failure here is an example of the response:                  ``` JSON                  {\"message\": \"SCENARIO_63cb358d-5834-4d73-84e4-a6343df5e08c not found.\"}                  ```                === \"Python\"                  This Python example requires the 'requests' package to be installed (`pip install requests`).                  ```python                  import requests                      response = requests.get(                      \"http://localhost:5000/api/v1/scenarios/SCENARIO_63cb358d-5834-4d73-84e4-a6343df5e08c\")                      print(response)                      print(response.json())                  ```                  `SCENARIO_63cb358d-5834-4d73-84e4-a6343df5e08c` is the value of the  *scenario_id* parameter. It                  represents the identifier of the Cycle we want to retrieve.                    In case of success here is an output example:                  ```                  <Response [200]>                  {\"scenario\": {                      \"cycle\": \"CYCLE_863418_fdd1499a-8925-4540-93fd-9dbfb4f0846d\",                      \"id\": \"SCENARIO_63cb358d-5834-4d73-84e4-a6343df5e08c\",                      \"properties\": {},                      \"tags\": [],                      \"version\": \"latest\",                      \"sequences\": [                          \"SEQUENCE_mean_baseline_5af317c9-34df-48b4-8a8a-bf4007e1de99\",                          \"SEQUENCE_arima_90aef6b9-8922-4a0c-b625-b2c6f3d19fa4\"],                      \"subscribers\": [],                      \"creation_date\": \"2022-08-15T19:21:01.871587\",                      \"primary_scenario\": true}}                  ```                    In case of failure here is an output example:                  ```                  <Response [404]>                  {'message': 'Scenario SCENARIO_63cb358d-5834-4d73-84e4-a6343df5e08c not found.'}                    ```            !!! Note              When the authorization feature is activated (available in Taipy Enterprise edition only), this endpoint              requires the `TAIPY_READER` role.            parameters:          - in: path            name: scenario_id            schema:              type: string            description: The identifier of the scenario to retrieve.        responses:          200:            content:              application/json:                schema:                  type: object                  properties:                    scenario: ScenarioSchema          404:            description: No scenario has the *scenario_id* identifier.      delete:        tags:          - api        description: |          Delete the `Scenario^` scenario identified by the *scenario_id* given as parameter. If the scenario does not          exist, a 404 error is returned.            !!! Example                === \"Curl\"                  ```shell                      curl -X DELETE http://localhost:5000/api/v1/scenarios/SCENARIO_63cb358d-5834-4d73-84e4-a6343df5e08c                  ```                  In this example the REST API is served on port 5000 on localhost. We are using curl command line                  client.                    `SCENARIO_63cb358d-5834-4d73-84e4-a6343df5e08c` is the value of the  *scenario_id* parameter. It                  represents the identifier of the scenario we want to delete.                    In case of success here is an example of the response:                  ``` JSON                  {\"msg\": \"Scenario SCENARIO_63cb358d-5834-4d73-84e4-a6343df5e08c deleted.\"}                  ```                    In case of failure here is an example of the response:                  ``` JSON                  {\"message\": \"Scenario SCENARIO_63cb358d-5834-4d73-84e4-a6343df5e08c not found.\"}                  ```                === \"Python\"                  This Python example requires the 'requests' package to be installed (`pip install requests`).                  ```python                  import requests                      response = requests.delete(                      \"http://localhost:5000/api/v1/scenarios/SCENARIO_63cb358d-5834-4d73-84e4-a6343df5e08c\")                      print(response)                      print(response.json())                  ```                  `SCENARIO_63cb358d-5834-4d73-84e4-a6343df5e08c` is the value of the *scenario_id* parameter. It                  represents the identifier of the Scenario we want to delete.                    In case of success here is an output example:                  ```                  <Response [200]>                  {\"msg\": \"Scenario SCENARIO_63cb358d-5834-4d73-84e4-a6343df5e08c deleted.\"}                  ```                    In case of failure here is an output example:                  ```                  <Response [404]>                  {'message': 'Scenario SCENARIO_63cb358d-5834-4d73-84e4-a6343df5e08c not found.'}                    ```            !!! Note              When the authorization feature is activated (available in Taipy Enterprise edition only), this endpoint              requires the `TAIPY_EDITOR` role.          parameters:          - in: path            name: scenario_id            schema:              type: string            description: The identifier of the scenario to delete.        responses:          200:            content:              application/json:                schema:                  type: object                  properties:                    message:                      type: string                      description: Status message.          404:            description: No scenario has the *scenario_id* identifier.      \"\"\"        def __init__(self, **kwargs):          self.logger = kwargs.get(\"logger\")        @_middleware      def get(self, scenario_id):          schema = ScenarioResponseSchema()          scenario = _get_or_raise(scenario_id)          return {\"scenario\": schema.dump(_to_model(REPOSITORY, scenario))}        @_middleware      def delete(self, scenario_id):          manager = _ScenarioManagerFactory._build_manager()          _get_or_raise(scenario_id)          manager._delete(scenario_id)          return {\"message\": f\"Scenario {scenario_id} was deleted.\"}      class ScenarioList(Resource):      \"\"\"Creation and get_all        ---      get:        tags:          - api        summary: Get all scenarios.        description: |          Returns a `ScenarioSchema^` list representing all existing Scenarios.            !!! Example                === \"Curl\"                  ```shell                      curl -X GET http://localhost:5000/api/v1/scenarios                  ```                  In this example the REST API is served on port 5000 on localhost. We are using curl command line                  client.                    Here is an example of the response:                  ``` JSON                  [{                      \"cycle\": \"CYCLE_863418_fdd1499a-8925-4540-93fd-9dbfb4f0846d\",                      \"id\": \"SCENARIO_63cb358d-5834-4d73-84e4-a6343df5e08c\",                      \"properties\": {},                      \"tags\": [],                      \"version\": \"latest\",                      \"sequences\": [                          \"SEQUENCE_mean_baseline_5af317c9-34df-48b4-8a8a-bf4007e1de99\",                          \"SEQUENCE_arima_90aef6b9-8922-4a0c-b625-b2c6f3d19fa4\"],                      \"subscribers\": [],                      \"creation_date\": \"2022-08-15T19:21:01.871587\",                      \"primary_scenario\": true                      }                  ]                  ```                    If there is no scenario, the response is an empty list as follows:                  ``` JSON                  []                  ```                === \"Python\"                  This Python example requires the 'requests' package to be installed (`pip install requests`).                  ```python                  import requests                      response = requests.get(\"http://localhost:5000/api/v1/scenarios\")                      print(response)                      print(response.json())                  ```                    In case of success here is an output example:                  ```                  <Response [200]>                  [{                      \"cycle\": \"CYCLE_863418_fdd1499a-8925-4540-93fd-9dbfb4f0846d\",                      \"id\": \"SCENARIO_63cb358d-5834-4d73-84e4-a6343df5e08c\",                      \"properties\": {},                      \"tags\": [],                      \"version\": \"latest\",                      \"sequences\": [                          \"SEQUENCE_mean_baseline_5af317c9-34df-48b4-8a8a-bf4007e1de99\",                          \"SEQUENCE_arima_90aef6b9-8922-4a0c-b625-b2c6f3d19fa4\"],                      \"subscribers\": [],                      \"creation_date\": \"2022-08-15T19:21:01.871587\",                      \"primary_scenario\": true                      }                  ]                  ```                    If there is no scenario, the response is an empty list as follows:                  ```                  <Response [200]>                  []                  ```            !!! Note              When the authorization feature is activated (available in Taipy Enterprise edition only), this endpoint              requires the `TAIPY_READER` role.          responses:          200:            content:              application/json:                schema:                  allOf:                    - type: object                      properties:                        results:                          type: array                          items:                            $ref: '#/components/schemas/ScenarioSchema'      post:        tags:          - api        description: |          Creates a new scenario from the  *config_id*. If the config does not exist, a 404 error is returned.            !!! Example                === \"Curl\"                  ```shell                      curl -X POST http://localhost:5000/api/v1/scenarios?config_id=my_scenario_config                  ```                  In this example the REST API is served on port 5000 on localhost. We are using curl command line                  client.                    In this example the *config_id* value (\"my_scenario_config\") is given as parameter directly in the                  url. A corresponding `ScenarioConfig^` must exist and must have been configured before.                    Here is the output message example:                  ```                  {\"msg\": \"scenario created.\",                  \"scenario\": {                      \"cycle\": \"CYCLE_863418_fdd1499a-8925-4540-93fd-9dbfb4f0846d\",                      \"id\": \"SCENARIO_63cb358d-5834-4d73-84e4-a6343df5e08c\",                      \"properties\": {},                      \"tags\": [],                      \"version\": \"latest\",                      \"sequences\": [                          \"SEQUENCE_mean_baseline_5af317c9-34df-48b4-8a8a-bf4007e1de99\",                          \"SEQUENCE_arima_90aef6b9-8922-4a0c-b625-b2c6f3d19fa4\"],                      \"subscribers\": [],                      \"creation_date\": \"2022-08-15T19:21:01.871587\",                      \"primary_scenario\": true}                  }                  ```                === \"Python\"                  This Python example requires the 'requests' package to be installed (`pip install requests`).                  ```python                  import requests                      response = requests.post(\"http://localhost:5000/api/v1/scenarios?config_id=my_scenario_config\")                      print(response)                      print(response.json())                  ```                  In this example the *config_id* value (\"my_scenario_config\") is given as parameter directly in the                  url. A corresponding `ScenarioConfig^` must exist and must have been configured before.                    Here is the output example:                  ```                  <Response [201]>                  {\"msg\": \"scenario created.\",                  \"scenario\": {                      \"cycle\": \"CYCLE_863418_fdd1499a-8925-4540-93fd-9dbfb4f0846d\",                      \"id\": \"SCENARIO_63cb358d-5834-4d73-84e4-a6343df5e08c\",                      \"properties\": {},                      \"tags\": [],                      \"version\": \"latest\",                      \"sequences\": [                          \"SEQUENCE_mean_baseline_5af317c9-34df-48b4-8a8a-bf4007e1de99\",                          \"SEQUENCE_arima_90aef6b9-8922-4a0c-b625-b2c6f3d19fa4\"],                      \"subscribers\": [],                      \"creation_date\": \"2022-08-15T19:21:01.871587\",                      \"primary_scenario\": true}                  }                  ```            !!! Note              When the authorization feature is activated (available in Taipy Enterprise edition only), this endpoint              requires the `TAIPY_EDITOR` role.          parameters:          - in: query            name: config_id            schema:              type: string            description: The identifier of the scenario configuration.        responses:          201:            content:              application/json:                schema:                  type: object                  properties:                    message:                      type: string                      description: Status message.                    scenario: ScenarioSchema      \"\"\"        def __init__(self, **kwargs):          self.logger = kwargs.get(\"logger\")        def fetch_config(self, config_id):          config = Config.scenarios.get(config_id)          if not config:              raise NonExistingScenarioConfig(config_id)          return config        @_middleware      def get(self):          schema = ScenarioResponseSchema(many=True)          manager = _ScenarioManagerFactory._build_manager()          scenarios = [_to_model(REPOSITORY, scenario) for scenario in manager._get_all()]          return schema.dump(scenarios)        @_middleware      def post(self):          args = request.args          config_id = args.get(\"config_id\")            response_schema = ScenarioResponseSchema()          manager = _ScenarioManagerFactory._build_manager()            if not config_id:              raise ConfigIdMissingException            config = self.fetch_config(config_id)          scenario = manager._create(config)            return {              \"message\": \"Scenario was created.\",              \"scenario\": response_schema.dump(_to_model(REPOSITORY, scenario)),          }, 201      class ScenarioExecutor(Resource):      \"\"\"Execute a scenario        ---      post:        tags:          - api        description: |          Executes a scenario by *scenario_id*. If the scenario does not exist, a 404 error is returned.            !!! Example                === \"Curl\"                  ```shell                      curl -X POST http://localhost:5000/api/v1/scenarios/submit/SCENARIO_658d-5834-4d73-84e4-a6343df5e08c                  ```                  In this example the REST API is served on port 5000 on localhost. We are using curl command line                  client.                    `SCENARIO_63cb358d-5834-4d73-84e4-a6343df5e08c` is the value of the *scenario_id* parameter. It                  represents the identifier of the Scenario we want to submit.                    Here is the output message example:                  ```                  {\"message\": \"Executed scenario SCENARIO_63cb358d-5834-4d73-84e4-a6343df5e08c.\"}                  ```                === \"Python\"                  This Python example requires the 'requests' package to be installed (`pip install requests`).                  ```python                      import requests                          response = requests.post(                          \"http://localhost:5000/api/v1/scenarios/submit/SCENARIO_63cb358d-5834-4d73-84e4-a6343df5e08c\")                          print(response)                          print(response.json())                  ```                  `SCENARIO_63cb358d-5834-4d73-84e4-a6343df5e08c` is the value of the *scenario_id* parameter. It                  represents the identifier of the Scenario we want to submit.                    Here is the output example:                  ```                  <Response [202]>                  {\"message\": \"Executed scenario SCENARIO_63cb358d-5834-4d73-84e4-a6343df5e08c.\"}                  ```            !!! Note              When the authorization feature is activated (available in Taipy Enterprise edition only), this endpoint              requires the `TAIPY_EXECUTOR` role.          parameters:          - in: path            name: scenario_id            schema:              type: string            description: The identifier of the scenario to submit.        responses:          202:            content:              application/json:                schema:                  type: object                  properties:                    message:                      type: string                      description: Status message.                    scenario: ScenarioSchema          404:            description: No scenario has the *scenario_id* identifier.      \"\"\"        def __init__(self, **kwargs):          self.logger = kwargs.get(\"logger\")        @_middleware      def post(self, scenario_id):          _get_or_raise(scenario_id)          manager = _ScenarioManagerFactory._build_manager()          manager._submit(scenario_id)          return {\"message\": f\"Scenario {scenario_id} was submitted.\"} "}
{"text": "#  # Licensed under the Apache License, Version 2.0 (the \"License\"); you may not use this file except in compliance with  # the License. You may obtain a copy of the License at  #  #        http://www.apache.org/licenses/LICENSE-2.0  #  # Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on  # an \"AS IS\" BASIS, WITHOUT 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": "import os  import re  import shutil  import subprocess    from _fetch_source_file import CLI, GitContext, read_doc_version_from_mkdocs_yml_template_file    # Assuming this script is in taipy-doc/tools  TOOLS_PATH = os.path.dirname(os.path.abspath(__file__))  ROOT_DIR = os.path.dirname(TOOLS_PATH)  TOP_DIR = os.path.dirname(ROOT_DIR)    # Where all the code from all directories/repositories is copied  DEST_DIR_NAME = \"taipy\"    REPOS = [\"config\", \"core\", \"gui\", \"rest\", \"taipy\", \"templates\"]  PRIVATE_REPOS = [\"auth\", \"enterprise\"]    OPTIONAL_PACKAGES = {      \"gui\": [\"pyarrow\", \"pyngrok\", \"python-magic\", \"python-magic-bin\"]  }    args = CLI(os.path.basename(__file__), REPOS).get_args()    # Read version from mkdocs.yml template  mkdocs_yml_version = read_doc_version_from_mkdocs_yml_template_file(ROOT_DIR)    # Gather version information for each repository  repo_defs = {repo if repo == \"taipy\" else f\"taipy-{repo}\": {\"version\": \"local\", \"tag\": None} for repo in REPOS + PRIVATE_REPOS}  CATCH_VERSION_RE = re.compile(r\"(^\\d+\\.\\d+?)(?:(\\.\\d+)(\\..*)?)?|develop|local$\")  for version in args.version:      repo = None      if version == \"MKDOCS\":          version = mkdocs_yml_version          tag = None      else:          try:              colon = version.index(\":\")              repo = version[:colon]              if not repo.startswith(\"taipy\"):                  repo = f\"taipy-{repo}\"              version = version[colon + 1:]          except ValueError as e:              pass          version_match = CATCH_VERSION_RE.fullmatch(version)          if not version_match:              raise ValueError(f\"'{version}' is not a valid version.\")          tag = None          if version_match.group(1):              version = version_match.group(1)              if version_match.group(2):                  tag = version + version_match.group(2)                  if version_match.group(3):                      tag += version_match.group(3)      if repo:          if not repo in repo_defs:              raise ValueError(f\"'{repo}' is not a valid repository name.\")          repo_defs[repo][\"version\"] = version          repo_defs[repo][\"tag\"] = tag      else:          for repo in repo_defs.keys():              repo_defs[repo][\"version\"] = version              repo_defs[repo][\"tag\"] = tag    # Test git, if needed  git_command = \"git\"  if args.no_pull and all(v[\"version\"] == \"local\" for v in repo_defs.values()):      git_command = None  else:      git_path = shutil.which(git_command)      if git_path is None or subprocess.run(f\"\\\"{git_path}\\\" --version\", shell=True, capture_output=True) is None:          raise IOError(f\"Couldn't find command \\\"{git_command}\\\"\")      git_command = git_path    # Check that directory, branches and tags exist for each repository  github_token = os.environ.get(\"GITHUB_TOKEN\", \"\")  if github_token:      github_token += \"@\"  github_root = f\"https://{github_token}github.com/Avaiga/\"  for repo in repo_defs.keys():      version = repo_defs[repo][\"version\"]      if version == \"local\":          repo_path = os.path.join(TOP_DIR, repo)          repo_defs[repo][\"path\"] = repo_path          if not os.path.isdir(repo_path):              if repo in PRIVATE_REPOS:                  repo_defs[repo][\"skip\"] = True              else:                  raise IOError(f\"Repository '{repo}' must be cloned in \\\"{TOP_DIR}\\\".\")      elif version == \"develop\":          with GitContext(repo, PRIVATE_REPOS):              cmd = subprocess.run(f\"\\\"{git_path}\\\" ls-remote -q -h {github_root}{repo}.git\", shell=True, capture_output=True,                                   text=True)              if cmd.returncode:                  if repo in PRIVATE_REPOS:                      repo_defs[repo][\"skip\"] = True                      continue                  else:                      raise SystemError(f\"Problem with {repo}:\\nOutput: {cmd.stdout}\\nError: {cmd.stderr}\")      else:          with GitContext(repo, PRIVATE_REPOS):              cmd = subprocess.run(f\"\\\"{git_path}\\\" ls-remote --exit-code --heads {github_root}{repo}.git\", shell=True,                                   capture_output=True, text=True)              if cmd.returncode:                  if repo in PRIVATE_REPOS:                      repo_defs[repo][\"skip\"] = True                      continue                  else:                      raise SystemError(f\"Couldn't query branches from {github_root}{repo}.\")              if not f\"release/{version}\\n\" in cmd.stdout:                  raise ValueError(f\"No branch 'release/{version}' in repository '{repo}'.\")              tag = repo_defs[repo][\"tag\"]              if tag:                  cmd = subprocess.run(f\"\\\"{git_path}\\\" ls-remote -t --refs {github_root}{repo}.git\", shell=True,                                       capture_output=True, text=True)                  if not f\"refs/tags/{tag}\\n\" in cmd.stdout:                      raise ValueError(f\"No tag '{tag}' in repository '{repo}'.\")    if args.check:      print(f\"Fetch should perform properly with the following settings:\")      for repo in repo_defs.keys():          if not repo_defs[repo].get(\"skip\", False):              version = repo_defs[repo]['version']              version = \"(local)\" if version == \"local\" else f\"branch:{version if version == 'develop' else f'release/{version}'}\"              tag = repo_defs[repo][\"tag\"]              if tag:                  version += f\" tag:{tag}\"              print(f\"- {repo} {version}\")      exit(0)    DEST_DIR = os.path.join(ROOT_DIR, DEST_DIR_NAME)      def safe_rmtree(dir: str):      if os.path.isdir(dir):          shutil.rmtree(dir)      # Remove target 'taipy' directory  safe_rmtree(DEST_DIR)  os.makedirs(DEST_DIR)  # If a leftover of a previous failed run  safe_rmtree(os.path.join(TOOLS_PATH, DEST_DIR_NAME))    pipfile_packages = {}  PIPFILE_PACKAGE_RE = re.compile(r\"(.*?)\\s?=\\s?(.*)\")      # Fetch files  def move_files(repo: str, src_path: str):      # Read Pipfile dependency packages      pipfile_path = os.path.join(src_path, \"Pipfile\")      if os.path.isfile(pipfile_path):          reading_packages = False          repo_optional_packages = OPTIONAL_PACKAGES.get(repo, None)          with open(pipfile_path, \"r\") as pipfile:              while True:                  line = pipfile.readline()                  if str(line) == \"\" or (reading_packages and (not line.strip() or line[0] == \"[\")):                      break                  line = line.strip()                  if line == \"[packages]\":                      reading_packages = True                  elif reading_packages:                      match = PIPFILE_PACKAGE_RE.fullmatch(line)                      if match and not match.group(1).startswith(\"taipy\"):                          package = match.group(1).lower()                          version = match.group(2)                          if repo_optional_packages is None or not package in repo_optional_packages:                              if package in pipfile_packages:                                  versions = pipfile_packages[package]                                  if version in versions:                                      versions[version].append(repo)                                  else:                                      versions[version] = [repo]                              else:                                  pipfile_packages[package] = {version: [repo]}      # Copy relevant files for doc generation      if repo.startswith(\"taipy-getting-started\"):          gs_dir = os.path.join(ROOT_DIR, \"docs\", \"getting_started\", repo[6:])          # safe_rmtree(os.path.join(gs_dir, \"src\"))          for step_dir in [step_dir for step_dir in os.listdir(gs_dir) if                           step_dir.startswith(\"step_\") and os.path.isdir(os.path.join(gs_dir, step_dir))]:              safe_rmtree(os.path.join(gs_dir, step_dir))          for step_dir in [step_dir for step_dir in os.listdir(src_path) if                           step_dir.startswith(\"step_\") and os.path.isdir(os.path.join(src_path, step_dir))]:              shutil.copytree(os.path.join(src_path, step_dir), os.path.join(gs_dir, step_dir))          safe_rmtree(os.path.join(gs_dir, \"src\"))          shutil.copytree(os.path.join(src_path, \"src\"), os.path.join(gs_dir, \"src\"))          shutil.copy(os.path.join(src_path, \"index.md\"), os.path.join(gs_dir, \"index.md\"))          saved_dir = os.getcwd()          os.chdir(os.path.join(ROOT_DIR, \"docs\", \"getting_started\", repo[6:]))          subprocess.run(f\"python {os.path.join(src_path, 'generate_notebook.py')}\",                         shell=True,                         capture_output=True,                         text=True)          os.chdir(saved_dir)      else:          tmp_dir = os.path.join(ROOT_DIR, f\"{repo}.tmp\")          safe_rmtree(tmp_dir)          gui_dir = os.path.join(ROOT_DIR, f\"gui\") if repo == \"taipy-gui\" else None          if repo == \"taipy-gui\" and os.path.isdir(gui_dir):              if os.path.isdir(os.path.join(gui_dir, \"node_modules\")):                  shutil.move(os.path.join(gui_dir, \"node_modules\"), os.path.join(ROOT_DIR, f\"gui_node_modules\"))              shutil.rmtree(gui_dir)          try:              def copy_source(src_path: str, repo: str):                  def copy(item: str, src: str, dst: str, rel_path: str):                      full_src = os.path.join(src, item)                      full_dst = os.path.join(dst, item)                      if os.path.isdir(full_src):                          if item in [\"__pycache__\", \"node_modules\"]:                              return                          if not os.path.isdir(full_dst):                              os.makedirs(full_dst)                          rel_path = f\"{rel_path}/{item}\"                          for sub_item in os.listdir(full_src):                              copy(sub_item, full_src, full_dst, rel_path)                      elif any(item.endswith(ext) for ext in [\".py\", \".pyi\", \".json\", \".ipynb\"]):                          if os.path.isfile(full_dst): # File exists - compare                              with open(full_src, \"r\") as f:                                  src = f.read()                              with open(full_dst, \"r\") as f:                                  dst = f.read()                              if src != dst:                                  raise FileExistsError(f\"File {rel_path}/{item} already exists and is different (copying repository {repo})\")                          else:                              shutil.copy(full_src, full_dst)                  dest_path = os.path.join(ROOT_DIR, \"taipy\")                  if not os.path.exists(dest_path):                      os.makedirs(dest_path)                  src_path = os.path.join(src_path, \"src\", \"taipy\")                  for item in os.listdir(src_path):                      copy(item, src_path, dest_path, \"\")              copy_source(src_path, repo)                if gui_dir:                  if not os.path.isdir(gui_dir):                      os.mkdir(gui_dir)                  src_gui_dir = os.path.join(src_path, \"gui\")                  shutil.copytree(os.path.join(src_gui_dir, \"src\"), os.path.join(gui_dir, \"src\"))                  for f in [f for f in os.listdir(src_gui_dir) if f.endswith(\".md\") or f.endswith(\".json\")]:                      shutil.copy(os.path.join(src_gui_dir, f), os.path.join(gui_dir, f))                  if os.path.isdir(os.path.join(ROOT_DIR, \"gui_node_modules\")):                      shutil.move(os.path.join(ROOT_DIR, \"gui_node_modules\"), os.path.join(gui_dir, \"node_modules\"))          finally:              pass              \"\"\"              shutil.rmtree(tmp_dir)              \"\"\"      for repo in repo_defs.keys():      if repo_defs[repo].get(\"skip\", False):          continue      version = repo_defs[repo]['version']      print(f\"Fetching file for repository {repo} ({version})\", flush=True)      if version == \"local\":          src_path = repo_defs[repo]['path']          if not args.no_pull:              subprocess.run(f\"\\\"{git_path}\\\" pull {src_path}\", shell=True, capture_output=True, text=True)          print(f\"    Copying from {src_path}...\", flush=True)          move_files(repo, src_path)      else:          clone_dir = os.path.join(ROOT_DIR, f\"{repo}.clone\")          if version != \"develop\":              version = f\"release/{version}\"          print(\"    Cloning...\", flush=True)          subprocess.run(f\"\\\"{git_path}\\\" clone -b {version} {github_root}{repo}.git {clone_dir}\", shell=True,                         capture_output=True, text=True)          tag = repo_defs[repo]['tag']          if tag:              # Checkout tag version              saved_dir = os.getcwd()              os.chdir(clone_dir)              subprocess.run(f\"\\\"{git_path}\\\" checkout {tag}\", shell=True, capture_output=True, text=True)              os.chdir(saved_dir)          move_files(repo, clone_dir)              # For some reason, we need to protect the removal of the clone dirs...          # See https://stackoverflow.com/questions/1213706/what-user-do-python-scripts-run-as-in-windows          def handleRemoveReadonly(func, path, exc):              import errno, stat              if func == os.unlink and exc[1].errno == errno.EACCES:                  os.chmod(path, stat.S_IRWXU | stat.S_IRWXG | stat.S_IRWXO)  # 0777                  func(path)              else:                  raise              shutil.rmtree(clone_dir, onerror=handleRemoveReadonly)    # Manually add the taipy.run() function.  # TODO: Automate this, grabbing the function from the 'taipy' repository,  # so we benefit from potential updates.  init_path = os.path.join(ROOT_DIR, \"taipy\", \"__init__.py\")  with open(init_path, \"a\") as init:      run_method = \"\"\"  import typing as t    def run(*services: t.Union[Gui, Rest, Core], **kwargs) -> t.Optional[t.Union[Gui, Rest, Core]]:      \\\"\\\"\\\"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.<br/>              If several services are provided, all the services run simultaneously. If this is empty or set to None,              this method does nothing.          **kwargs (dict[str, any]): Other parameters to provide to the services.      \\\"\\\"\\\"      pass\\n\"\"\"      init.write(run_method)    # Generate Pipfile from package dependencies from all repositories  pipfile_path = os.path.join(ROOT_DIR, \"Pipfile\")  pipfile_message = \"WARNING: Package versions mismatch in Pipfiles - Pipfile not updated.\"  for package, versions in pipfile_packages.items():      if len(versions) != 1:          if pipfile_message:              print(pipfile_message)              pipfile_message = None          print(f\"- {package}:\")          for version, repos in versions.items():              print(f\"  {version} in {', '.join(repos)}.\")          pipfile_path = None  # Update Pipfile from all other Pipfiles  if pipfile_path:      pipfile_lines = None      with open(pipfile_path, \"r\") as pipfile:          pipfile_lines = pipfile.readlines()      new_pipfile_path = os.path.join(ROOT_DIR, \"Pipfile.new\")      in_packages_section = False      legacy_pipfile_packages = {}      pipfile_changes = []      with open(new_pipfile_path, \"w\") as new_pipfile:          for line in pipfile_lines:              if in_packages_section:                  if not line or line[0] == \"[\":                      in_packages_section = False                      # List packages                      for package in sorted(pipfile_packages.keys(), key=str.casefold):                          versions = pipfile_packages[package]                          version = list(versions.keys())[0]                          if package == \"modin\":                              # Remove 'extras' from modin package requirements                              version = re.sub(r\"\\{\\s*extras.*?,\\s*version\\s*=\\s*(.*?)\\s*}\", r\"\\1\", version)                          new_pipfile.write(f\"{package} = {version}\\n\")                          if not package in legacy_pipfile_packages:                              pipfile_changes.append(f\"Package '{package}' added ({version})\")                          elif legacy_pipfile_packages[package] != version:                              pipfile_changes.append(                                  f\"Package '{package}' version changed from {legacy_pipfile_packages[package]} to {version}\")                              del legacy_pipfile_packages[package]                          else:                              del legacy_pipfile_packages[package]                      new_pipfile.write(\"\\n\")                      skip_line = True                      new_pipfile.write(line)                  match = PIPFILE_PACKAGE_RE.fullmatch(line.strip())                  if match and not match.group(1).startswith(\"taipy\"):                      legacy_pipfile_packages[match.group(1).lower()] = match.group(2)              else:                  new_pipfile.write(line)                  if line.strip() == \"[packages]\":                      in_packages_section = True      for package, version in legacy_pipfile_packages.items():          pipfile_changes.append(f\"Package '{package}' removed ({version})\")      if pipfile_changes:          print(f\"Pipfile was updated (Pipfile.bak saved):\")          for change in pipfile_changes:              print(f\"- {change}\")          shutil.move(pipfile_path, os.path.join(ROOT_DIR, \"Pipfile.bak\"))          shutil.move(new_pipfile_path, pipfile_path)          print(f\"You may want to rebuild you virtual environment:\")          print(f\"  - pipenv --rm\")          print(f\"  - pipenv install --dev\")      else:          print(f\"No changes in Pipfile\")          os.remove(new_pipfile_path) "}
{"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": "# ######################################################################  #  # Syntax for cross-references to the Reference Manual:  #   `ClassName^`  #       generates a link from `ClassName` to the class doc page.  #   `functionName(*)^`  #       generates a link from `functionName(*)` to the function doc section.  #   `ClassName.methodName(*)^`  #       generates a link from `ClassName.methodName(*)` to the method doc section.  #   `(ClassName.)methodName(*)^`  #       generates a link from `methodName(*)` to the method doc section, hiding the class name.  #   `package.functionName(*)^`  #       generates a link from `package.functionName(*)` to the function doc section.  #   `(package.)functionName(*)^`  #       generates a link from `functionName(*)` to the function doc section, hiding the package.  #   `(package.)ClassName^`  #       generates a link from `ClassName` to the class doc page, hiding the package.  #   `(package.)ClassName.methodName(*)^`  #       generates a link from `ClassName.methodName(*)` to the method doc section, hiding the  #       package.  #   `(package.ClassName.)methodName(*)^`  #       generates a link from `methodName(*)` to the method doc section, hiding the package and the  #       class name.  # ######################################################################  import os  import re  from typing import Dict  import logging  import json    def define_env(env):      \"\"\"      Mandatory to make this a proper MdDocs macro      \"\"\"      match = re.search(r\"/en/(develop|(?:release-(\\d+\\.\\d+)))/$\", env.conf[\"site_url\"])      env.conf[\"branch\"] = (f\"release/{match[2]}\" if match[2] else match[1]) if match else \"unknown\"      TOC_ENTRY_PART1 = r\"<li\\s*class=\\\"md-nav__item\\\">\\s*<a\\s*href=\\\"\"  TOC_ENTRY_PART2 = r\"\\\"\\s*class=\\\"md-nav__link\\\">([^<]*)</a>\\s*</li>\\s*\"  # XREF_RE details:  #  group(1) - The package, class or function name with a trailing '.'.  #    Can be empty.  #    This text will not appear as the anchor text.  #  group(2) - The name of a class, function, method... This text will appear in the anchor text  #  group(3) - The function parameters, with their (). Can be empty.  #  group(4) - The anchor text. Can be empty, then group(2)+group(3) is used.  ## XREF_RE = re.compile(r\"<code>(\\()?((?:[^\\d\\W]\\w*\\.)*)\"  ##                     + r\"(?:\\))?([^\\d\\W][\\w\\.]*)(\\(.*?\\))?\\^<\\/code>\")  XREF_RE = re.compile(r\"<code>(?:\\(([\\w*\\.]*)\\))?([\\.\\w]*)(\\(.*?\\))?\\^<\\/code>(?:\\(([^\\)]*)\\))?\")      def find_dummy_h3_entries(content: str) -> Dict[str, str]:      \"\"\"      Find 'dummy <h3>' entries.        These are <h3> tags that are just redirections to another page.      These need to be removed, and redirection must be used in TOC.      \"\"\"        ids = {}      TOC_ENTRY = re.compile(TOC_ENTRY_PART1 + r\"(#[^\\\"]+)\" + TOC_ENTRY_PART2, re.M | re.S)      while True:          toc_entry = TOC_ENTRY.search(content)          if toc_entry is None:              break          content = content[toc_entry.end() :]          id = toc_entry.group(1)[1:]          dummy_h3 = re.search(r\"<h3\\s+id=\\\"\" + id + r\"\\\">\\s*<a\\s+href=\\\"(.*?)\\\".*?</h3>\", content, re.M | re.S)          if dummy_h3 is not None:              ids[id] = dummy_h3.group(1)      return ids      def remove_dummy_h3(content: str, ids: Dict[str, str]) -> str:      \"\"\"      Removes dummy <h3> entries and fix TOC.      \"\"\"        for id, redirect in ids.items():          # Replace redirection in TOC          content = re.sub(              TOC_ENTRY_PART1 + \"#\" + id + TOC_ENTRY_PART2,              '<li class=\"md-nav__item\"><a href=\"' + redirect + '\" class=\"md-nav__link\">\\\\1</a></li>\\n',              content,              re.M | re.S,          )          # Remove dummy <h3>          content = re.sub(r\"<h3\\s+id=\\\"\" + id + r\"\\\">\\s*<a\\s+href=\\\".*?\\\".*?</h3>\", \"\", content, re.M | re.S)      return content      def on_post_build(env):      \"\"\"      Post-build actions for Taipy documentation      \"\"\"        log = logging.getLogger(\"mkdocs\")      site_dir = env.conf[\"site_dir\"]      xrefs = {}      multi_xrefs = {}      if os.path.exists(site_dir + \"/manuals/xrefs\"):          with open(site_dir + \"/manuals/xrefs\") as xrefs_file:              xrefs = json.load(xrefs_file)      if xrefs is None:          log.error(f\"Could not read xrefs in 'manuals/xrefs'\")      x_packages = set()      for xref, xref_desc in xrefs.items():          if isinstance(xref_desc, list):              x_packages.add(xref_desc[0])              if xref_desc[2]:                  x_packages.update(xref_desc[2])          else:              descs = [xrefs[f\"{xref}/{i}\"] for i in range(0, xref_desc)]              # If unspecified, the first xref will be used (the one with the shortests package)              multi_xrefs[xref] = sorted(descs, key=lambda p: len(p[0]))      manuals_files_path = os.path.join(site_dir, \"manuals\")      ref_files_path = os.path.join(manuals_files_path, \"reference\")      fixed_cross_refs = {}      for root, _, file_list in os.walk(site_dir):          for f in file_list:              # Remove the *_template files              if f.endswith(\"_template\"):                  os.remove(os.path.join(root, f))              # Post-process generated '.html' files              elif f.endswith(\".html\"):                  filename = os.path.join(root, f)                  file_was_changed = False                  with open(filename) as html_file:                      try:                          html_content = html_file.read()                      except Exception as e:                          print(f\"Couldn't read HTML file {filename}\")                          raise e                      # Rebuild coherent links from TOC to sub-pages                      ids = find_dummy_h3_entries(html_content)                      if ids:                          html_content = remove_dummy_h3(html_content, ids)                          file_was_changed = True                      # Remove <h1>Index</h1> part of relevant pages                      INDEX_H1_RE = re.compile(                          r\"<h1>Index</h1>\\s*<h2(.*?)>(.*?)</h2>\", re.M | re.S                      )                      match = INDEX_H1_RE.search(html_content)                      if match:                          before = html_content[:match.start()]                          new_title = match.group(2)                          if new_title.startswith(\"Package\"):                              USELESS_TITLE_RE = re.compile(r\"(?<=<title>)Index(.*?)(?=</title>)\", re.M | re.S)                              t_match = USELESS_TITLE_RE.search(before)                              if t_match:                                  new_title = re.sub(r\"<a\\s+.*?</a>\", \"\", new_title)                                  new_title, n = re.subn(r\"<code>(.*?)</code>\", r\"\\g<1>\", new_title)                                  new_title = \"Taipy p\" + new_title[1:]                          before = before[:t_match.start()] + new_title + before[t_match.end():]                          html_content = (before                              + f\"<h1{match.group(1)}>{match.group(2)}</h1>\"                              + html_content[match.end():])                          file_was_changed = True                      #\"\"\"                      # Collapse doubled <h1>/<h2> page titles                      REPEATED_H1_H2 = re.compile(                          r\"<h1>(.*?)</h1>\\s*<h2\\s+(id=\\\".*?\\\")>\\1(<a\\s+class=\\\"headerlink\\\".*?</a>)?</h2>\", re.M | re.S                      )                      html_content, n_changes = REPEATED_H1_H2.subn('<h1 \\\\2>\\\\1\\\\3</h1>', html_content)                      if n_changes != 0:                          file_was_changed = True                      #\"\"\"                      # Specific processing for Getting Started documentation files                      if \"getting_started\" in filename:                          GS_H1_H2 = re.compile(r\"<h1>(.*?)</h1>(.*?<h2.*?>\\1)<\", re.M | re.S)                          html_content, n_changes = GS_H1_H2.subn('\\\\2<', html_content)                          if n_changes != 0:                              file_was_changed = True                          gs_rel_path = os.path.relpath(site_dir, filename).replace(\"\\\\\", \"/\").replace(\"../\", \"\", 1)                          GS_DOCLINK = re.compile(r\"(href=\\\")https://docs\\.taipy\\.io/en/latest(.*?\\\")\", re.M | re.S)                          html_content, n_changes = GS_DOCLINK.subn(f\"\\\\1{gs_rel_path}\\\\2\", html_content)                          if n_changes != 0:                              file_was_changed = True                          GS_IPYNB = re.compile(r\"(<a\\s*href=\\\"([^\\\"]*?)\\.ipynb\\\")\\s*>\", re.M | re.S)                          html_content, n_changes = GS_IPYNB.subn(f\"\\\\1 download>\", html_content)                          if n_changes != 0:                              file_was_changed = True                      # Add external link icons (and open in new tab)                      # Note we want this only for the simple [text](http*://ext_url) cases                      EXTLINK = re.compile(                          r\"<a\\s+(href=\\\"http[^\\\"]+\\\">.*?<\\/a>)\", re.M | re.S                      )                      html_content, n_changes = EXTLINK.subn('<a class=\"ext-link\" target=\"_blank\" \\\\1', html_content)                      if n_changes != 0:                          file_was_changed = True                      # Find and resolve automatic cross-references to the Reference Manual                      # The syntax in Markdown is `(class.)method()^` and similar.                      rel_path = os.path.relpath(ref_files_path, filename).replace(\"\\\\\", \"/\").replace(\"../\", \"\", 1)                      new_content = \"\"                      last_location = 0                      for xref in XREF_RE.finditer(html_content):                          all_parts = (xref[1] + xref[2]) if xref[1] else xref[2]                          parts = all_parts.split(\".\")                          c_name: str = parts.pop() # Class of function name                          m_name: str = None # Method name                          # Get potential destination link descriptor from last part                          desc = xrefs.get(c_name)                          # Check for class.method (looking at part before last)                          if len(parts) > 0:                              potential_class_name = parts[-1]                              if class_xref := xrefs.get(potential_class_name):                                  desc = class_xref                                  m_name = c_name                                  c_name = potential_class_name                                  parts.pop()                          if isinstance(desc, int):                              if parts:                                  package = \".\" . join(parts)                                  desc = next(d for d in multi_xrefs.get(c_name) if d[0].endswith(package))                              else:                                  desc = multi_xrefs.get(c_name)[0]                          link = None                          if not desc:                              if os.path.exists(f\"{ref_files_path}/pkg_{all_parts}/index.html\"):                                  link = f\"pkg_{all_parts}\"                              else:                                  (dir, file) = os.path.split(filename)                                  (dir, dir1) = os.path.split(dir)                                  (dir, dir2) = os.path.split(dir)                                  message = f\"Unresolve crossref '{re.sub(r'</?code>', '`', xref[0])}' found in \"                                  if file == \"index.html\":                                      (dir, dir3) = os.path.split(dir)                                      log.error(f\"{message}{dir3}/{dir2}/{dir1}.md\")                                  else:                                      log.error(f\"{message}{dir2}/{dir1}/{file}\")                          else:                              link = f\"{desc[0]}.{c_name}\"                              if m_name:                                  link += f\"/index.html#{desc[0]}.{c_name}.{m_name}\"                          if link:                              new_content += html_content[last_location:xref.start()]                              new_content += f\"<a href=\\\"{rel_path}/{link}\\\">\"                              if xref[4]: # Anchor text                                  new_content += xref[4]                              elif xref[2] or xref[3]:                                  new_content += \"<code>\"                                  if xref[2]: new_content += xref[2]                                  if xref[3]: new_content += xref[3]                                  new_content += \"</code>\"                              else:                                  new_content += f\"<b>NO CONTENT</b>\"                              new_content += f\"</a>\"                          last_location = xref.end()                      if last_location:                          file_was_changed = True                          html_content = new_content + html_content[last_location:]                      # Find 'free' crossrefs to the Reference Manual                      # Syntax in Markdown is [free text]((class.)method()^) and similar                      new_content = \"\"                      last_location = 0                      FREE_XREF_RE = re.compile(r\"(<a\\s+href=\\\")\"                                              + r\"([^\\d\\W]\\w*)(?:\\.\\))?\"                                              + r\"((?:\\.)?(?:[^\\d\\W]\\w*))?(\\(.*?\\))?\\^\"                                              + r\"(\\\">.*?</a>)\")                      for xref in FREE_XREF_RE.finditer(html_content):                          groups = xref.groups()                          entry = groups[1]                          method = groups[2]                          # Function in package? Or method in class?                          packages  = [entry, None] if entry in x_packages else xrefs.get(entry)                          if packages is None:                              (dir, file) = os.path.split(filename)                              (dir, dir1) = os.path.split(dir)                              (dir, dir2) = os.path.split(dir)                              bad_xref = xref.group(0)                              message = f\"Unresolve crossref '{bad_xref}' found in \"                              if file == \"index.html\":                                  (dir, dir3) = os.path.split(dir)                                  log.error(f\"{message}{dir3}/{dir2}/{dir1}.md\")                              else:                                  log.error(f\"{message}{dir2}/{dir1}/{file}\")                              continue                          else: # Free XRef was found: forget about the previous warning after all                              md_file=filename[len(site_dir):]                              sep=md_file[0]                              (dir, file) = os.path.split(md_file[1:]) # Drop the separator                              (dir, dir1) = os.path.split(dir)                              if file == \"index.html\": # Other cases to be treated as they come                                  source = f\"{dir}{sep}{dir1}.md\"                                  dest = f\"{dir}{sep}{entry}{method}{groups[3]}^\"                                  sources = fixed_cross_refs.get(dest, None)                                  if sources:                                      sources.add(source)                                  else:                                      fixed_cross_refs[dest] = {source}                          package = packages[0]                          orig_package = packages[1]                          new_content += html_content[last_location:xref.start()]                          new_content += f\"{groups[0]}{rel_path}/{package}.\"                          if orig_package:                              new_content += f\"{entry}\"                              if method:                                  new_content += f\"/index.html#{orig_package}.{entry}{method}\\\"\"                          else:                              new_content += f\"{method}/\"                          new_content += f\"\\\"{groups[4]}\"                          last_location = xref.end()                      if last_location:                          file_was_changed = True                          html_content = new_content + html_content[last_location:]                        # Finding xrefs in 'Parameters', 'Returns' and similar constructs.                      # These would be <typeName>^ fragments located in potentially                      # complex constructs such as \"Optional[Union[str, <typeName>^]]\"                      #                      # These fragments appear in single-line <td> blocks.                      #                      # At this point, this code is pretty sub-optimal and heavily                      # depends on the MkDocs generation. Time will tell if we can                      # keep it as is...                      typing_code = re.compile(r\"(<td>\\s*<code>)(.*\\^.*)(</code>\\s*</td>)\")                      # This will match a single <typeName>^ fragment.                      typing_type = re.compile(r\"\\w+\\^\")                      for xref in typing_code.finditer(html_content):                          groups = xref.groups()                          table_line = groups[1]                          table_line_to_replace = \"\".join(groups)                          new_table_line = table_line_to_replace                          typing_xref_found = False                            for type_ in typing_type.finditer(table_line):                              class_ = type_[0][:-1] # Remove ^                              packages = xrefs.get(class_)                              if packages:                                  # TODO - Retrieve the actual XREF                                  if isinstance(packages, int):                                      packages = xrefs.get(f\"{class_}/0\") # WRONG                                  typing_xref_found = True                                  new_content = f\"<a href=\\\"{rel_path}/{packages[0]}.{class_}\\\">{class_}</a>\"                                  new_table_line = new_table_line.replace(f\"{class_}^\", new_content)                          if typing_xref_found:                              file_was_changed = True                              html_content = html_content.replace(table_line_to_replace, new_table_line)                        # Replace data-source attributes in h<N> tags to links to                      # files in the appropriate repositores.                      process = process_data_source_attr(html_content, env)                      if process[0]:                          html_content = process[1]                          file_was_changed = True                      # Replace hrefs to GitHub containg [BRANCH] with proper branch name.                      process = process_links_to_github(html_content, env)                      if process[0]:                          html_content = process[1]                          file_was_changed = True                      # Shorten Table of contents in REST API files                      if \"rest/apis_\" in filename or \"rest\\\\apis_\" in filename:                          REST_TOC_ENTRY_RE = re.compile(r\"(<a\\s+href=\\\"#apiv.*?>\\s+)\"                                                       + r\"/api/v\\d+(.*?)(?=\\s+</a>)\")                          new_content = \"\"                          last_location = 0                          for toc_entry in REST_TOC_ENTRY_RE.finditer(html_content):                              new_content += html_content[last_location:toc_entry.start()]                              new_content += f\"{toc_entry.group(1)}{toc_entry.group(2)}\"                              last_location = toc_entry.end()                          if last_location:                              file_was_changed = True                              html_content = new_content + html_content[last_location:]                        # Rename the GUI Extension API type aliases                      elif \"reference_guiext\" in filename:                          for in_out in [(\"TaipyAction\", \"Action\", \"../interfaces/Action\"),                                         (\"TaipyContext\", \"Context\", \"#context\")]:                              LINK_RE = re.compile(f\"<code>{in_out[0]}</code>\")                              new_content = \"\"                              last_location = 0                              for link in LINK_RE.finditer(html_content):                                  new_content += html_content[last_location:link.start()]                                  new_content += f\"<a href=\\\"{in_out[2]}\\\"><code>{in_out[1]}</code></a>\"                                  last_location = link.end()                              if last_location:                                  file_was_changed = True                                  html_content = new_content + html_content[last_location:]                        # Processing for visual element pages:                      # - Remove <tt> from title                      # - Add breadcrumbs to Taipy GUI's control, part and core element pages                      fn_match = re.search(r\"(/|\\\\)gui\\1(vis|cor)elements\\1(.*?)\\1index.html\", filename)                      element_category = None                      if fn_match is not None:                          if title_match := re.search(r\"<title><tt>(.*?)</tt> - Taipy</title>\", html_content):                              html_content = (html_content[:title_match.start()]                                              + f\"<title>{title_match.group(1)} - Taipy</title>\"                                              + html_content[title_match.end():])                              file_was_changed = True                          if category_match := re.search(r\"<!--\\s+Category:\\s+(\\w+)\\s+-->\", html_content):                              element_category = category_match[1]                          elif re.match(r\"^charts(/|\\\\).*$\", fn_match[3]):                              element_category = \"chart\"                      if element_category:                          # Insert breadcrumbs                          ARTICLE_RE = re.compile(r\"(<div\\s+class=\\\"md-content\\\".*?>)(\\s*<article)\")                          if article_match := ARTICLE_RE.search(html_content):                              repl = \"\\n<ul class=\\\"tp-bc\\\">\"                              if fn_match[2] == \"cor\":                                  repl += f\"<li><a href=\\\"../../viselements\\\"><b>Visual Elements</b></a></li>\"                                  repl += \"<li><a href=\\\"../../viselements/controls/#scenario-management-controls\\\"><b>Scenario management controls</b></a></li>\"                              else:                                  chart_part = \"../\" if element_category == \"chart\" else \"\"                                  repl += f\"<li><a href=\\\"{chart_part}..\\\"><b>Visual Elements</b></a></li>\"                                  repl += (f\"<li><a href=\\\"{chart_part}../blocks\\\"><b>Blocks</b></a></li>\" if element_category == \"blocks\"                                          else f\"<li><a href=\\\"{chart_part}../controls/#standard-controls\\\"><b>Standard controls</b></a></li>\")                                  if chart_part:                                      repl += f\"<li><a href=\\\"{chart_part}../chart\\\"><b>Charts</b></a></li>\"                              repl += \"</ul>\"                              html_content = (html_content[:article_match.start()]                                              + article_match.group(1)                                              + repl                                              + article_match.group(2)                                              + html_content[article_match.end():])                              file_was_changed = True                      # Processing for the page builder API:                      fn_match = re.search(r\"(/|\\\\)reference\\1taipy\\.gui\\.builder.(.*?)\\1index.html\", filename)                      if fn_match is not None:                          element_name = fn_match[2]                          # Default value of properties appear as \"dynamic(type\" as \"indexed(type\"                          prop_re = re.compile(r\"<tr>\\s*<td><code>.*?</code></td>\"                                             + r\"\\s*<td>\\s*<code>(.*?)</code>\\s*</td>\\s*<td>\",                                               re.S)                          new_content = \"\"                          last_location = 0                          for prop in prop_re.finditer(html_content):                              if default_value_re := re.match(r\"(dynamic|indexed)\\((.*)\", prop[1]):                                  new_content += html_content[last_location:prop.start(1)]                                  new_content += f\"{default_value_re[2]}<br/><small><i>{default_value_re[1]}</i></small>\"                                  last_location = prop.end(1)                          if last_location:                              file_was_changed = True                              html_content = new_content + html_content[last_location:]                          # '<i>default value</i>' -> <i>default value</i>                          dv_re = re.compile(r\"&\\#39;&lt;i&gt;(.*?)&lt;/i&gt;&\\#39;\", re.S)                          new_content = \"\"                          last_location = 0                          for dv in dv_re.finditer(html_content):                              new_content += html_content[last_location:dv.start()] + f\"<i>{dv[1]}</i>\"                              last_location = dv.end()                          if last_location:                              file_was_changed = True                              html_content = new_content + html_content[last_location:]                      # Handle title and header in packages documentation file                      FONT_SIZE_CHANGE=''                      def code(s: str) -> str:                          return f\"<code><font size='+2'>{s}</font></code>\"                        fn_match = re.search(r\"manuals(/|\\\\)reference\\1pkg_taipy\\1index.html\", filename)                      if fn_match is not None: # The root 'taipy' package                          html_content = re.sub(f\"(<h1>)taipy(</h1>)\", f\"\\\\1{code('taipy')}\\\\2\", html_content)                          file_was_changed = True                      fn_match = re.search(r\"manuals(/|\\\\)reference\\1pkg_taipy(\\..*)\\1index.html\", filename)                      if fn_match is not None:                          pkg = fn_match[2]                          sub_match = re.search(r\"(\\.\\w+)(\\..*)\", pkg)                          if sub_match is None:                              html_content = re.sub(f\"(<title>)Index\\\\s\", f\"\\\\1taipy{pkg} \", html_content)                              html_content = re.sub(f\"(<h1>)Index(</h1>)\", f\"\\\\1{code('taipy'+pkg)}\\\\2\", html_content)                              html_content = re.sub(f\"(<h1>){pkg}(</h1>)\", f\"\\\\1{code('taipy'+pkg)}\\\\2\", html_content)                          else:                              html_content = re.sub(f\"(<title>)({sub_match[2]})\\\\s\", f\"\\\\1taipy{sub_match[1]}\\\\2 \", html_content)                              html_content = re.sub(f\"(<h1>)(?:<code>){sub_match[2]}(?:</code>)(</h1>)\", f\"\\\\1{code('taipy'+pkg)}\\\\2\", html_content)                          file_was_changed = True                    if file_was_changed:                      with open(filename, \"w\") as html_file:                          html_file.write(html_content)              # Replace path to doc in '.ipynb' files              elif f.endswith(\".ipynb\"):                  filename = os.path.join(root, f)                  with open(filename) as ipynb_file:                      try:                          content = ipynb_file.read()                      except Exception as e:                          print(f\"Couldn't read Notebook file {filename}\")                          raise e                      (new_content, n) = re.subn(\"(?<=https://docs.taipy.io/en/)latest\", f\"{env.conf['branch']}\", content)                      if n > 0:                          with open(filename, \"w\") as ipynb_file:                              ipynb_file.write(new_content)      if fixed_cross_refs:          for dest in sorted(fixed_cross_refs.keys()):              sources = \", \".join(sorted(fixed_cross_refs[dest]))              log.info(f\"FIXED cross-ref to '{dest}' from {sources}\")      # ################################################################################  # Functions that are used in the postprocessing phase.  # I wish we could move them elsewhere, but couldn't figure out how  # ################################################################################  def process_data_source_attr(html: str, env):      _DATASOURCE_RE = re.compile(r\"(<(h\\d+))\\s+data-source=\\\"(.*?)\\\"(.*</\\2>)\")      new_content = \"\"      last_location = 0      for m in _DATASOURCE_RE.finditer(html):          ref = m.group(3)          repo_m = re.search(r\"^([\\w\\d]+):\", ref)          if repo_m:              ref = (\"https://github.com/Avaiga/taipy-\" +                     f\"{repo_m.group(0)[:-1]}/blob/{env.conf['branch']}/{ref[repo_m.end():]}\")          new_content += (html[last_location:m.start()]                          + f\"{m.group(1)}{m.group(4)}\"                          + f\"\\n<small>You can download the entire source code used in this \"                          + f\"section from the <a href=\\\"{ref}\\\">GitHub repository</a>.</small>\"                          )          last_location = m.end()      if last_location:          return (True, new_content + html[last_location:])      else:          return (False, None)      def process_links_to_github(html: str, env):      _LINK_RE = re.compile(r\"(?<=href=\\\"https://github.com/Avaiga/)(taipy-gui/tree/)\\[BRANCH\\](.*?\\\")\")      new_content = \"\"      last_location = 0      for m in _LINK_RE.finditer(html):          new_content += html[last_location:m.start()] + m.group(1) + env.conf['branch'] + m.group(2)          last_location = m.end()      if last_location:          return (True, new_content + html[last_location:])      else:          return (False, None) "}
{"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": "# ################################################################################  # Taipy REST API Reference Manual generation setup step.  #  # A Taipy REST server is created and the API is queries dynamically.  # Then documentation pages are generated from the retrieved structure.  # ################################################################################  from .setup import Setup, SetupStep      class RestRefManStep(SetupStep):      def __init__(self):          self.navigation = None        def get_id(self) -> str:          return \"rest\"        def get_description(self) -> str:          return \"Generation of the REST API Reference Manual pages\"        def enter(self, setup: Setup):          self.navigation = None        def setup(self, setup: Setup) -> None:          setup.move_package_to_tools(Setup.ROOT_PACKAGE)          try:              self.generate_rest_refman_pages(setup)          except Exception as e:              raise e          finally:              setup.move_package_to_root(Setup.ROOT_PACKAGE)        def generate_rest_refman_pages(self, setup: Setup):          REST_REF_DIR_PATH = setup.manuals_dir + \"/reference_rest\"          from taipy.rest.app import create_app as rest_create_app            app = rest_create_app()            from taipy.rest.extensions import apispec as rest_apispec            with app.app_context():              rest_specs = rest_apispec.swagger_json().json            self.navigation = \"\"            path_descs = {              \"cycle\": \"Entry points that interact with `Cycle^` entities.\",              \"scenario\": \"Entry points that interact with `Scenario^` entities.\",              \"sequence\": \"Entry points that interact with `Sequence^` entities.\",              \"datanode\": \"Entry points that interact with `DataNode^` entities.\",              \"task\": \"Entry points that interact with `Task^` entities.\",              \"job\": \"Entry points that interact with `Job^` entities.\",              \"auth\": \"Entry points that deal with authentication.\",          }          path_files = {}          enterprise_paths = [\"auth\"]            response_statuses = {              \"200\": (\"OK\", \"https://httpwg.org/specs/rfc7231.html#status.200\"),              \"201\": (\"Created\", \"https://httpwg.org/specs/rfc7231.html#status.201\"),              \"202\": (\"Accepted\", \"https://httpwg.org/specs/rfc7231.html#status.202\"),              \"204\": (\"No Content\", \"https://httpwg.org/specs/rfc7231.html#status.204\"),              \"401\": (\"Unauthorized\", \"https://httpwg.org/specs/rfc7235.html#status.401\"),              \"404\": (\"Not Found\", \"https://httpwg.org/specs/rfc7231.html#status.404\"),          }            def get_property_type(property_desc, from_schemas):              type_name = property_desc.get(\"type\", None)              a_pre = \"\"              a_post = \"\"              if type_name == \"array\":                  property_desc = property_desc[\"items\"]                  type_name = property_desc.get(\"type\", None)                  a_pre = \"\\\\[\"                  a_post = \"\\\\]\"              if type_name is None:                  type_name = property_desc.get(\"$ref\", None)                  if type_name is None:                      # print(f\"WARNING - No type...\")                      return \"\"                  type_name = type_name[type_name.rfind(\"/\") + 1 :]                  prefix = \"\" if from_schemas else \"schemas.md\"                  type_name = f\"[`{type_name}`]({prefix}#{type_name.lower()})\"              return f\"{a_pre}{type_name}{a_post}\"            for path, desc in rest_specs[\"paths\"].items():              dest_path = None              dest_path_desc = None              for p, d in path_descs.items():                  if f\"/{p}\" in path:                      dest_path = p                      dest_path_desc = d                      break              if dest_path is None:                  print(f\"Path {path} has no paths bucket\")                  continue                file = path_files.get(dest_path)              if file is None:                  file = open(f\"{REST_REF_DIR_PATH}/apis_{dest_path}.md\", \"w\")                  if dest_path in enterprise_paths:                      file.write(Setup.ENTERPRISE_BANNER)                  file.write(f\"{dest_path_desc}\\n\\n\")                  self.navigation += f\"- \\\"Paths for {dest_path}\\\": manuals/reference_rest/apis_{dest_path}.md\\n\"                  path_files[dest_path] = file                file.write(f\"# `{path}`\\n\\n\")              for method, method_desc in desc.items():                  file.write(f\"## {method.upper()}\\n\\n\")                  file.write(f\"{method_desc['description']}\\n\\n\")                  parameters = method_desc.get(\"parameters\")                  if parameters is not None:                      file.write(f\"<h4>Parameters</h4>\\n\\n\")                      file.write(\"|Name|Type|Required|Description|\\n\")                      file.write(\"|---|---|---|---|\\n\")                      for param in parameters:                          param_type = \"TODO\"                          if \"schema\" in param and len(param[\"schema\"]) == 1:                              param_type = param[\"schema\"][\"type\"]                          file.write(                              f\"|{param['name']}|{param_type}|{'Yes' if param['name'] else 'No'}|{param.get('description', '-')}|\\n\"                          )                      file.write(\"\\n\")                  request_body = method_desc.get(\"requestBody\")                  if request_body is not None:                      file.write(f'<div><h4 style=\"display: inline-block;\">Request body:</h4>\\n')                      schema = request_body[\"content\"][\"application/json\"][\"schema\"][\"$ref\"]                      schema = schema[schema.rfind(\"/\") + 1 :]                      file.write(f'<span><a href=\"schemas.md#{schema.lower()}\">{schema}</a></div>\\n\\n')                  responses = method_desc.get(\"responses\")                  if responses is not None:                      file.write(f\"<h4>Responses</h4>\\n\\n\")                      for response, response_desc in responses.items():                          file.write(f\"- <b><code>{response}</code></b><br/>\\n\")                          status = response_statuses[response]                          file.write(f\"    Status: [`{status[0]}`]({status[1]})\\n\\n\")                          description = response_desc.get(\"description\")                          if description is not None:                              file.write(f\"    {description}\\n\")                          content = response_desc.get(\"content\", None)                          if content is not None:                              schema = content[\"application/json\"][\"schema\"]                              allOf = schema.get(\"allOf\")                              if allOf is not None:                                  schema = allOf[0]                              properties = schema.get(\"properties\")                              if properties is not None:                                  file.write(\"    |Name|Type|\\n\")                                  file.write(\"    |---|---|\\n\")                                  for property, property_desc in properties.items():                                      file.write(f\"    |{property}|{get_property_type(property_desc, False)}|\\n\")                              else:                                  print(f\"No properties in content in response {response} in method {method} of {path}\")                          elif response != \"404\":                              print(f\"No content in response {response} in method {method} of {path}\")                          file.write(\"\\n\")            for f in path_files.values():              f.close()            with open(f\"{REST_REF_DIR_PATH}/schemas.md\", \"w\") as file:              for schema, schema_desc in rest_specs[\"components\"][\"schemas\"].items():                  properties = schema_desc.get(\"properties\")                  if properties is not None:                      file.write(f\"## {schema}\\n\\n\")                      file.write(\"|Name|Type|Description|\\n\")                      file.write(\"|---|---|---|\\n\")                      for property, property_desc in properties.items():                          file.write(f\"|{property}|{get_property_type(property_desc, True)}|-|\\n\")                      file.write(\"\\n\")          self.navigation += \"- \\\"Schemas\\\": manuals/reference_rest/schemas.md\\n\"          def exit(self, setup: Setup):          setup.update_mkdocs_yaml_template(              r\"^\\s*\\[REST_REFERENCE_CONTENT\\]\\s*\\n\", self.navigation if self.navigation else \"\"          ) "}
{"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": "# ################################################################################  # Taipy Reference Manual generation setup step.  #  # Generate the entries for every documented class, method, and function.  # This scripts browses the root package (Setup.ROOT_PACKAGE) and builds a  # documentation file for every package and every class it finds.  # It finally updates the top navigation bar content (in mkdocs.yml) to  # reflect the root package structure.  # ################################################################################  import json  import os  import re  import shutil  from inspect import isclass, isfunction, ismodule    from .setup import Setup, SetupStep      class RefManStep(SetupStep):      # Package grouping (order is kept in generation)      PACKAGE_GROUPS = [          \"taipy.config\",          \"taipy.core\",          \"taipy.gui\",          \"taipy.gui_core\",          \"taipy.rest\",          \"taipy.auth\",          \"taipy.enterprise\",      ]        # Entries that should be hidden for the time being      HIDDEN_ENTRIES = [\"get_context_id\", \"invoke_state_callback\"]      # Where the Reference Manual files are generated (MUST BE relative to docs_dir)      REFERENCE_REL_PATH = \"manuals/reference\"        def __init__(self):          self.navigation = None        def get_id(self) -> str:          return \"refman\"        def get_description(self) -> str:          return \"Generation of the Reference Manual pages\"        def enter(self, setup: Setup):          os.environ[\"GENERATING_TAIPY_DOC\"] = \"true\"          self.REFERENCE_DIR_PATH = os.path.join(setup.docs_dir, RefManStep.REFERENCE_REL_PATH)          self.XREFS_PATH = os.path.join(setup.manuals_dir, \"xrefs\")        def setup(self, setup: Setup) -> None:          # Clean REFERENCE_DIR_PATH directory          for p in os.listdir(self.REFERENCE_DIR_PATH):              fp = os.path.join(self.REFERENCE_DIR_PATH, p)              if re.match(\"^(pkg_)?taipy(\\..*)?\\.md$\", p):                  os.remove(fp)              elif os.path.isdir(fp) and re.match(\"^pkg_taipy(\\..*)?$\", p):                  shutil.rmtree(fp)            saved_dir = os.getcwd()          try:              os.chdir(setup.tools_dir)              if not os.path.isdir(os.path.join(setup.tools_dir, Setup.ROOT_PACKAGE)):                  setup.move_package_to_tools(Setup.ROOT_PACKAGE)              self.generate_refman_pages(setup)          except Exception as e:              raise e          finally:              os.chdir(saved_dir)              setup.move_package_to_root(Setup.ROOT_PACKAGE)        def generate_refman_pages(self, setup: Setup) -> None:          CLASS_ID = \"C\"          FUNCTION_ID = \"F\"          TYPE_ID = \"T\"          FIRST_DOC_LINE_RE = re.compile(r\"^(.*?)(:?\\n\\s*\\n|$)\", re.DOTALL)          REMOVE_LINE_SKIPS_RE = re.compile(r\"\\s*\\n\\s*\", re.MULTILINE)            loaded_modules = set()            # Entries:          #   full_entry_name ->          #     name          #     module (source)          #     type          #     doc          #     packages          entries: dict[str, dict[str, any]] = {}          module_doc = {}            def read_module(module):              if module in loaded_modules:                  return              loaded_modules.add(module)              if not module.__name__.startswith(Setup.ROOT_PACKAGE):                  return              entry: str              for entry in dir(module):                  # Private?                  if entry.startswith(\"_\"):                      continue                  e = getattr(module, entry)                  if hasattr(e, \"__class__\") and e.__class__.__name__.startswith(\"_\"):                      continue                  entry_type: str = None                  if hasattr(e, \"__module__\") and e.__module__:                      # Handling alias Types                      if e.__module__.startswith(Setup.ROOT_PACKAGE):  # For local build                          if e.__class__.__name__ == \"NewType\":                              entry_type = TYPE_ID                      elif e.__module__ == \"typing\" and hasattr(e, \"__name__\"):  # For Readthedoc build                          # Manually remove class from 'typing'                          if e.__name__ == \"NewType\":                              continue                          # Manually remove function from 'typing'                          if e.__name__ == \"overload\":                              continue                          entry_type = TYPE_ID                      else:                          continue                  # Remove hidden entries                  if entry in RefManStep.HIDDEN_ENTRIES:                      continue                  # Not a function or a class?                  if not entry_type:                      if isclass(e):                          entry_type = CLASS_ID                      elif isfunction(e):                          entry_type = FUNCTION_ID                      elif ismodule(e):                          module_doc[e.__name__] = e.__doc__                          read_module(e)                  if not entry_type:                      continue                  # Add to all entries                  doc = e.__doc__                  if doc:                      first_line = FIRST_DOC_LINE_RE.match(doc.strip())                      if first_line:                          if first_line.group(0).startswith(\"NOT DOCUMENTED\"):                              continue                          doc = REMOVE_LINE_SKIPS_RE.subn(\" \", first_line.group(0))[0].strip()                      else:                          print(                              f\"WARNING - Couldn't extract doc summary for {e.__name__} in {e.__module__}\",                              flush=True,                          )                  full_name = f\"{e.__module__}.{entry}\"                  # Entry module: e.__module__                  # Current module: module.__name__                  if entry_info := entries.get(full_name):                      packages = entry_info[\"packages\"]                      if module.__name__ != Setup.ROOT_PACKAGE:                          # Is current module a parent of known packages? Use that instead if yes                          child_idxs = [i for i, p in enumerate(packages) if p.startswith(module.__name__)]                          if child_idxs:                              for index in reversed(child_idxs):                                  del packages[index]                              packages.append(module.__name__)                          else:                          # Is any known package a parent of the current module? If yes ignore it                              parent_idxs = [i for i, p in enumerate(packages) if module.__name__.startswith(p)]                              if not parent_idxs:                                  packages.append(module.__name__)                  else:                      if doc is None:                          print(f\"WARNING - {e.__name__} [in {e.__module__}] has no doc\", flush=True)                      entries[full_name] = {                          \"name\": entry,                          \"module\": e.__module__,                          \"type\": entry_type,                          \"doc\": doc,                          \"packages\": [module.__name__],                      }                  if module.__name__ == Setup.ROOT_PACKAGE:                      entry = entries[full_name]                      entry[\"at_root\"] = True                      if Setup.ROOT_PACKAGE in entry[\"packages\"]:                          entry[\"packages\"].remove(Setup.ROOT_PACKAGE)            taipy_config_dir = os.path.join(setup.tools_dir, \"taipy\", \"config\")          config_backup_path = os.path.join(taipy_config_dir, \"config.py.bak\")          if os.path.exists(config_backup_path):              shutil.move(config_backup_path, os.path.join(taipy_config_dir, \"config.py\"))            read_module(__import__(Setup.ROOT_PACKAGE))            # Compute destination package for each entry          for entry, entry_desc in entries.items():              doc_package = None # Where this entity should be exposed              module = entry_desc[\"module\"]              packages = entry_desc[\"packages\"]              # If no packages, it has to be at the root level              if not packages:                  if not entry_desc.get(\"at_root\", False):                      raise SystemError(f\"FATAL - Entry '{entry}' has no package, and not in root\")                  doc_package = Setup.ROOT_PACKAGE              else:                  # If visible from a package above entry module, pick this one                  parents = list(filter(lambda p: module.startswith(p), packages))                  if len(parents) > 1:                      raise SystemError(                          \"FATAL - Entry '{entry}' has several matching parent packages ([packages])\"                      )                  elif len(parents) == 0:                      if len(packages) == 1:                          doc_package = packages[0]                      else:                          package_groups = list(filter(lambda p: p in RefManStep.PACKAGE_GROUPS, packages))                          if len(package_groups) == 1:                              doc_package = package_groups[0]                  else:                      doc_package = parents[0]              if doc_package is None:                  raise SystemError(f\"FATAL - Entry '{entry}' has no target package\")              entry_desc[\"doc_package\"] = doc_package            # Group entries by package          package_to_entries = {}          for entry, info in entries.items():              package = info[\"doc_package\"]              if package in package_to_entries:                  package_to_entries[package].append(info)              else:                  package_to_entries[package] = [info]            # Add taipy packages with documentation but no entry          for package, doc in module_doc.items():              if not package.startswith(\"taipy\"):                  continue              if package in package_to_entries:                  continue              if not doc:                  continue              package_to_entries[package] = {}            # Generate all Reference manual pages and update navigation          self.navigation = \"\"          xrefs = {}          package_group = None          for package in sorted(package_to_entries.keys()):              functions = []              classes = []              types = []              for entry_info in package_to_entries[package]:                  if entry_info[\"type\"] == CLASS_ID:                      classes.append(entry_info)                  elif entry_info[\"type\"] == FUNCTION_ID:                      functions.append(entry_info)                  elif entry_info[\"type\"] == TYPE_ID:                      types.append(entry_info)                  else:                      raise SystemError(                          \"FATAL - Invalid entry type '{entry_info['type']}' for {entry_info['module']}.{entry_info['name']}\"                      )              if package in RefManStep.PACKAGE_GROUPS:                  package_group = package                  package_path = f\"{self.REFERENCE_DIR_PATH}/pkg_{package}\"                  os.mkdir(package_path)                  package_output_path = os.path.join(package_path, \"index.md\")                  self.navigation += (                      f\"- \\\"<code>{package}</code>\\\":\\n  - {RefManStep.REFERENCE_REL_PATH}/pkg_{package}/index.md\\n\"                  )              else:                  high_package_group = None                  for p in RefManStep.PACKAGE_GROUPS:                      if package.startswith(p + \".\"):                          high_package_group = p                          break                  if high_package_group != package_group:                      if not high_package_group:                          raise SystemExit(                              f\"FATAL - Unknown package '{high_package_group}' for package '{package}' (renamed from '{package_group}')\"                          )                      package_group = high_package_group                      self.navigation += f\"- {package_group}:\\n\"                  package_nav_entry = package                  if package_group:                      self.navigation += \"  \"                      package_nav_entry = package[len(package_group):]                  self.navigation += f\"- \\\"<code>{package_nav_entry}</code>\\\": {RefManStep.REFERENCE_REL_PATH}/pkg_{package}.md\\n\"                  package_output_path = os.path.join(                      self.REFERENCE_DIR_PATH, f\"pkg_{package}.md\"                  )                  package_output_path = os.path.join(self.REFERENCE_DIR_PATH, f\"pkg_{package}.md\")                def update_xrefs(name, type, force_package, module, others):                  if not others:                      print(f\"{name}\")                      pass                  # xrefs:                  # entry_name <-> [ exposed_package, entry_module, other_packages]                  #   or                  # name <-> <number of similar entries> (int)                  # +  entry_name/<index> <-> [ exposed_package, entry_module, other_packages]                  type_name = \"Function\" if type == FUNCTION_ID else \"Class\" if type == CLASS_ID else \"Type\"                  if xref := xrefs.get(name):                      if force_package == xref[0]:                          raise SystemError(                              f\"FATAL -  - {type_name} {name} exposed in {force_package} already declared as {xref[0]}.{xref[1]}\"                              )                      print(f\"NOTE: duplicate entry {name} - {xref[0]}/{force_package}\")                      #print(f\"WARNING - {'Function' if type == FUNCTION_ID else 'Class'} {name} already declared as {xref[0]}.{xref[1]}\")                      xref_array = []                      if isinstance(xref, int): # If there already are duplicates                          for index in range(0..int(xref)):                              xref = xrefs.get(f\"{name}/{index}\")                              if force_package == xref[0]:                                  raise SystemError(                                      \"FATAL -  - {type_name} {name} exposed in {force_package} already declared as {xref[0]}.{xref[1]}\"                                      )                          xrefs[f\"{name}/{index}\"] = [ force_package, module, others ]                      else: # Create multiple indexed entries for 'name'                          xrefs[name] = 2                          xrefs[f\"{name}/0\"] = xref                          xrefs[f\"{name}/1\"] = [ force_package, module, others ]                  else:                      xrefs[name] = [force_package, module, others ]                def generate_entries(entry_infos, package, type, package_output_file, in_group):                  in_group = \"../\" if in_group else \"\"                  for entry_info in sorted(entry_infos, key=lambda i: i[\"name\"]):                      name = entry_info[\"name\"]                      force_package = entry_info.get(\"force_package\", package)                      package_output_file.write(                          f\"   - [`{name}\"                          + f\"{'()' if type == FUNCTION_ID else ''}`]({in_group}{force_package}.{name}.md)\"                          + f\"{': ' + entry_info['doc'] if entry_info['doc'] else ' - NOT DOCUMENTED'}\\n\"                      )                      output_path = os.path.join(self.REFERENCE_DIR_PATH, f\"{force_package}.{name}.md\")                      with open(output_path, \"w\") as output_file:                          output_file.write(\"---\\nhide:\\n  - navigation\\n---\\n\\n\" + f\"::: {force_package}.{name}\\n\")                      update_xrefs(name, type, force_package, entry_info[\"module\"], entry_info[\"packages\"])                with open(package_output_path, \"w\") as package_output_file:                  if package in module_doc and module_doc[package]:                      package_output_file.write(module_doc[package])                  package_grouped = package == package_group                  if types:                      package_output_file.write(f\"## Types\\n\\n\")                      for type in types:                          name = type[\"name\"]                          package_output_file.write(f\"   - `{name}`\" + f\"{': ' + type.get('doc', ' - NOT DOCUMENTED')}\\n\")                          update_xrefs(name, TYPE_ID, package, entry_info[\"module\"], entry_info.get(\"packages\"))                  if functions:                      package_output_file.write(f\"## Functions\\n\\n\")                      generate_entries(                          functions,                          package,                          FUNCTION_ID,                          package_output_file,                          package_grouped,                      )                  if classes:                      package_output_file.write(f\"## Classes\\n\\n\")                      generate_entries(classes, package, CLASS_ID, package_output_file, package_grouped)            self.add_external_methods_to_config_class(setup)            # Filter out packages that are the exposed package and appear in the packages list          for entry, entry_desc in xrefs.items():              if not isinstance(entry_desc, int):                  package = entry_desc[0]                  if entry_desc[2]:                      entry_desc[2] = [p for p in entry_desc[2] if p != package]          with open(self.XREFS_PATH, \"w\") as xrefs_output_file:              xrefs_output_file.write(json.dumps(xrefs))        @staticmethod      def add_external_methods_to_config_class(setup: Setup):          if not os.path.exists(\"config_doc.txt\"):              print(f\"WARNING - No methods found to inject to Config documentation!\")              return            # Get code of methods to inject          with open(\"config_doc.txt\", \"r\") as f:              print(f\"INFO - Injecting methods to Config documentation.\")              methods_to_inject = f.read()            # Delete temporary file          if os.path.exists(\"config_doc.txt\"):              os.remove(\"config_doc.txt\")            # Backup file taipy/config/config.py          taipy_config_dir = os.path.join(setup.tools_dir, \"taipy\", \"config\")          config_path = os.path.join(taipy_config_dir, \"config.py\")          shutil.copyfile(config_path, os.path.join(taipy_config_dir, \"config.py.bak\"))            # Read config.py file          with open(config_path, \"r\") as f:              contents = f.readlines()            # Inject imports and code          imports_to_inject = \"\"\"  from types import NoneType  from typing import Any, Callable, Dict, List, Union, Optional  import json  from .common.scope import Scope  from .common.frequency import Frequency  from taipy.core.common.mongo_default_document import MongoDefaultDocument  from taipy.core.config.job_config import JobConfig  from taipy.core.config.data_node_config import DataNodeConfig  from taipy.core.config.task_config import TaskConfig  from taipy.core.config.scenario_config import ScenarioConfig  from taipy.core.config.sequence_config import SequenceConfig\\n\"\"\"          contents.insert(11, imports_to_inject)          contents.insert(len(contents) - 2, methods_to_inject)            # Fix code injection          with open(config_path, \"w\") as f:              new_content = \"\".join(contents)              new_content = new_content.replace(                  \"custom_document: Any = <class 'taipy.core.common.mongo_default_document.MongoDefaultDocument'>\",                  \"custom_document: Any = MongoDefaultDocument\",              )              new_content = new_content.replace(\"taipy.config.common.scope.Scope\", \"Scope\")              new_content = new_content.replace(\"<Scope.SCENARIO: 2>\", \"Scope.SCENARIO\")              new_content = new_content.replace(\"taipy.core.config.data_node_config.DataNodeConfig\", \"DataNodeConfig\")              new_content = new_content.replace(\"taipy.core.config.task_config.TaskConfig\", \"TaskConfig\")              new_content = new_content.replace(\"taipy.core.config.sequence_config.SequenceConfig\", \"SequenceConfig\")              new_content = new_content.replace(\"taipy.config.common.frequency.Frequency\", \"Frequency\")              f.write(new_content)        def exit(self, setup: Setup):          setup.update_mkdocs_yaml_template(r\"^\\s*\\[REFERENCE_CONTENT\\]\\s*\\n\", self.navigation if self.navigation else \"\")          if \"GENERATING_TAIPY_DOC\" in os.environ:              del os.environ[\"GENERATING_TAIPY_DOC\"] "}
{"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": "# ################################################################################  # Taipy GUI Visual Elements documentation.  #  # This includes the update of the Table of Contents for both the controls  # and the blocks document pages.  #  # For each visual element, this script combines its property list and core  # documentation, and generates full Markdown files in [VISELEMENTS_DIR_PATH]. All  # these files ultimately get integrated in the global doc set.  #  # The skeleton documentation files  # [VISELEMENTS_DIR_PATH]/[controls|blocks].md_template  # are also completed with generated table of contents.  # ################################################################################  import json  import os  import re  import sys  from typing import Dict, List, Optional    from .setup import Setup, SetupStep  from io import StringIO    class VisElementsStep(SetupStep):      DEFAULT_PROPERTY = \"default_property\"      PROPERTIES = \"properties\"      NAME = \"name\"      INHERITS = \"inherits\"        def get_id(self) -> str:          return \"viselements\"        def get_description(self) -> str:          return \"Extraction of the visual elements documentation\"        def enter(self, setup: Setup):          self.VISELEMENTS_DIR_PATH = setup.manuals_dir + \"/gui/viselements\"          self.CORELEMENTS_DIR_PATH = setup.manuals_dir + \"/gui/corelements\"          self.controls_path = f\"{self.VISELEMENTS_DIR_PATH}/controls.md\"          template_path = f\"{self.controls_path}_template\"          if not os.access(template_path, os.R_OK):              raise FileNotFoundError(                  f\"FATAL - Could not read {template_path} Markdown template\"              )          self.blocks_path = f\"{self.VISELEMENTS_DIR_PATH}/blocks.md\"          template_path = f\"{self.blocks_path}_template\"          if not os.access(template_path, os.R_OK):              raise FileNotFoundError(                  f\"FATAL - Could not read {template_path} Markdown template\"              )          self.charts_home_html_path = (              self.VISELEMENTS_DIR_PATH + \"/charts/home.html_fragment\"          )          if not os.access(self.charts_home_html_path, os.R_OK):              raise FileNotFoundError(                  f\"FATAL - Could not read {self.charts_home_html_path} html fragment\"              )            # Load Taipy GUI and Taipy elements          # -----------------------------------------------------------          # Load elements, check basic features and resolve inheritance          def load_elements(              self, elements_json_path: str, prefix: str, doc_pages_path: str          ) -> None:              with open(elements_json_path) as elements_json_file:                  loaded_elements = json.load(elements_json_file)                new_elements = {}              for category, elements in loaded_elements.items():                  if category not in self.categories:                      self.categories[category] = []                  for element in elements:                      element_type = element[0]                      self.categories[category].append(element_type)                      if element_type in self.elements:                          raise ValueError(                              f\"FATAL - Duplicate element type '{element_type}' in {elements_json_path}\"                          )                      element_desc = element[1]                      if (                          not __class__.PROPERTIES in element_desc                          and not __class__.INHERITS in element_desc                      ):                          raise ValueError(                              f\"FATAL - No properties in element type '{element_type}' in {elements_json_path}\"                          )                      element_desc[\"prefix\"] = prefix                      element_desc[\"doc_path\"] = doc_pages_path                      element_desc[\"source\"] = elements_json_path                      new_elements[element_type] = element_desc              self.elements.update(new_elements)              # Find default property for all element types              for element_type, element_desc in new_elements.items():                  default_property = None                  if properties := element_desc.get(__class__.PROPERTIES, None):                      for property in properties:                          if __class__.DEFAULT_PROPERTY in property:                              if property[__class__.DEFAULT_PROPERTY]:                                  default_property = property[__class__.NAME]                              del property[__class__.DEFAULT_PROPERTY]                  element_desc[__class__.DEFAULT_PROPERTY] = default_property                # Resolve inheritance              def merge(                  element_desc, parent_element_desc, default_property: str              ) -> Optional[str]:                  element_properties = element_desc.get(__class__.PROPERTIES, [])                  element_property_names = [p[__class__.NAME] for p in element_properties]                  for property in parent_element_desc.get(__class__.PROPERTIES, []):                      property_name = property[__class__.NAME]                      if property_name in element_property_names:                          element_property = element_properties[                              element_property_names.index(property_name)                          ]                          for n in [\"type\", \"default_value\", \"doc\"]:                              if not n in element_property and n in property:                                  element_property[n] = property[n]                      else:                          element_property_names.append(property_name)                          element_properties.append(property)                  element_desc[__class__.PROPERTIES] = element_properties                  if not default_property and parent_element_desc.get(                      __class__.DEFAULT_PROPERTY, False                  ):                      default_property = parent_element_desc[__class__.DEFAULT_PROPERTY]                  return default_property                def resolve_inheritance(element_desc):                  if parent_types := element_desc.get(__class__.INHERITS, None):                      del element_desc[__class__.INHERITS]                      original_default_property = element_desc[__class__.DEFAULT_PROPERTY]                      default_property = original_default_property                      for parent_type in parent_types:                          parent_desc = self.elements[parent_type]                          resolve_inheritance(parent_desc)                          default_property = merge(                              element_desc, parent_desc, default_property                          )                      if original_default_property != default_property:                          element_desc[__class__.DEFAULT_PROPERTY] = default_property                for element_desc in self.elements.values():                  resolve_inheritance(element_desc)            self.elements = {}          self.categories = {}          load_elements(              self,              setup.root_dir + \"/taipy/gui/viselements.json\",              \"\",              self.VISELEMENTS_DIR_PATH,          )          load_elements(              self,              setup.root_dir + \"/taipy/gui_core/viselements.json\",              \"core_\",              self.CORELEMENTS_DIR_PATH,          )            # Check that documented elements have a default property and a doc file,          # and that their properties have the mandatory settings.          for category, element_type in [              (c, e) for c, elts in self.categories.items() for e in elts          ]:              if category == \"undocumented\":                  continue              element_desc = self.elements[element_type]              if not __class__.DEFAULT_PROPERTY in element_desc:                  raise ValueError(                      f\"FATAL - No default property for element type '{element_type}'\"                  )              if not __class__.PROPERTIES in element_desc:                  raise ValueError(                      f\"FATAL - No properties for element type '{element_type}'\"                  )              template_path = f\"{element_desc['doc_path']}/{element_type}.md_template\"              if not os.access(template_path, os.R_OK):                  raise FileNotFoundError(                      f\"FATAL - Could not find template doc file for element type '{element_type}' at {template_path}\"                  )              # Check completeness              for property in element_desc[__class__.PROPERTIES]:                  for n in [\"type\", \"doc\"]:                      if not n in property:                          raise ValueError(                              f\"FATAL - No value for '{n}' in the '{property[__class__.NAME]}' properties of element type '{element_type}' in {element_desc['source']}\"                          )        # Generate element doc pages for that category      # Find first level 2 or 3 header      def generate_pages(self, category: str, md_path: str) -> None:          FIRST_PARA_RE = re.compile(r\"(^.*?)(:?\\n\\n)\", re.MULTILINE | re.DOTALL)          # Find first level 2 or 3 header          FIRST_HEADER_RE = re.compile(r\"(^.*?)(\\n#+\\s+)\", re.MULTILINE | re.DOTALL)            md_template = \"\"          with open(f\"{md_path}_template\") as template_file:              md_template = template_file.read()          if not md_template:              raise FileNotFoundError(                  f\"FATAL - Could not read {md_path}_template markdown template\"              )          prefixes = set([desc[\"prefix\"] for desc in self.elements.values()])          toc = {}          for prefix in prefixes:              toc[prefix] = '<div class=\"tp-ve-cards\">\\n'            def generate_element_doc(element_type: str, element_desc: Dict, prefix: str):              \"\"\"              Returns the entry for the Table of Contents that is inserted              in the global Visual Elements or Core Elements doc page.              \"\"\"              template_doc_path = f\"{element_desc['doc_path']}/{element_type}.md_template\"              with open(template_doc_path, \"r\") as template_doc_file:                  element_documentation = template_doc_file.read()              # Retrieve first paragraph from element documentation              match = FIRST_PARA_RE.match(element_documentation)              if not match:                  raise ValueError(                      f\"Couldn't locate first paragraph in documentation for element '{element_type}'\"                  )              first_documentation_paragraph = match.group(1)              element_desc['short_doc'] = first_documentation_paragraph                # Build properties table              properties_table = \"\"\"  # Properties\\n\\n  <table>  <thead>      <tr>      <th>Name</th>      <th>Type</th>      <th>Default</th>      <th>Description</th>      </tr>  </thead>  <tbody>  \"\"\"              STAR = \"(&#9733;)\"              default_property_name = element_desc[__class__.DEFAULT_PROPERTY]              # Convert properties array to a dict              property_descs = {p[\"name\"]: p for p in element_desc[__class__.PROPERTIES]}              for property_name in [default_property_name] + list(                  filter(lambda x: x != default_property_name, property_descs.keys())              ):                  property_desc = property_descs[property_name]                  name = property_desc[__class__.NAME]                  type = property_desc[\"type\"]                  if m := re.match(r\"dynamic\\((.*?)\\)\", type):                      type = f\"<code>{m[1]}</code><br/><i>dynamic</i>\"                  elif m := re.match(r\"indexed\\((.*?)\\)\", type):                      type = f\"<code>{m[1]}</code><br/><i>indexed</i>\"                  else:                      type = f\"<code>{type}</code>\"                  default_value = property_desc.get(\"default_value\", None)                  doc = property_desc.get(\"doc\", None)                  if not default_value:                      default_value = (                          \"<i>Required</i>\"                          if property_desc.get(\"required\", False)                          else \"\"                      )                  full_name = f\"<code id=\\\"p-{re.sub('<[^>]+>', '', name)}\\\">\"                  if name == default_property_name:                      full_name += f'<u><bold>{name}</bold></u></code><sup><a href=\"#dv\">{STAR}</a></sup>'                  else:                      full_name += f\"{name}</code>\"                  properties_table += (                      \"<tr>\\n\"                      + f\"<td nowrap>{full_name}</td>\\n\"                      + f\"<td>{type}</td>\\n\"                      + f\"<td nowrap>{default_value}</td>\\n\"                      + f\"<td><p>{doc}</p></td>\\n\"                      + \"</tr>\\n\"                  )              properties_table += \"  </tbody>\\n</table>\\n\\n\"              if default_property_name:                  properties_table += (                      f'<p><sup id=\"dv\">{STAR}</sup>'                      + f'<a href=\"#p-{default_property_name}\" title=\"Jump to the default property documentation.\">'                      + f\"<code>{default_property_name}</code></a>\"                      + \" is the default property for this visual element.</p>\\n\"                  )                # Insert title and properties in element documentation              match = FIRST_HEADER_RE.match(element_documentation)              if not match:                  raise ValueError(                      f\"Couldn't locate first header in documentation for element '{element_type}'\"                  )              before_properties = match.group(1)              after_properties = match.group(2) + element_documentation[match.end() :]                # Chart hook              if element_type == \"chart\":                  values = self.chart_page_hook(                      element_documentation, before_properties, after_properties                  )                  before_properties = values[0]                  after_properties = values[1]                with open(f\"{element_desc['doc_path']}/{element_type}.md\", \"w\") as md_file:                  md_file.write(                      f\"---\\ntitle: <tt>{element_type}</tt>\\nhide:\\n  - navigation\\n---\\n\\n\"                      + f\"<!-- Category: {category} -->\\n\"                      + before_properties                      + properties_table                      + after_properties                  )              e = element_type  # Shortcut              d = \"../corelements/\" if prefix == \"core_\" else \"\"              s = (                  ' style=\"font-size: .8em;\"'                  if e == \"scenario_selector\" or e == \"data_node_selector\"                  else \"\"              )              return (                  f'<a class=\"tp-ve-card\" href=\"../{d}{e}/\">\\n'                  + f\"<div{s}>{e}</div>\\n\"                  + f'<img class=\"tp-ve-l\" src=\"../{d}{e}-l.png\"/><img class=\"tp-ve-lh\" src=\"../{d}{e}-lh.png\"/>\\n'                  + f'<img class=\"tp-ve-d\" src=\"../{d}{e}-d.png\"/><img class=\"tp-ve-dh\" src=\"../{d}{e}-dh.png\"/>\\n'                  + f\"<p>{first_documentation_paragraph}</p>\\n\"                  + \"</a>\\n\"              )              # If you want a simple list, use              # f\"<li><a href=\\\"../{e}/\\\"><code>{e}</code></a>: {first_documentation_paragraph}</li>\\n\"              # The toc header and footer must then be \"<ui>\" and \"</ul>\" respectively.            for element_type in self.categories[category]:              element_desc = self.elements[element_type]              prefix = element_desc[\"prefix\"]              toc[prefix] += generate_element_doc(element_type, element_desc, prefix)            with open(md_path, \"w\") as md_file:              for prefix in prefixes:                  md_template = md_template.replace(                      f\"[{prefix}TOC]\", toc[prefix] + \"</div>\\n\"                  )              md_file.write(md_template)        def generate_builder_api(self) -> None:          separator = \"# Generated code for Page Builder\"          py_file = \"taipy/gui/builder/__init__.py\"          py_content = None          with open(py_file, \"r\") as file:              py_content = file.read()          # Remove generated code          if m := re.search(f\"\\\\n*{separator}\", py_content):              py_content = py_content[:m.start(0)+1]            def generate(self, category, base_class: str) -> str:                element_types = self.categories[category]              def build_doc(property, desc, indent: int):                  type = desc['type']                  dynamic = \"\"                  dynamic_re = re.match(r\"^dynamic\\(\\s*(.*)\\s*\\)$\", type)                  if False and dynamic_re:                      type = dynamic_re[1]                      dynamic = \" (<i>dynamic</i>)\"                  doc = \"\"                  if \"doc\" in desc:                      doc = str(desc[\"doc\"]).replace(\"\\n\", f'\\n{(indent+4)*\" \"}').replace(\"<br/>\", f'<br/>\\n{(indent+4)*\" \"}')                  default_value = f'{desc[\"default_value\"]}' if \"default_value\" in desc else \"\"                  if m := re.match(r\"^(<i>.*?</i>)$\", default_value):                      default_value = f\"\\\"{m[1]}\\\"\"                  elif m := re.match(r\"^`(.*?)`$\", default_value):                      default_value = f\"{m[1]}\"                  elif default_value == \"scatter\" or default_value == \"lines+markers\":                      default_value = f\"\\\"{default_value}\\\"\"                  if default_value:                      try:                          x = eval(default_value)                      except:                          raise SyntaxError(f\"Default value for property '{property}' of element '{element_type}' is not a valid Python expression ({default_value})\")                  return (f\"{property}={default_value if default_value else 'None'}, \",                           f\"{indent*' '}{desc['name']} ({type}){dynamic}: {doc}\\n\")                template = f\"\"\"    class [element_type]({base_class}):      '''[short_doc]        This class represents the [control_or_block] documented in the [element_md_page] section.      '''      _ELEMENT_NAME: str      def __init__(self, [arguments]) -> None:          '''Create a new `[element_type]` element.            Arguments:              [arguments_doc]          '''          ...  \"\"\"                buffer = StringIO()              docline_in_template = next(l for l in template.splitlines() if l.lstrip().startswith(\"[arguments_doc]\"))              doc_indent = len(docline_in_template) - len(docline_in_template.lstrip())                for element_type in element_types:                  desc = self.elements[element_type]                  properties = desc[\"properties\"]                  default_prop = next(                      p for p in properties if p[\"name\"] == desc[\"default_property\"]                  )                  doc = build_doc(default_prop['name'], default_prop, doc_indent)                  arguments = doc[0]                  arguments_doc = doc[1]                  for property in properties:                      property_name = property[\"name\"]                      if property_name != desc[\"default_property\"] and not \"[\" in property_name:                          doc = build_doc(property_name, property, doc_indent)                          arguments += doc[0]                          arguments_doc += doc[1]                  # Process short doc                  short_doc = desc[\"short_doc\"]                  if m := re.search(r\"(\\[`(\\w+)`\\]\\()\\2\\.md\\)\", short_doc):                      short_doc = short_doc[:m.start()]+f\"{m[1]}../gui/viselements/{m[2]}.md)\"+short_doc[m.end():]                  # Link to element doc page                  element_md_location = \"corelements\" if desc[\"prefix\"] == \"core_\" else \"viselements\"                  element_md_page = f\"[`{element_type}`](../gui/{element_md_location}/{element_type}.md)\"                  buffer.write(template.replace(\"[element_type]\", element_type)                                       .replace(\"[element_md_page]\", element_md_page)                                       .replace(\"[arguments]\", arguments)                                       .replace(\"[short_doc]\", short_doc)                                       .replace(\"[control_or_block]\", \"control\" if category==\"controls\" else \"block\")                                       .replace(\" \"*doc_indent+\"[arguments_doc]\\n\", arguments_doc))              s = buffer.getvalue()              return buffer.getvalue()            with open(py_file, \"wt\") as file:              file.write(py_content)              file.write(f\"\\n\\n{separator}\\n\\n\")              file.write(f\"from ._element import _Block, _Control\\n\\n\")              file.write(generate(self, \"controls\", \"_Control\"))              file.write(generate(self, \"blocks\",   \"_Block\"))        def setup(self, setup: Setup) -> None:          self.generate_pages(\"controls\", self.controls_path)          self.generate_pages(\"blocks\", self.blocks_path)          self.generate_builder_api()        # Special case for charts: we want to insert the chart gallery that is stored in the      # file whose path is in self.charts_home_html_path      # This should be inserted before the first level 1 header      def chart_page_hook(          self, element_documentation: str, before: str, after: str      ) -> tuple[str, str]:          with open(self.charts_home_html_path, \"r\") as html_fragment_file:              chart_gallery = html_fragment_file.read()              # The chart_gallery begins with a comment where all sub-sections              # are listed.          SECTIONS_RE = re.compile(              r\"^(?:\\s*<!--\\s+)(.*?)(?:-->)\", re.MULTILINE | re.DOTALL          )          match = SECTIONS_RE.match(chart_gallery)          if not match:              raise ValueError(                  f\"{self.charts_home_html_path} should begin with an HTML comment that lists the chart types\"              )          chart_gallery = \"\\n\" + chart_gallery[match.end() :]          SECTION_RE = re.compile(r\"^([\\w-]+):(.*)$\")          chart_sections = \"\"          for line in match.group(1).splitlines():              match = SECTION_RE.match(line)              if match:                  chart_sections += f\"- [{match.group(2)}](charts/{match.group(1)}.md)\\n\"            match = re.match(              r\"(^.*?)(?:\\n#\\s+)\", element_documentation, re.MULTILINE | re.DOTALL          )          if not match:              raise ValueError(                  f\"Couldn't locate first header1 in documentation for element 'chart'\"              )          return (              match.group(1) + chart_gallery + before[match.end() :],              after + chart_sections,          ) "}
{"text": "# ################################################################################  # Taipy Contributor list generation setup step.  #  # A contributors list is generated based on internal and external contributors  # retrieved using GitHub REST APIs.  # ################################################################################  import base64  import os  import random  import requests    from .setup import SetupStep, Setup      class ContributorsStep(SetupStep):        def __init__(self):          self.GH_TOKEN = os.getenv(\"GITHUB_TOKEN\", None)          self.BASE_URL = \"https://api.github.com\"          self.ORGANIZATION_URL = f\"{self.BASE_URL}/orgs/Avaiga\"          self.MEMBERS_URL = f\"{self.ORGANIZATION_URL}/members\"          self.REPOS = f\"{self.ORGANIZATION_URL}/repos\"          self.REPO_URLS = []          self.MEMBERS = {}          self.CONTRIBUTORS = {}          self.ANONYMOUS = [\"dependabot[bot]\"]          self.PATH = \"\"          self.TEMPLATE_SUFFIX = \"_template\"        def enter(self, setup: Setup):          self.PATH = os.path.join(setup.docs_dir, \"contributing\", \"contributors.md\")        def get_id(self) -> str:          return \"contributors\"        def get_description(self) -> str:          return \"Generating the contributors list.\"        def setup(self, setup: Setup) -> None:          try:              self.get_repo_urls()              self.get_avaiga_members()              self.get_contributors()              self.build_content((self.MEMBERS, \"[AVAIGA_TEAM_MEMBERS]\"), (self.CONTRIBUTORS, \"[TAIPY_CONTRIBUTORS]\"))          except Exception as e:              print(f\"WARNING - Exception raised while listing contributors:\\n{e}\")        def get_repo_urls(self):          response = self.__get(self.REPOS)          if response.status_code != 200:              print(f\"WARNING - Couldn't get repositories. response.status_code: {response.status_code}\", flush=True)              return          repos = response.json()          self.REPO_URLS = list(map(lambda _: _['url'], repos))        def get_avaiga_members(self):          response = self.__get(self.MEMBERS_URL, with_token=False)          if response.status_code != 200:              print(f\"WARNING - Couldn't get members. response.status_code: {response.status_code}\", flush=True)              return          members = response.json()          for member in members:              login = member['login']              if login not in self.MEMBERS and login not in self.ANONYMOUS:                  self.MEMBERS[login] = {\"avatar_url\": member['avatar_url'], \"html_url\": member['html_url']}        def get_contributors(self):          for url in self.REPO_URLS:              response = self.__get(url + \"/contents/contributors.txt\", ignore404=True)              public_contributor_logins = []              if response.status_code == 200:                  data = response.json()                  content = data[\"content\"]                  encoding = data[\"encoding\"]                  if encoding == 'base64':                      file_content = base64.b64decode(content).decode()                      public_contributor_logins += file_content.strip().split(\"\\n\")                  else:                      print(f\"WARNING - Couldn't get contributors from {url}. unknown encoding: {encoding}\", flush=True)                      continue              elif response.status_code == 404:                  print(f\"INFO - No contributors.txt in repository {url[len(self.BASE_URL)+14:]}.\", flush=True)              else:                  print(f\"WARNING - Couldn't get contributors for {url}. response.status_code: {response.status_code}\",                        flush=True)                  continue              response = self.__get(url+\"/contributors\")              if response.status_code != 200:                  print(f\"WARNING - Couldn't get contributors. response.status_code: {response.status_code}\", flush=True)                  continue              for c in response.json():                  login = c['login']                  if login not in self.MEMBERS and login not in self.ANONYMOUS and login in public_contributor_logins:                      self.CONTRIBUTORS[login] = {\"avatar_url\": c['avatar_url'], \"html_url\": c['html_url']}        def build_content(self, *members_pattern_tuples):          pattern_content_tuples = []          for member_pattern in members_pattern_tuples:              members = member_pattern[0]              pattern = member_pattern[1]              content = \"\"              members_list = list(members.items())              random.shuffle(members_list)              for login, member_info in members_list:                  if login not in self.ANONYMOUS:                      content += f\"\\n- [<img src='{member_info['avatar_url']}' alt='{login} GitHub avatar' width='20'/>\" \\                                      f\"{login}]\" \\                                      f\"({member_info['html_url']})\"              content += \"\\n\"              pattern_content_tuples.append((pattern, content))            self._replace(self.PATH, *pattern_content_tuples)        def _replace(self, path, *pattern_content_tuples):          # Read in the file          with open(path + self.TEMPLATE_SUFFIX, 'r') as file:              file_data = file.read()            # Replace the patterns by the contents          for pattern_content in pattern_content_tuples:              pattern = pattern_content[0]              content = pattern_content[1]              file_data = file_data.replace(pattern, content)            # Write the file out without the template suffix          with open(path, 'w') as file:              file.write(file_data)        def __get(self, url, with_token=True, ignore404:bool = False):          if with_token and self.GH_TOKEN:              headers = {                  \"Accept\": \"application/vnd.github+json\",                  \"Authorization\": \"Bearer \"+self.GH_TOKEN              }              #{'Authorization': f'token {self.GH_TOKEN}'}              return requests.get(url, headers=headers)          else:              return requests.get(url)        def exit(self, setup: Setup):          pass "}
{"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 os    import modin.pandas as modin_pd  import numpy as np  import pandas as pd  import pytest  import taipy.core as tp  from taipy.config import Config      def test_excel_multi_sheet():      from tests.shared_test_cases.multi_excel_sheets import (          EXCEL_INPUT_PATH,          EXCEL_OUTPUT_PATH,          ROW_COUNT,          SHEET_NAMES,          Row,          scenario_cfg,          scenario_cfg_2,          scenario_cfg_3,          scenario_cfg_4,      )        pandas_data = pd.read_excel(EXCEL_INPUT_PATH, sheet_name=SHEET_NAMES)      numpy_data = {sheet_name: pandas_data[sheet_name].to_numpy() for sheet_name in SHEET_NAMES}      modin_data = modin_pd.read_excel(EXCEL_INPUT_PATH, sheet_name=SHEET_NAMES)      custom_data = {}      for sheet_name in SHEET_NAMES:          rows = []          for _, row in pandas_data[sheet_name].iterrows():              rows.append(Row(int(row.id), int(row.age), float(row.rating)))          custom_data[sheet_name] = rows        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_multi_sheet_dataset_1      output_data_node_1 = scenario_1.output_excel_multi_sheet_dataset_1        read_data_1 = input_data_node_1.read()      assert len(read_data_1) == len(SHEET_NAMES)      assert all([pandas_data[sheet_name].equals(read_data_1[sheet_name]) for sheet_name in SHEET_NAMES])        assert output_data_node_1.read() is None      output_data_node_1.write(read_data_1)      assert len(output_data_node_1.read()) == len(SHEET_NAMES)      assert all([pandas_data[sheet_name].equals(output_data_node_1.read()[sheet_name]) for sheet_name in SHEET_NAMES])        output_data_node_1.write({sheet_name: pd.DataFrame() for sheet_name in SHEET_NAMES})        scenario_1.submit()      assert all([pandas_data[sheet_name].equals(output_data_node_1.read()[sheet_name]) for sheet_name in SHEET_NAMES])        os.remove(EXCEL_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_multi_sheet_dataset_2      # output_data_node_2 = scenario_2.output_excel_multi_sheet_dataset_2        # read_data_2 = input_data_node_2.read()      # assert len(read_data_2) == len(SHEET_NAMES)      # assert all(compare_custom_date(read_data_2[sheet_name], custom_data[sheet_name]) for sheet_name in SHEET_NAMES)        # breakpoint()      # output_data_node_2.write(read_data_2)      # assert len(read_data_2) == len(SHEET_NAMES)      # print(output_data_node_2.read())    #TODO: failed write function      # assert all(compare_custom_date(read_data_2[sheet_name], output_data_node_2.read()[sheet_name]) for sheet_name in SHEET_NAMES)        # output_data_node_2.write(None)      # assert isinstance(output_data_node_2.read(), list)      # assert len(output_data_node_2.read()) == 0      # sequence_2.submit()      # assert all(compare_custom_date(read_data_2[sheet_name], output_data_node_2.read()[sheet_name]) for sheet_name in SHEET_NAMES)        # 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(read_data_2[sheet_name], output_data_node_2.read()[sheet_name]) for sheet_name in SHEET_NAMES)        # os.remove(EXCEL_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_multi_sheet_dataset_3      output_data_node_3 = scenario_3.output_excel_multi_sheet_dataset_3        read_data_3 = input_data_node_3.read()      assert len(read_data_3) == len(SHEET_NAMES)      assert [np.array_equal(read_data_3[sheet_name], numpy_data[sheet_name]) for sheet_name in SHEET_NAMES]        assert output_data_node_3.read() is None      output_data_node_3.write(read_data_3)      assert len(output_data_node_3.read()) == len(SHEET_NAMES)      assert [          np.array_equal(read_data_3[sheet_name], output_data_node_3.read()[sheet_name]) for sheet_name in SHEET_NAMES      ]        # output_data_node_3.write(None)      # with pytest.raises(ValueError):      #     assert output_data_node_1.read()        scenario_3.submit()      assert [          np.array_equal(read_data_3[sheet_name], output_data_node_3.read()[sheet_name]) for sheet_name in SHEET_NAMES      ]        os.remove(EXCEL_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_multi_sheet_dataset_4      output_data_node_4 = scenario_4.output_excel_multi_sheet_dataset_4        read_data_4 = input_data_node_4.read()      assert len(read_data_4) == len(SHEET_NAMES)      assert all(          [all(modin_data[sheet_name]._to_pandas() == read_data_4[sheet_name]._to_pandas()) for sheet_name in SHEET_NAMES]      )        assert output_data_node_4.read() is None      output_data_node_4.write(read_data_4)      assert len(read_data_4) == len(SHEET_NAMES)      assert all(          [              all(modin_data[sheet_name]._to_pandas() == output_data_node_4.read()[sheet_name]._to_pandas())              for sheet_name in SHEET_NAMES          ]      )        # output_data_node_4.write(None)      # with pytest.raises(ValueError):      #     output_data_node_4.read()  # TODO: test excel file has no header provided        scenario_4.submit()      assert all(          [              all(modin_data[sheet_name]._to_pandas() == output_data_node_4.read()[sheet_name]._to_pandas())              for sheet_name in SHEET_NAMES          ]      )        os.remove(EXCEL_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 datetime as dt  from time import sleep    import numpy as np  import pandas as pd  from sklearn.ensemble import RandomForestClassifier  from sklearn.linear_model import LogisticRegression  from sklearn.metrics import roc_auc_score  from sklearn.model_selection import train_test_split      def sum(a, b):      a = a[\"number\"]      b = b[\"number\"]      return a + b      def subtract(a, b):      a = a[\"number\"]      b = b[\"number\"]      return a - b      def mult(a, b):      return a * b      def mult_by_2(a):      return a      def divide(a, b):      return a / b      def average(a):      return [a.sum() / len(a)]      def div_constant_with_sleep(a):      sleep(1)      return a[\"number\"] / 10      def return_a_number():      return 10      def return_a_number_with_sleep():      sleep(1)      return 10      def preprocess_dataset(initial_dataset: pd.DataFrame, date: dt.datetime = None):      \"\"\"This function preprocess the dataset to be used in the model      Args:          initial_dataset (pd.DataFrame): the raw format when we first read the data      Returns:          pd.DataFrame: the preprocessed dataset for classification      \"\"\"      print(\"\\n     Preprocessing the dataset...\")        # We filter the dataframe on the date      if date != \"None\":          initial_dataset[\"Date\"] = pd.to_datetime(initial_dataset[\"Date\"])          processed_dataset = initial_dataset[initial_dataset[\"Date\"] <= date]          print(len(processed_dataset))      else:          processed_dataset = initial_dataset        processed_dataset = processed_dataset[          [              \"CreditScore\",              \"Geography\",              \"Gender\",              \"Age\",              \"Tenure\",              \"Balance\",              \"NumOfProducts\",              \"HasCrCard\",              \"IsActiveMember\",              \"EstimatedSalary\",              \"Exited\",          ]      ]        processed_dataset = pd.get_dummies(processed_dataset)        if \"Gender_Female\" in processed_dataset.columns:          processed_dataset.drop(\"Gender_Female\", axis=1, inplace=True)        processed_dataset = processed_dataset.apply(pd.to_numeric)        columns_to_select = [          \"CreditScore\",          \"Age\",          \"Tenure\",          \"Balance\",          \"NumOfProducts\",          \"HasCrCard\",          \"IsActiveMember\",          \"EstimatedSalary\",          \"Geography_France\",          \"Geography_Germany\",          \"Geography_Spain\",          \"Gender_Male\",          \"Exited\",      ]        processed_dataset = processed_dataset[[col for col in columns_to_select if col in processed_dataset.columns]]        print(\"     Preprocessing done!\\n\")      return processed_dataset      def create_train_test_data(preprocessed_dataset: pd.DataFrame):      \"\"\"This function will create the train data by segmenting the dataset      Args:          preprocessed_dataset (pd.DataFrame): the preprocessed dataset      Returns:          pd.DataFrame: the training dataset      \"\"\"      print(\"\\n     Creating the training and testing dataset...\")        X_train, X_test, y_train, y_test = train_test_split(          preprocessed_dataset.iloc[:, :-1], preprocessed_dataset.iloc[:, -1], test_size=0.2, random_state=42      )        train_data = pd.concat([X_train, y_train], axis=1)      test_data = pd.concat([X_test, y_test], axis=1)      print(\"     Creating done!\")      return train_data, test_data      def train_model_baseline(train_dataset: pd.DataFrame):      \"\"\"Function to train the Logistic Regression model      Args:          train_dataset (pd.DataFrame): the training dataset      Returns:          model (LogisticRegression): the fitted model      \"\"\"      print(\"     Training the model...\\n\")      X, y = train_dataset.iloc[:, :-1], train_dataset.iloc[:, -1]      model_fitted = LogisticRegression().fit(X, y)      print(\"\\n    \", model_fitted, \" is trained!\")        importance_dict = {\"Features\": X.columns, \"Importance\": model_fitted.coef_[0]}      importance = pd.DataFrame(importance_dict).sort_values(by=\"Importance\", ascending=True)      return model_fitted, importance      def train_model(train_dataset: pd.DataFrame):      \"\"\"Function to train the Logistic Regression model      Args:          train_dataset (pd.DataFrame): the training dataset      Returns:          model (RandomForest): the fitted model      \"\"\"      print(\"     Training the model...\\n\")      X, y = train_dataset.iloc[:, :-1], train_dataset.iloc[:, -1]      model_fitted = RandomForestClassifier().fit(X, y)      print(\"\\n    \", model_fitted, \" is trained!\")        importance_dict = {\"Features\": X.columns, \"Importance\": model_fitted.feature_importances_}      importance = pd.DataFrame(importance_dict).sort_values(by=\"Importance\", ascending=True)      return model_fitted, importance      def forecast(test_dataset: pd.DataFrame, trained_model: RandomForestClassifier):      \"\"\"Function to forecast the test dataset      Args:          test_dataset (pd.DataFrame): the test dataset          trained_model (LogisticRegression): the fitted model      Returns:          forecast (pd.DataFrame): the forecasted dataset      \"\"\"      print(\"     Forecasting the test dataset...\")      X, y = test_dataset.iloc[:, :-1], test_dataset.iloc[:, -1]      # predictions = trained_model.predict(X)      predictions = trained_model.predict_proba(X)[:, 1]      print(\"     Forecasting done!\")      return predictions      def forecast_baseline(test_dataset: pd.DataFrame, trained_model: LogisticRegression):      \"\"\"Function to forecast the test dataset      Args:          test_dataset (pd.DataFrame): the test dataset          trained_model (LogisticRegression): the fitted model      Returns:          forecast (pd.DataFrame): the forecasted dataset      \"\"\"      print(\"     Forecasting the test dataset...\")      X, y = test_dataset.iloc[:, :-1], test_dataset.iloc[:, -1]      predictions = trained_model.predict_proba(X)[:, 1]      print(\"     Forecasting done!\")      return predictions      def roc_from_scratch(probabilities, test_dataset, partitions=100):      print(\"     Calculation of the ROC curve...\")      y_test = test_dataset.iloc[:, -1]        roc = np.array([])      for i in range(partitions + 1):          threshold_vector = np.greater_equal(probabilities, i / partitions).astype(int)          tpr, fpr = true_false_positive(threshold_vector, y_test)          roc = np.append(roc, [fpr, tpr])        roc_np = roc.reshape(-1, 2)      roc_data = pd.DataFrame({\"False positive rate\": roc_np[:, 0], \"True positive rate\": roc_np[:, 1]})      print(\"     Calculation done\")      print(\"     Scoring...\")        score_auc = roc_auc_score(y_test, probabilities)      print(\"     Scoring done\\n\")        return roc_data, score_auc      def true_false_positive(threshold_vector: np.array, y_test: np.array):      \"\"\"Function to calculate the true positive rate and the false positive rate        Args:          threshold_vector (np.array): the test dataset          y_test (np.array): the fitted model      Returns:          tpr (pd.DataFrame): the forecasted dataset          fpr (pd.DataFrame): the forecasted dataset      \"\"\"        true_positive = np.equal(threshold_vector, 1) & np.equal(y_test, 1)      true_negative = np.equal(threshold_vector, 0) & np.equal(y_test, 0)      false_positive = np.equal(threshold_vector, 1) & np.equal(y_test, 0)      false_negative = np.equal(threshold_vector, 0) & np.equal(y_test, 1)        tpr = true_positive.sum() / (true_positive.sum() + false_negative.sum())      fpr = false_positive.sum() / (false_positive.sum() + true_negative.sum())        return tpr, fpr      def create_metrics(predictions: np.array, test_dataset: np.array):      print(\"     Creating the metrics...\")      threshold = 0.5      threshold_vector = np.greater_equal(predictions, threshold).astype(int)        y_test = test_dataset.iloc[:, -1]        true_positive = (np.equal(threshold_vector, 1) & np.equal(y_test, 1)).sum()      true_negative = (np.equal(threshold_vector, 0) & np.equal(y_test, 0)).sum()      false_positive = (np.equal(threshold_vector, 1) & np.equal(y_test, 0)).sum()      false_negative = (np.equal(threshold_vector, 0) & np.equal(y_test, 1)).sum()        f1_score = np.around(2 * true_positive / (2 * true_positive + false_positive + false_negative), decimals=2)      accuracy = np.around(          (true_positive + true_negative) / (true_positive + true_negative + false_positive + false_negative), decimals=2      )      dict_ftpn = {\"tp\": true_positive, \"tn\": true_negative, \"fp\": false_positive, \"fn\": false_negative}        number_of_good_predictions = true_positive + true_negative      number_of_false_predictions = false_positive + false_negative        metrics = {          \"f1_score\": f1_score,          \"accuracy\": accuracy,          \"dict_ftpn\": dict_ftpn,          \"number_of_predictions\": len(predictions),          \"number_of_good_predictions\": number_of_good_predictions,          \"number_of_false_predictions\": number_of_false_predictions,      }        print(\"     Creating the metrics done!\")      return metrics      def create_results(forecast_values, test_dataset):      forecast_series_proba = pd.Series(          np.around(forecast_values, decimals=2), index=test_dataset.index, name=\"Probability\"      )      forecast_series = pd.Series((forecast_values > 0.5).astype(int), index=test_dataset.index, name=\"Forecast\")      true_series = pd.Series(test_dataset.iloc[:, -1], name=\"Historical\", index=test_dataset.index)      index_series = pd.Series(range(len(true_series)), index=test_dataset.index, name=\"Id\")        results = pd.concat([index_series, forecast_series_proba, forecast_series, true_series], axis=1)      return results "}
{"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": "import datetime as dt  import os  import pathlib    from taipy.config import Config, Frequency, Scope    from .complex_application_algos import (      average,      create_metrics,      create_results,      create_train_test_data,      divide,      forecast,      forecast_baseline,      mult,      mult_by_2,      preprocess_dataset,      return_a_number,      roc_from_scratch,      subtract,      sum,      train_model,      train_model_baseline,  )      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_config_1, task_config_2])        return scenario_config      def build_complex_required_file_paths():      csv_path_inp = os.path.join(          pathlib.Path(__file__).parent.resolve(),          \"shared_test_cases/data_sample/example.csv\",      )      excel_path_inp = os.path.join(          pathlib.Path(__file__).parent.resolve(),          \"shared_test_cases/data_sample/example.xlsx\",      )        csv_path_sum = os.path.join(pathlib.Path(__file__).parent.resolve(), \"shared_test_cases/data_sample/sum.csv\")      excel_path_sum = os.path.join(          pathlib.Path(__file__).parent.resolve(),          \"shared_test_cases/data_sample/sum.xlsx\",      )        excel_path_out = os.path.join(          pathlib.Path(__file__).parent.resolve(),          \"shared_test_cases/data_sample/res.xlsx\",      )      csv_path_out = os.path.join(pathlib.Path(__file__).parent.resolve(), \"shared_test_cases/data_sample/res.csv\")      return (          csv_path_inp,          excel_path_inp,          csv_path_sum,          excel_path_sum,          excel_path_out,          csv_path_out,      )      def build_complex_config():      (          csv_path_inp,          excel_path_inp,          csv_path_sum,          excel_path_sum,          excel_path_out,          csv_path_out,      ) = build_complex_required_file_paths()        inp_csv_dn_1 = Config.configure_csv_data_node(\"dn_csv_in_1\", default_path=csv_path_inp)      inp_csv_dn_2 = Config.configure_csv_data_node(\"dn_csv_in_2\", default_path=csv_path_inp)        inp_excel_dn_1 = Config.configure_excel_data_node(\"dn_excel_in_1\", default_path=excel_path_inp, sheet_name=\"Sheet1\")      inp_excel_dn_2 = Config.configure_excel_data_node(\"dn_excel_in_2\", default_path=excel_path_inp, sheet_name=\"Sheet1\")        placeholder = Config.configure_data_node(id=\"dn_placeholder\", default_data=10)        dn_csv_sum = Config.configure_csv_data_node(\"dn_sum_csv\", default_path=csv_path_sum)      dn_excel_sum = Config.configure_excel_data_node(\"dn_sum_excel\", default_path=excel_path_sum, sheet_name=\"Sheet1\")        dn_subtract_csv_excel = Config.configure_pickle_data_node(\"dn_subtract_csv_excel\")      dn_mult = Config.configure_pickle_data_node(\"dn_mult\")      dn_div = Config.configure_pickle_data_node(\"dn_div\")        output_csv_dn = Config.configure_csv_data_node(\"csv_out\", csv_path_out)      output_excel_dn = Config.configure_excel_data_node(\"excel_out\", excel_path_out)        task_print_csv = Config.configure_task(\"task_print_csv\", print, input=inp_csv_dn_1)      task_print_excel = Config.configure_task(\"task_print_excel\", print, input=inp_excel_dn_1)      task_sum_csv = Config.configure_task(\"task_sum_csv\", sum, input=[inp_csv_dn_2, inp_csv_dn_1], output=dn_csv_sum)      task_sum_excel = Config.configure_task(          \"task_sum_excel\",          sum,          input=[inp_excel_dn_2, inp_excel_dn_1],          output=dn_excel_sum,      )        task_subtract_csv_excel = Config.configure_task(          \"task_subtract_csv_excel\",          subtract,          input=[dn_csv_sum, dn_excel_sum],          output=dn_subtract_csv_excel,      )      task_insert_placeholder = Config.configure_task(\"task_insert_placeholder\", return_a_number, output=[placeholder])      task_mult = Config.configure_task(          \"task_mult_by_placeholder\",          mult,          input=[dn_subtract_csv_excel, placeholder],          output=dn_mult,      )      task_div = Config.configure_task(\"task_div_by_placeholder\", divide, input=[dn_mult, placeholder], output=dn_div)      task_avg_div = Config.configure_task(\"task_avg_div\", average, input=dn_div, output=output_csv_dn)      task_avg_mult = Config.configure_task(\"task_avg_mult\", average, input=dn_mult, output=output_excel_dn)        scenario_config = Config.configure_scenario(          \"scenario\",          [              task_print_csv,              task_print_excel,              task_sum_csv,              task_sum_excel,              task_subtract_csv_excel,              task_insert_placeholder,              task_mult,              task_div,              task_avg_div,              task_avg_mult,          ],      )        return scenario_config      def build_churn_classification_required_file_paths():      csv_path_inp = os.path.join(          pathlib.Path(__file__).parent.resolve(),          \"shared_test_cases/data_sample/churn.csv\",      )      return csv_path_inp      def build_churn_classification_config():      csv_path_inp = build_churn_classification_required_file_paths()        # path for csv and file_path for pickle      initial_dataset = Config.configure_data_node(          id=\"initial_dataset\", path=csv_path_inp, storage_type=\"csv\", has_header=True      )        date_cfg = Config.configure_data_node(id=\"date\", default_data=\"None\")        preprocessed_dataset = Config.configure_data_node(          id=\"preprocessed_dataset\", cacheable=True, validity_period=dt.timedelta(days=1)      )        # the final datanode that contains the processed data      train_dataset = Config.configure_data_node(id=\"train_dataset\", cacheable=True, validity_period=dt.timedelta(days=1))        # the final datanode that contains the processed data      trained_model = Config.configure_data_node(id=\"trained_model\", cacheable=True, validity_period=dt.timedelta(days=1))        trained_model_baseline = Config.configure_data_node(          id=\"trained_model_baseline\",          cacheable=True,          validity_period=dt.timedelta(days=1),      )        # the final datanode that contains the processed data      test_dataset = Config.configure_data_node(id=\"test_dataset\", cacheable=True, validity_period=dt.timedelta(days=1))        forecast_baseline_dataset = Config.configure_data_node(          id=\"forecast_baseline_dataset\",          scope=Scope.SCENARIO,          # cacheable=True,          # validity_period=dt.timedelta(days=1),      )        forecast_test_dataset = Config.configure_data_node(          id=\"forecast_test_dataset\",          scope=Scope.SCENARIO,          # cacheable=True,          # validity_period=dt.timedelta(days=1),      )        roc_data = Config.configure_data_node(          id=\"roc_data\",          scope=Scope.SCENARIO,          # cacheable=True,          # validity_period=dt.timedelta(days=1),      )        score_auc = Config.configure_data_node(          id=\"score_auc\",          scope=Scope.SCENARIO,          # cacheable=True,          # validity_period=dt.timedelta(days=1),      )        metrics = Config.configure_data_node(          id=\"metrics\",          scope=Scope.SCENARIO,          # cacheable=True,          # validity_period=dt.timedelta(days=1),      )        feature_importance_cfg = Config.configure_data_node(id=\"feature_importance\", scope=Scope.SCENARIO)        results = Config.configure_data_node(          id=\"results\",          scope=Scope.SCENARIO,          # cacheable=True,          # validity_period=dt.timedelta(days=1),      )        ##############################################################################################################################      # Creation of the tasks      ##############################################################################################################################        # the task will make the link between the input data node      # and the output data node while executing the function        # initial_dataset --> preprocess dataset --> preprocessed_dataset      task_preprocess_dataset = Config.configure_task(          id=\"preprocess_dataset\",          input=[initial_dataset, date_cfg],          function=preprocess_dataset,          output=preprocessed_dataset,      )        # preprocessed_dataset --> create train data --> train_dataset, test_dataset      task_create_train_test = Config.configure_task(          id=\"create_train_and_test_data\",          input=preprocessed_dataset,          function=create_train_test_data,          output=[train_dataset, test_dataset],      )        # train_dataset --> create train_model data --> trained_model      task_train_model = Config.configure_task(          id=\"train_model\",          input=train_dataset,          function=train_model,          output=[trained_model, feature_importance_cfg],      )        # train_dataset --> create train_model data --> trained_model      task_train_model_baseline = Config.configure_task(          id=\"train_model_baseline\",          input=train_dataset,          function=train_model_baseline,          output=[trained_model_baseline, feature_importance_cfg],      )        # test_dataset --> forecast --> forecast_dataset      task_forecast = Config.configure_task(          id=\"predict_the_test_data\",          input=[test_dataset, trained_model],          function=forecast,          output=forecast_test_dataset,      )        # test_dataset --> forecast --> forecast_dataset      task_forecast_baseline = Config.configure_task(          id=\"predict_of_baseline\",          input=[test_dataset, trained_model_baseline],          function=forecast_baseline,          output=forecast_baseline_dataset,      )        task_roc = Config.configure_task(          id=\"task_roc\",          input=[forecast_test_dataset, test_dataset],          function=roc_from_scratch,          output=[roc_data, score_auc],      )        task_roc_baseline = Config.configure_task(          id=\"task_roc_baseline\",          input=[forecast_baseline_dataset, test_dataset],          function=roc_from_scratch,          output=[roc_data, score_auc],      )        task_create_metrics = Config.configure_task(          id=\"task_create_metrics\",          input=[forecast_test_dataset, test_dataset],          function=create_metrics,          output=metrics,      )        task_create_results = Config.configure_task(          id=\"task_create_results\",          input=[forecast_test_dataset, test_dataset],          function=create_results,          output=results,      )        task_create_baseline_metrics = Config.configure_task(          id=\"task_create_baseline_metrics\",          input=[forecast_baseline_dataset, test_dataset],          function=create_metrics,          output=metrics,      )        task_create_baseline_results = Config.configure_task(          id=\"task_create_baseline_results\",          input=[forecast_baseline_dataset, test_dataset],          function=create_results,          output=results,      )        ##############################################################################################################################      # Creation of the sequence and the scenario      ##############################################################################################################################        # the scenario will run the sequences      scenario_cfg = Config.configure_scenario(          id=\"churn_classification\",          task_configs=[              task_preprocess_dataset,              task_create_train_test,              task_train_model_baseline,              task_train_model,              task_forecast,              task_roc,              task_create_metrics,              task_create_results,              task_forecast_baseline,              task_roc_baseline,              task_create_metrics,              task_create_results,              task_create_baseline_metrics,              task_create_baseline_results,          ],          frequency=Frequency.WEEKLY,      )        return scenario_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 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": "import datetime as dt  from time import sleep    import numpy as np  import pandas as pd  from sklearn.ensemble import RandomForestClassifier  from sklearn.linear_model import LogisticRegression  from sklearn.metrics import roc_auc_score  from sklearn.model_selection import train_test_split      def sum(a, b):      a = a[\"number\"]      b = b[\"number\"]      return a + b      def subtract(a, b):      a = a[\"number\"]      b = b[\"number\"]      return a - b      def mult(a, b):      return a * b      def divide(a, b):      return a / b      def average(a):      return [a.sum() / len(a)]      def div_constant_with_sleep(a):      sleep(0.5)      return a[\"number\"] / 10      def return_a_number():      return 10      def return_a_number_with_sleep():      sleep(0.5)      return 10      def preprocess_dataset(initial_dataset: pd.DataFrame, date: dt.datetime = None):      \"\"\"This function preprocess the dataset to be used in the model      Args:          initial_dataset (pd.DataFrame): the raw format when we first read the data      Returns:          pd.DataFrame: the preprocessed dataset for classification      \"\"\"      # print(\"\\n     Preprocessing the dataset...\")        # We filter the dataframe on the date      if date != \"None\":          initial_dataset[\"Date\"] = pd.to_datetime(initial_dataset[\"Date\"])          processed_dataset = initial_dataset[initial_dataset[\"Date\"] <= date]          # print(len(processed_dataset))      else:          processed_dataset = initial_dataset        processed_dataset = processed_dataset[          [              \"CreditScore\",              \"Geography\",              \"Gender\",              \"Age\",              \"Tenure\",              \"Balance\",              \"NumOfProducts\",              \"HasCrCard\",              \"IsActiveMember\",              \"EstimatedSalary\",              \"Exited\",          ]      ]        processed_dataset = pd.get_dummies(processed_dataset)        if \"Gender_Female\" in processed_dataset.columns:          processed_dataset.drop(\"Gender_Female\", axis=1, inplace=True)        processed_dataset = processed_dataset.apply(pd.to_numeric)        columns_to_select = [          \"CreditScore\",          \"Age\",          \"Tenure\",          \"Balance\",          \"NumOfProducts\",          \"HasCrCard\",          \"IsActiveMember\",          \"EstimatedSalary\",          \"Geography_France\",          \"Geography_Germany\",          \"Geography_Spain\",          \"Gender_Male\",          \"Exited\",      ]        processed_dataset = processed_dataset[[col for col in columns_to_select if col in processed_dataset.columns]]        # print(\"     Preprocessing done!\\n\")      return processed_dataset      def create_train_test_data(preprocessed_dataset: pd.DataFrame):      \"\"\"This function will create the train data by segmenting the dataset      Args:          preprocessed_dataset (pd.DataFrame): the preprocessed dataset      Returns:          pd.DataFrame: the training dataset      \"\"\"      # print(\"\\n     Creating the training and testing dataset...\")        X_train, X_test, y_train, y_test = train_test_split(          preprocessed_dataset.iloc[:, :-1], preprocessed_dataset.iloc[:, -1], test_size=0.2, random_state=42      )        train_data = pd.concat([X_train, y_train], axis=1)      test_data = pd.concat([X_test, y_test], axis=1)      # print(\"     Creating done!\")      return train_data, test_data      def train_model_baseline(train_dataset: pd.DataFrame):      \"\"\"Function to train the Logistic Regression model      Args:          train_dataset (pd.DataFrame): the training dataset      Returns:          model (LogisticRegression): the fitted model      \"\"\"      # print(\"     Training the model...\\n\")      X, y = train_dataset.iloc[:, :-1], train_dataset.iloc[:, -1]      model_fitted = LogisticRegression().fit(X, y)      # print(\"\\n    \",model_fitted,\" is trained!\")        importance_dict = {\"Features\": X.columns, \"Importance\": model_fitted.coef_[0]}      importance = pd.DataFrame(importance_dict).sort_values(by=\"Importance\", ascending=True)      return model_fitted, importance      def train_model(train_dataset: pd.DataFrame):      \"\"\"Function to train the Logistic Regression model      Args:          train_dataset (pd.DataFrame): the training dataset      Returns:          model (RandomForest): the fitted model      \"\"\"      # print(\"     Training the model...\\n\")      X, y = train_dataset.iloc[:, :-1], train_dataset.iloc[:, -1]      model_fitted = RandomForestClassifier().fit(X, y)      # print(\"\\n    \",model_fitted,\" is trained!\")        importance_dict = {\"Features\": X.columns, \"Importance\": model_fitted.feature_importances_}      importance = pd.DataFrame(importance_dict).sort_values(by=\"Importance\", ascending=True)      return model_fitted, importance      def forecast(test_dataset: pd.DataFrame, trained_model: RandomForestClassifier):      \"\"\"Function to forecast the test dataset      Args:          test_dataset (pd.DataFrame): the test dataset          trained_model (LogisticRegression): the fitted model      Returns:          forecast (pd.DataFrame): the forecasted dataset      \"\"\"      # print(\"     Forecasting the test dataset...\")      X, y = test_dataset.iloc[:, :-1], test_dataset.iloc[:, -1]      # predictions = trained_model.predict(X)      predictions = trained_model.predict_proba(X)[:, 1]      # print(\"     Forecasting done!\")      return predictions      def forecast_baseline(test_dataset: pd.DataFrame, trained_model: LogisticRegression):      \"\"\"Function to forecast the test dataset      Args:          test_dataset (pd.DataFrame): the test dataset          trained_model (LogisticRegression): the fitted model      Returns:          forecast (pd.DataFrame): the forecasted dataset      \"\"\"      # print(\"     Forecasting the test dataset...\")      X, y = test_dataset.iloc[:, :-1], test_dataset.iloc[:, -1]      predictions = trained_model.predict_proba(X)[:, 1]      print(\"     Forecasting done!\")      return predictions      def roc_from_scratch(probabilities, test_dataset, partitions=100):      # print(\"     Calculation of the ROC curve...\")      y_test = test_dataset.iloc[:, -1]        roc = np.array([])      for i in range(partitions + 1):          threshold_vector = np.greater_equal(probabilities, i / partitions).astype(int)          tpr, fpr = true_false_positive(threshold_vector, y_test)          roc = np.append(roc, [fpr, tpr])        roc_np = roc.reshape(-1, 2)      roc_data = pd.DataFrame({\"False positive rate\": roc_np[:, 0], \"True positive rate\": roc_np[:, 1]})      # print(\"     Calculation done\")      # print(\"     Scoring...\")        score_auc = roc_auc_score(y_test, probabilities)      # print(\"     Scoring done\\n\")        return roc_data, score_auc      def true_false_positive(threshold_vector: np.array, y_test: np.array):      \"\"\"Function to calculate the true positive rate and the false positive rate        Args:          threshold_vector (np.array): the test dataset          y_test (np.array): the fitted model      Returns:          tpr (pd.DataFrame): the forecasted dataset          fpr (pd.DataFrame): the forecasted dataset      \"\"\"        true_positive = np.equal(threshold_vector, 1) & np.equal(y_test, 1)      true_negative = np.equal(threshold_vector, 0) & np.equal(y_test, 0)      false_positive = np.equal(threshold_vector, 1) & np.equal(y_test, 0)      false_negative = np.equal(threshold_vector, 0) & np.equal(y_test, 1)        tpr = true_positive.sum() / (true_positive.sum() + false_negative.sum())      fpr = false_positive.sum() / (false_positive.sum() + true_negative.sum())        return tpr, fpr      def create_metrics(predictions: np.array, test_dataset: np.array):      # print(\"     Creating the metrics...\")      threshold = 0.5      threshold_vector = np.greater_equal(predictions, threshold).astype(int)        y_test = test_dataset.iloc[:, -1]        true_positive = (np.equal(threshold_vector, 1) & np.equal(y_test, 1)).sum()      true_negative = (np.equal(threshold_vector, 0) & np.equal(y_test, 0)).sum()      false_positive = (np.equal(threshold_vector, 1) & np.equal(y_test, 0)).sum()      false_negative = (np.equal(threshold_vector, 0) & np.equal(y_test, 1)).sum()        f1_score = np.around(2 * true_positive / (2 * true_positive + false_positive + false_negative), decimals=2)      accuracy = np.around(          (true_positive + true_negative) / (true_positive + true_negative + false_positive + false_negative), decimals=2      )      dict_ftpn = {\"tp\": true_positive, \"tn\": true_negative, \"fp\": false_positive, \"fn\": false_negative}        number_of_good_predictions = true_positive + true_negative      number_of_false_predictions = false_positive + false_negative        metrics = {          \"f1_score\": f1_score,          \"accuracy\": accuracy,          \"dict_ftpn\": dict_ftpn,          \"number_of_predictions\": len(predictions),          \"number_of_good_predictions\": number_of_good_predictions,          \"number_of_false_predictions\": number_of_false_predictions,      }        # print(\"     Creating the metrics done!\")      return metrics      def create_results(forecast_values, test_dataset):      forecast_series_proba = pd.Series(          np.around(forecast_values, decimals=2), index=test_dataset.index, name=\"Probability\"      )      forecast_series = pd.Series((forecast_values > 0.5).astype(int), index=test_dataset.index, name=\"Forecast\")      true_series = pd.Series(test_dataset.iloc[:, -1], name=\"Historical\", index=test_dataset.index)      index_series = pd.Series(range(len(true_series)), index=test_dataset.index, name=\"Id\")        results = pd.concat([index_series, forecast_series_proba, forecast_series, true_series], axis=1)      return results "}
{"text": "import os  import pathlib    from taipy.config import Config, Frequency, Scope    from .algos import *      def build_complex_config():      (          csv_path_inp,          excel_path_inp,          csv_path_sum,          excel_path_sum,          excel_path_out,          csv_path_out,      ) = build_complex_required_file_paths()        inp_csv_dn_1 = Config.configure_csv_data_node(\"dn_csv_in_1\", default_path=csv_path_inp)      inp_csv_dn_2 = Config.configure_csv_data_node(\"dn_csv_in_2\", default_path=csv_path_inp)        inp_excel_dn_1 = Config.configure_excel_data_node(\"dn_excel_in_1\", default_path=excel_path_inp, sheet_name=\"Sheet1\")      inp_excel_dn_2 = Config.configure_excel_data_node(\"dn_excel_in_2\", default_path=excel_path_inp, sheet_name=\"Sheet1\")        placeholder = Config.configure_data_node(id=\"dn_placeholder\", default_data=10)        dn_csv_sum = Config.configure_csv_data_node(\"dn_sum_csv\", default_path=csv_path_sum)      dn_excel_sum = Config.configure_excel_data_node(\"dn_sum_excel\", default_path=excel_path_sum, sheet_name=\"Sheet1\")        dn_subtract_csv_excel = Config.configure_pickle_data_node(\"dn_subtract_csv_excel\")      dn_mult = Config.configure_pickle_data_node(\"dn_mult\")      dn_div = Config.configure_pickle_data_node(\"dn_div\")        output_csv_dn = Config.configure_csv_data_node(\"csv_out\", csv_path_out)      output_excel_dn = Config.configure_excel_data_node(\"excel_out\", excel_path_out)        task_print_csv = Config.configure_task(\"task_print_csv\", print, input=inp_csv_dn_1)      task_print_excel = Config.configure_task(\"task_print_excel\", print, input=inp_excel_dn_1)      task_sum_csv = Config.configure_task(\"task_sum_csv\", sum, input=[inp_csv_dn_2, inp_csv_dn_1], output=dn_csv_sum)      task_sum_excel = Config.configure_task(          \"task_sum_excel\",          sum,          input=[inp_excel_dn_2, inp_excel_dn_1],          output=dn_excel_sum,      )        task_subtract_csv_excel = Config.configure_task(          \"task_subtract_csv_excel\",          subtract,          input=[dn_csv_sum, dn_excel_sum],          output=dn_subtract_csv_excel,      )      task_insert_placeholder = Config.configure_task(\"task_insert_placeholder\", return_a_number, output=[placeholder])      task_mult = Config.configure_task(          \"task_mult_by_placeholder\",          mult,          input=[dn_subtract_csv_excel, placeholder],          output=dn_mult,      )      task_div = Config.configure_task(\"task_div_by_placeholder\", divide, input=[dn_mult, placeholder], output=dn_div)      task_avg_div = Config.configure_task(\"task_avg_div\", average, input=dn_div, output=output_csv_dn)      task_avg_mult = Config.configure_task(\"task_avg_mult\", average, input=dn_mult, output=output_excel_dn)        scenario_config = Config.configure_scenario(          \"scenario\",          [              task_print_csv,              task_print_excel,              task_sum_csv,              task_sum_excel,              task_subtract_csv_excel,              task_insert_placeholder,              task_mult,              task_div,              task_avg_div,              task_avg_mult,          ],      )      return scenario_config      def build_complex_required_file_paths():      csv_path_inp = \"tests/shared_test_cases/data_sample/example.csv\"      excel_path_inp = \"tests/shared_test_cases/data_sample/example.xlsx\"        csv_path_sum = \"tests/shared_test_cases/data_sample/sum.csv\"      excel_path_sum = \"tests/shared_test_cases/data_sample/sum.xlsx\"        excel_path_out = \"tests/shared_test_cases/data_sample/res.xlsx\"      csv_path_out = \"tests/shared_test_cases/data_sample/res.csv\"      return (          csv_path_inp,          excel_path_inp,          csv_path_sum,          excel_path_sum,          excel_path_out,          csv_path_out,      )      def build_churn_classification_required_file_paths():      csv_path_inp = os.path.join(          pathlib.Path(__file__).parent.resolve(),          \"../../shared_test_cases/data_sample/churn.csv\",      )      return csv_path_inp      def build_churn_classification_config():      csv_path_inp = build_churn_classification_required_file_paths()        # path for csv and file_path for pickle      initial_dataset = Config.configure_data_node(          id=\"initial_dataset\", path=csv_path_inp, storage_type=\"csv\", has_header=True      )        date_cfg = Config.configure_data_node(id=\"date\", default_data=\"None\")        preprocessed_dataset = Config.configure_data_node(          id=\"preprocessed_dataset\", cacheable=True, validity_period=dt.timedelta(days=1)      )        # the final datanode that contains the processed data      train_dataset = Config.configure_data_node(id=\"train_dataset\", cacheable=True, validity_period=dt.timedelta(days=1))        # the final datanode that contains the processed data      trained_model = Config.configure_data_node(id=\"trained_model\", cacheable=True, validity_period=dt.timedelta(days=1))        trained_model_baseline = Config.configure_data_node(          id=\"trained_model_baseline\",          cacheable=True,          validity_period=dt.timedelta(days=1),      )        # the final datanode that contains the processed data      test_dataset = Config.configure_data_node(id=\"test_dataset\", cacheable=True, validity_period=dt.timedelta(days=1))        forecast_baseline_dataset = Config.configure_data_node(          id=\"forecast_baseline_dataset\",          scope=Scope.SCENARIO,          # cacheable=True,          # validity_period=dt.timedelta(days=1),      )        forecast_test_dataset = Config.configure_data_node(          id=\"forecast_test_dataset\",          scope=Scope.SCENARIO,          # cacheable=True,          # validity_period=dt.timedelta(days=1),      )        roc_data = Config.configure_data_node(          id=\"roc_data\",          scope=Scope.SCENARIO,          # cacheable=True,          # validity_period=dt.timedelta(days=1),      )        score_auc = Config.configure_data_node(          id=\"score_auc\",          scope=Scope.SCENARIO,          # cacheable=True,          # validity_period=dt.timedelta(days=1),      )        metrics = Config.configure_data_node(          id=\"metrics\",          scope=Scope.SCENARIO,          # cacheable=True,          # validity_period=dt.timedelta(days=1),      )        feature_importance_cfg = Config.configure_data_node(id=\"feature_importance\", scope=Scope.SCENARIO)        results = Config.configure_data_node(          id=\"results\",          scope=Scope.SCENARIO,          # cacheable=True,          # validity_period=dt.timedelta(days=1),      )        ##############################################################################################################################      # Creation of the tasks      ##############################################################################################################################        # the task will make the link between the input data node      # and the output data node while executing the function        # initial_dataset --> preprocess dataset --> preprocessed_dataset      task_preprocess_dataset = Config.configure_task(          id=\"preprocess_dataset\",          input=[initial_dataset, date_cfg],          function=preprocess_dataset,          output=preprocessed_dataset,      )        # preprocessed_dataset --> create train data --> train_dataset, test_dataset      task_create_train_test = Config.configure_task(          id=\"create_train_and_test_data\",          input=preprocessed_dataset,          function=create_train_test_data,          output=[train_dataset, test_dataset],      )        # train_dataset --> create train_model data --> trained_model      task_train_model = Config.configure_task(          id=\"train_model\",          input=train_dataset,          function=train_model,          output=[trained_model, feature_importance_cfg],      )        # train_dataset --> create train_model data --> trained_model      task_train_model_baseline = Config.configure_task(          id=\"train_model_baseline\",          input=train_dataset,          function=train_model_baseline,          output=[trained_model_baseline, feature_importance_cfg],      )        # test_dataset --> forecast --> forecast_dataset      task_forecast = Config.configure_task(          id=\"predict_the_test_data\",          input=[test_dataset, trained_model],          function=forecast,          output=forecast_test_dataset,      )        # test_dataset --> forecast --> forecast_dataset      task_forecast_baseline = Config.configure_task(          id=\"predict_of_baseline\",          input=[test_dataset, trained_model_baseline],          function=forecast_baseline,          output=forecast_baseline_dataset,      )        task_roc = Config.configure_task(          id=\"task_roc\",          input=[forecast_test_dataset, test_dataset],          function=roc_from_scratch,          output=[roc_data, score_auc],      )        task_roc_baseline = Config.configure_task(          id=\"task_roc_baseline\",          input=[forecast_baseline_dataset, test_dataset],          function=roc_from_scratch,          output=[roc_data, score_auc],      )        task_create_metrics = Config.configure_task(          id=\"task_create_metrics\",          input=[forecast_test_dataset, test_dataset],          function=create_metrics,          output=metrics,      )        task_create_results = Config.configure_task(          id=\"task_create_results\",          input=[forecast_test_dataset, test_dataset],          function=create_results,          output=results,      )        task_create_baseline_metrics = Config.configure_task(          id=\"task_create_baseline_metrics\",          input=[forecast_baseline_dataset, test_dataset],          function=create_metrics,          output=metrics,      )        task_create_baseline_results = Config.configure_task(          id=\"task_create_baseline_results\",          input=[forecast_baseline_dataset, test_dataset],          function=create_results,          output=results,      )        ##############################################################################################################################      # Creation of the scenario      ##############################################################################################################################        # the scenario will run the sequences      scenario_cfg = Config.configure_scenario(          id=\"churn_classification\",          task_configs=[              task_preprocess_dataset,              task_create_train_test,              task_train_model_baseline,              task_train_model,              task_forecast,              task_roc,              task_create_metrics,              task_create_results,              task_forecast_baseline,              task_roc_baseline,              task_create_metrics,              task_create_results,              task_create_baseline_metrics,              task_create_baseline_results,          ],          frequency=Frequency.WEEKLY,      )        return scenario_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 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  import json  import logging  import socket  import time  import typing as t  import warnings  from types import FrameType    from taipy.gui import Gui, Html, Markdown  from taipy.gui._renderers.builder import _Builder  from taipy.gui._warnings import TaipyGuiWarning  from taipy.gui.utils._variable_directory import _reset_name_map  from taipy.gui.utils.expr_var_name import _reset_expr_var_name      class Helpers:      @staticmethod      def test_cleanup():          _Builder._reset_key()          _reset_name_map()          _reset_expr_var_name()        @staticmethod      def test_control_md(gui: Gui, md_string: str, expected_values: t.Union[str, t.List]):          gui.add_page(\"test\", Markdown(md_string, frame=None))          Helpers._test_control(gui, expected_values)        @staticmethod      def test_control_html(gui: Gui, html_string: str, expected_values: t.Union[str, t.List]):          gui.add_page(\"test\", Html(html_string, frame=None))          Helpers._test_control(gui, expected_values)        @staticmethod      def test_control_builder(gui: Gui, builder_page, expected_values: t.Union[str, t.List]):          gui.add_page(\"test\", builder_page)          Helpers._test_control(gui, expected_values)        @staticmethod      def _test_control(gui: Gui, expected_values: t.Union[str, t.List]):          gui.run(run_server=False, single_client=True, stylekit=False)          client = gui._server.test_client()          response = client.get(\"/taipy-jsx/test\")          assert response.status_code == 200, f\"response.status_code {response.status_code} != 200\"          response_data = json.loads(response.get_data().decode(\"utf-8\", \"ignore\"))          assert isinstance(response_data, t.Dict), \"response_data is not Dict\"          assert \"jsx\" in response_data, \"jsx not in response_data\"          jsx = response_data[\"jsx\"]          logging.getLogger().debug(jsx)          if isinstance(expected_values, str):              assert jsx == expected_values, f\"{jsx} != {expected_values}\"          elif isinstance(expected_values, list):              for expected_value in expected_values:                  assert expected_value in jsx, f\"{expected_value} not in {jsx}\"        @staticmethod      def assert_outward_ws_message(received_message, type, varname, value):          assert isinstance(received_message, dict)          assert \"name\" in received_message and received_message[\"name\"] == \"message\"          assert \"args\" in received_message          args = received_message[\"args\"]          assert \"type\" in args and args[\"type\"] == type          assert \"payload\" in args          payload = args[\"payload\"][0]          assert \"name\" in payload and varname in payload[\"name\"]          assert \"payload\" in payload and \"value\" in payload[\"payload\"] and payload[\"payload\"][\"value\"] == value          logging.getLogger().debug(payload[\"payload\"][\"value\"])        @staticmethod      def assert_outward_simple_ws_message(received_message, type, varname, value):          assert isinstance(received_message, dict)          assert \"name\" in received_message and received_message[\"name\"] == \"message\"          assert \"args\" in received_message          args = received_message[\"args\"]          assert \"type\" in args and args[\"type\"] == type          assert \"name\" in args and args[\"name\"] == varname          assert \"payload\" in args          payload = args[\"payload\"]          assert \"value\" in payload and payload[\"value\"] == value          logging.getLogger().debug(payload[\"value\"])        @staticmethod      def assert_outward_ws_simple_message(received_message, aType, values):          assert isinstance(received_message, dict)          assert \"name\" in received_message and received_message[\"name\"] == \"message\"          assert \"args\" in received_message          args = received_message[\"args\"]          assert \"type\" in args and args[\"type\"] == aType          for k, v in values.items():              assert k in args and args[k] == v              logging.getLogger().debug(f\"{k}: {args[k]}\")        @staticmethod      def assert_outward_ws_multiple_message(received_message, type, array_len: int):          assert isinstance(received_message, dict)          assert \"name\" in received_message and received_message[\"name\"] == \"message\"          assert \"args\" in received_message          args = received_message[\"args\"]          assert \"type\" in args and args[\"type\"] == type          assert \"payload\" in args          payload = args[\"payload\"]          assert isinstance(payload, list)          assert len(payload) == array_len          logging.getLogger().debug(payload)        @staticmethod      def create_scope_and_get_sid(gui: Gui) -> str:          sid = \"test\"          gui._bindings()._get_or_create_scope(sid)          return sid        @staticmethod      def port_check():          s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)          s.settimeout(1)          if s.connect_ex((\"127.0.0.1\", 5000)) == 0:              s.close()              return True          else:              s.close()              return False        @staticmethod      def run_e2e(gui, **kwargs):          kwargs[\"run_in_thread\"] = True          kwargs[\"single_client\"] = True          kwargs[\"run_browser\"] = False          kwargs[\"stylekit\"] = kwargs.get(\"stylekit\", False)          with warnings.catch_warnings(record=True):              gui.run(**kwargs)          while not Helpers.port_check():              time.sleep(0.1)        @staticmethod      def run_e2e_multi_client(gui: Gui):          with warnings.catch_warnings(record=True):              gui.run(run_server=False, run_browser=False, single_client=False, stylekit=False)              gui._server.run(                  host=gui._get_config(\"host\", \"127.0.0.1\"),                  port=gui._get_config(\"port\", 5000),                  debug=False,                  use_reloader=False,                  flask_log=False,                  run_in_thread=True,                  allow_unsafe_werkzeug=False,                  notebook_proxy=False,              )          while not Helpers.port_check():              time.sleep(0.1)        @staticmethod      def get_taipy_warnings(warns: t.List[warnings.WarningMessage]) -> t.List[warnings.WarningMessage]:          return [w for w in warns if w.category is TaipyGuiWarning] "}
{"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.  import inspect  import typing as t  from pathlib import Path    import pytest    from taipy.gui import Gui  from taipy.gui.extension import Element, ElementLibrary, ElementProperty, PropertyType      def render_xhtml_4_my_library(properties: t.Dict[str, t.Any]) -> str:      return f\"<h1>{properties.get('value', '')}</h1>\"      def render_xhtml_4_my_library_fail(properties: t.Dict[str, t.Any]) -> str:      return f\"<h1>{properties.get('value', '')}</h1\"      class MyLibrary(ElementLibrary):      elts = {          \"testinput\": Element(              \"value\",              {                  \"value\": ElementProperty(PropertyType.dynamic_string, \"Fred\"),                  \"multiline\": ElementProperty(PropertyType.boolean, False),                  \"broadcast\": ElementProperty(PropertyType.broadcast, \"broadcast\"),              },              \"Input\",          ),          \"title\": Element(              \"value\",              {                  \"value\": ElementProperty(PropertyType.string, \"\"),              },              \"h1\",              render_xhtml=render_xhtml_4_my_library,          ),          \"title_fail\": Element(              \"value\",              {                  \"value\": ElementProperty(PropertyType.string, \"\"),              },              \"h1\",              render_xhtml=render_xhtml_4_my_library_fail,          ),          \"inner\": Element(              \"value\",              {\"value\": ElementProperty(PropertyType.string, \"\")},              inner_properties={                  \"with_property\": ElementProperty(                      PropertyType.react,                      \"{<tp:prop:value>}\",                  ),              },          ),      }        def get_name(self) -> str:          return \"test_lib\"        def get_elements(self) -> t.Dict[str, Element]:          return MyLibrary.elts        def get_resource(self, name: str) -> Path:          return Path(name)      class MyBadLibrary(ElementLibrary):      def get_name(self) -> str:          return \"bad name\"        def get_elements(self) -> t.Dict[str, Element]:          return {}      class MyGoodLibrary(ElementLibrary):      def get_name(self) -> str:          return \"test_lib\"        def get_elements(self) -> t.Dict[str, Element]:          return {}      Gui.add_library(MyLibrary())      def test_lib_input_md(gui: Gui, test_client, helpers):      val = \"\"  # noqa: F841      gui._set_frame(inspect.currentframe())      md_string = \"<|{val}|test_lib.testinput|multiline|>\"      expected_list = [          \"<TestLib_Input\",          'libClassName=\"test_lib-testinput\"',          \"multiline={true}\",          'defaultValue=\"\"',          \"broadcast={_bc_broadcast}\",          \"value={tpec_TpExPr_val_TPMDL_0}\",      ]      helpers.test_control_md(gui, md_string, expected_list)      def test_lib_xhtml_md(gui: Gui, test_client, helpers):      val = \"title\"  # noqa: F841      gui._set_frame(inspect.currentframe())      md_string = \"<|{val}|test_lib.title|>\"      expected = [f\"<h1>{val}</h1>\"]      helpers.test_control_md(gui, md_string, expected)      def test_lib_xhtml_fail_md(gui: Gui, test_client, helpers):      val = \"title\"  # noqa: F841      gui._set_frame(inspect.currentframe())      md_string = \"<|{val}|test_lib.title_fail|>\"      expected = [\"title_fail.render_xhtml() did not return a valid XHTML string. unclosed token: line 1, column 9\"]      helpers.test_control_md(gui, md_string, expected)      def test_lib_input_html_1(gui: Gui, test_client, helpers):      val = \"\"  # noqa: F841      gui._set_frame(inspect.currentframe())      html_string = '<test_lib:testinput value=\"{val}\" multiline=\"true\" />'      expected_list = [          \"<TestLib_Input\",          \"multiline={true}\",          'defaultValue=\"\"',          \"broadcast={_bc_broadcast}\",          \"value={tpec_TpExPr_val_TPMDL_0}\",          \"</TestLib_Input>\",      ]      helpers.test_control_html(gui, html_string, expected_list)      def test_lib_input_html_2(gui: Gui, test_client, helpers):      val = \"\"  # noqa: F841      gui._set_frame(inspect.currentframe())      html_string = '<test_lib:testinput multiline=\"true\">{val}</test_lib:testinput>'      expected_list = [          \"<TestLib_Input\",          \"multiline={true}\",          'defaultValue=\"\"',          \"broadcast={_bc_broadcast}\",          \"value={tpec_TpExPr_val_TPMDL_0}\",          \"</TestLib_Input>\",      ]      helpers.test_control_html(gui, html_string, expected_list)      def test_lib_inner_md(gui: Gui, test_client, helpers):      val = \"title\"  # noqa: F841      gui._set_frame(inspect.currentframe())      md_string = \"<|{val}|test_lib.inner|>\"      expected = [          \"<TestLib_Inner\",          \"value={tpec_TpExPr_val_TPMDL_0}\",          \"withProperty={tpec_TpExPr_tpec_TpExPr_val_TPMDL_0_TPMDL_0}\",      ]      helpers.test_control_md(gui, md_string, expected)      def test_lib_inner_no_value_md(gui: Gui, test_client, helpers):      gui._set_frame(inspect.currentframe())      md_string = \"<|test_lib.inner|>\"      expected = [\"<TestLib_Inner\", \"withProperty={tpec_TpExPr_None_TPMDL_0}\"]      helpers.test_control_md(gui, md_string, expected)      def test_lib_bad_name():      with pytest.raises(NameError):          Gui.add_library(MyBadLibrary())      def test_lib_good_name():      Gui.add_library(MyGoodLibrary())      def test_add_lib():      Gui(libraries=[MyGoodLibrary()]) "}
{"text": "#  # Licensed under the Apache License, Version 2.0 (the \"License\"); you may not use this file except in compliance with  # the License. You may obtain a copy of the License at  #  #        http://www.apache.org/licenses/LICENSE-2.0  #  # Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on  # an \"AS IS\" BASIS, WITHOUT 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": "import inspect  from datetime import datetime  from importlib import util    import pandas  # type: ignore  from flask import g    from taipy.gui import Gui  from taipy.gui.data.data_format import _DataFormat  from taipy.gui.data.decimator import ScatterDecimator  from taipy.gui.data.pandas_data_accessor import _PandasDataAccessor      def test_simple_data(gui: Gui, helpers, small_dataframe):      accessor = _PandasDataAccessor()      pd = pandas.DataFrame(data=small_dataframe)      ret_data = accessor.get_data(gui, \"x\", pd, {\"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, small_dataframe):      if util.find_spec(\"pyarrow\"):          accessor = _PandasDataAccessor()          pd = pandas.DataFrame(data=small_dataframe)          ret_data = accessor.get_data(gui, \"x\", pd, {\"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_get_all_simple_data(gui: Gui, helpers, small_dataframe):      accessor = _PandasDataAccessor()      pd = pandas.DataFrame(data=small_dataframe)      ret_data = accessor.get_data(gui, \"x\", pd, {\"alldata\": True}, _DataFormat.JSON)      assert ret_data      assert ret_data[\"alldata\"] is True      value = ret_data[\"value\"]      assert value      data = value[\"data\"]      assert data == small_dataframe      def test_slice(gui: Gui, helpers, small_dataframe):      accessor = _PandasDataAccessor()      pd = pandas.DataFrame(data=small_dataframe)      value = accessor.get_data(gui, \"x\", pd, {\"start\": 0, \"end\": 1}, _DataFormat.JSON)[\"value\"]      assert value[\"rowcount\"] == 3      data = value[\"data\"]      assert len(data) == 2      value = accessor.get_data(gui, \"x\", pd, {\"start\": \"0\", \"end\": \"1\"}, _DataFormat.JSON)[\"value\"]      data = value[\"data\"]      assert len(data) == 2      def test_sort(gui: Gui, helpers, small_dataframe):      accessor = _PandasDataAccessor()      pd = pandas.DataFrame(data=small_dataframe)      query = {\"columns\": [\"name\", \"value\"], \"start\": 0, \"end\": -1, \"orderby\": \"name\", \"sort\": \"desc\"}      data = accessor.get_data(gui, \"x\", pd, query, _DataFormat.JSON)[\"value\"][\"data\"]      assert data[0][\"name\"] == \"C\"      def test_aggregate(gui: Gui, helpers, small_dataframe):      accessor = _PandasDataAccessor()      pd = pandas.DataFrame(data=small_dataframe)      pd = pandas.concat(          [pd, pandas.DataFrame(data={\"name\": [\"A\"], \"value\": [4]})], axis=0, join=\"outer\", ignore_index=True      )      query = {\"columns\": [\"name\", \"value\"], \"start\": 0, \"end\": -1, \"aggregates\": [\"name\"], \"applies\": {\"value\": \"sum\"}}      value = accessor.get_data(gui, \"x\", pd, query, _DataFormat.JSON)[\"value\"]      assert value[\"rowcount\"] == 3      data = value[\"data\"]      assert next(v.get(\"value\") for v in data if v.get(\"name\") == \"A\") == 5      def test_filters(gui: Gui, helpers, small_dataframe):      accessor = _PandasDataAccessor()      pd = pandas.DataFrame(data=small_dataframe)      pd = pandas.concat(          [pd, pandas.DataFrame(data={\"name\": [\"A\"], \"value\": [4]})], axis=0, join=\"outer\", ignore_index=True      )      query = {          \"columns\": [\"name\", \"value\"],          \"start\": 0,          \"end\": -1,          \"filters\": [{\"col\": \"name\", \"action\": \"!=\", \"value\": \"\"}],      }      value = accessor.get_data(gui, \"x\", pd, query, _DataFormat.JSON)      assert len(value[\"value\"][\"data\"]) == 4        query = {          \"columns\": [\"name\", \"value\"],          \"start\": 0,          \"end\": -1,          \"filters\": [{\"col\": \"name\", \"action\": \"==\", \"value\": \"\"}],      }      value = accessor.get_data(gui, \"x\", pd, query, _DataFormat.JSON)      assert len(value[\"value\"][\"data\"]) == 0        query = {          \"columns\": [\"name\", \"value\"],          \"start\": 0,          \"end\": -1,          \"filters\": [{\"col\": \"name\", \"action\": \"==\", \"value\": \"A\"}],      }      value = accessor.get_data(gui, \"x\", pd, query, _DataFormat.JSON)      assert len(value[\"value\"][\"data\"]) == 2        query = {          \"columns\": [\"name\", \"value\"],          \"start\": 0,          \"end\": -1,          \"filters\": [{\"col\": \"name\", \"action\": \"==\", \"value\": \"A\"}, {\"col\": \"value\", \"action\": \"==\", \"value\": 2}],      }      value = accessor.get_data(gui, \"x\", pd, query, _DataFormat.JSON)      assert len(value[\"value\"][\"data\"]) == 0        query = {          \"columns\": [\"name\", \"value\"],          \"start\": 0,          \"end\": -1,          \"filters\": [{\"col\": \"name\", \"action\": \"!=\", \"value\": \"A\"}, {\"col\": \"value\", \"action\": \"==\", \"value\": 2}],      }      value = accessor.get_data(gui, \"x\", pd, query, _DataFormat.JSON)      assert len(value[\"value\"][\"data\"]) == 1      assert value[\"value\"][\"data\"][0][\"_tp_index\"] == 1      def test_filter_by_date(gui: Gui, helpers, small_dataframe):      accessor = _PandasDataAccessor()      pd = pandas.DataFrame(data=small_dataframe)      pd[\"a date\"] = [          datetime.fromisocalendar(2022, 28, 1),          datetime.fromisocalendar(2022, 28, 2),          datetime.fromisocalendar(2022, 28, 3),      ]      query = {          \"columns\": [\"name\", \"value\"],          \"start\": 0,          \"end\": -1,          \"filters\": [{\"col\": \"a date\", \"action\": \">\", \"value\": datetime.fromisocalendar(2022, 28, 3).isoformat() + \"Z\"}],      }      value = accessor.get_data(gui, \"x\", pd, query, _DataFormat.JSON)      assert len(value[\"value\"][\"data\"]) == 0      query = {          \"columns\": [\"name\", \"value\"],          \"start\": 0,          \"end\": -1,          \"filters\": [{\"col\": \"a date\", \"action\": \">\", \"value\": datetime.fromisocalendar(2022, 28, 2).isoformat() + \"Z\"}],      }      value = accessor.get_data(gui, \"x\", pd, query, _DataFormat.JSON)      assert len(value[\"value\"][\"data\"]) == 1      query = {          \"columns\": [\"name\", \"value\"],          \"start\": 0,          \"end\": -1,          \"filters\": [{\"col\": \"a date\", \"action\": \"<\", \"value\": datetime.fromisocalendar(2022, 28, 3).isoformat() + \"Z\"}],      }      value = accessor.get_data(gui, \"x\", pd, query, _DataFormat.JSON)      assert len(value[\"value\"][\"data\"]) == 2      query = {          \"columns\": [\"name\", \"value\"],          \"start\": 0,          \"end\": -1,          \"filters\": [              {\"col\": \"a date\", \"action\": \"<\", \"value\": datetime.fromisocalendar(2022, 28, 2).isoformat() + \"Z\"},              {\"col\": \"a date\", \"action\": \">\", \"value\": datetime.fromisocalendar(2022, 28, 2).isoformat() + \"Z\"},          ],      }      value = accessor.get_data(gui, \"x\", pd, query, _DataFormat.JSON)      assert len(value[\"value\"][\"data\"]) == 0      query = {          \"columns\": [\"name\", \"value\"],          \"start\": 0,          \"end\": -1,          \"filters\": [              {\"col\": \"a date\", \"action\": \"<\", \"value\": datetime.fromisocalendar(2022, 28, 3).isoformat() + \"Z\"},              {\"col\": \"a date\", \"action\": \">\", \"value\": datetime.fromisocalendar(2022, 28, 1).isoformat() + \"Z\"},          ],      }      value = accessor.get_data(gui, \"x\", pd, query, _DataFormat.JSON)      assert len(value[\"value\"][\"data\"]) == 1      def test_decimator(gui: Gui, helpers, small_dataframe):      a_decimator = ScatterDecimator()        accessor = _PandasDataAccessor()      pd = pandas.DataFrame(data=small_dataframe)        # set gui frame      gui._set_frame(inspect.currentframe())        gui.add_page(\"test\", \"<|Hello {a_decimator}|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().test_request_context(f\"/taipy-jsx/test/?client_id={cid}\", data={\"client_id\": cid}):          g.client_id = cid            ret_data = accessor.get_data(              gui,              \"x\",              pd,              {                  \"start\": 0,                  \"end\": -1,                  \"alldata\": True,                  \"decimatorPayload\": {                      \"decimators\": [{\"decimator\": \"a_decimator\", \"chartMode\": \"markers\"}],                      \"width\": 100,                  },              },              _DataFormat.JSON,          )          assert ret_data          value = ret_data[\"value\"]          assert value          data = value[\"data\"]          assert len(data) == 2 "}
{"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 datetime  import inspect  import random  import typing as t    import taipy.gui.builder as tgb  from taipy.gui import Gui      def test_chart_builder_1(gui: Gui, helpers, csvdata):      selected_indices = [14258]  # noqa: F841      subplot_layout = {  # noqa: F841          \"grid\": {\"rows\": 1, \"columns\": 2, \"subplots\": [[\"xy\", \"x2y\"]], \"roworder\": \"bottom to top\"}      }      y = [\"Daily hospital occupancy\", \"Daily hospital occupancy\"]  # noqa: F841      label = [\"Entity\", \"Code\"]  # noqa: F841      mode = [None, \"markers\"]  # noqa: F841      color = [None, \"red\"]  # noqa: F841      chart_type = [None, \"scatter\"]  # noqa: F841      xaxis = [None, \"x2\"]  # noqa: F841      with tgb.Page(frame=None) as page:          tgb.chart(              data=\"{csvdata}\",              x=\"Day\",              selected_color=\"green\",              y=\"{y}\",              label=\"{label}\",              mode=\"{mode}\",              color=\"{color}\",              type=\"{chart_type}\",              xaxis=\"{xaxis}\",              layout=\"{subplot_layout}\",              on_range_change=\"range_change\",              width=\"100%\",              height=\"100%\",              selected=\"{selected_indices}\",          )      expected_list = [          \"<Chart\",          \"selected0={tpec_TpExPr_selected_indices_TPMDL_0}\",          \"selected1={tpec_TpExPr_selected_indices_TPMDL_0}\",          'height=\"100%\"',          'defaultLayout=\"{&quot;grid&quot;: &#x7B;&quot;rows&quot;: 1, &quot;columns&quot;: 2, &quot;subplots&quot;: [[&quot;xy&quot;, &quot;x2y&quot;]], &quot;roworder&quot;: &quot;bottom to top&quot;&#x7D;}\"',          'onRangeChange=\"range_change\"',          'updateVars=\"layout=_TpDi_tpec_TpExPr_subplot_layout_TPMDL_0;selected0=tpec_TpExPr_selected_indices_TPMDL_0;selected1=tpec_TpExPr_selected_indices_TPMDL_0\"',          'updateVarName=\"_TpD_tpec_TpExPr_csvdata_TPMDL_0\"',          \"data={_TpD_tpec_TpExPr_csvdata_TPMDL_0}\",          'width=\"100%\"',      ]      gui._set_frame(inspect.currentframe())      helpers.test_control_builder(gui, page, expected_list)      def test_chart_builder_2(gui: Gui, helpers, csvdata):      selected_indices = [14258]  # noqa: F841      with tgb.Page(frame=None) as page:          tgb.chart(              data=\"{csvdata}\",              x=\"Day\",              selected_color=\"green\",              y=[\"Daily hospital occupancy\", \"Daily hospital occupancy\"],              label=[\"Entity\", \"Code\"],              mode=[None, \"markers\"],              color=[None, \"red\"],              type=(None, \"scatter\"),              xaxis=(None, \"x2\"),              layout={\"grid\": {\"rows\": 1, \"columns\": 2, \"subplots\": [[\"xy\", \"x2y\"]], \"roworder\": \"bottom to top\"}},              on_range_change=\"range_change\",              width=\"100%\",              height=\"100%\",              selected=\"{selected_indices}\",          )      expected_list = [          \"<Chart\",          \"selected0={tpec_TpExPr_selected_indices_TPMDL_0}\",          \"selected1={tpec_TpExPr_selected_indices_TPMDL_0}\",          'height=\"100%\"',          'defaultLayout=\"{&quot;grid&quot;: &#x7B;&quot;rows&quot;: 1, &quot;columns&quot;: 2, &quot;subplots&quot;: [[&quot;xy&quot;, &quot;x2y&quot;]], &quot;roworder&quot;: &quot;bottom to top&quot;&#x7D;}\"',          'onRangeChange=\"range_change\"',          'updateVars=\"selected0=tpec_TpExPr_selected_indices_TPMDL_0;selected1=tpec_TpExPr_selected_indices_TPMDL_0\"',          'updateVarName=\"_TpD_tpec_TpExPr_csvdata_TPMDL_0\"',          \"data={_TpD_tpec_TpExPr_csvdata_TPMDL_0}\",          'width=\"100%\"',      ]      gui._set_frame(inspect.currentframe())      helpers.test_control_builder(gui, page, expected_list)      def test_map_builder(gui: Gui, helpers):      mapData = {  # noqa: F841          \"Lat\": [              48.4113,              18.0057,              48.6163,              48.5379,              48.5843,              48.612,              48.6286,              48.6068,              48.4489,              48.6548,              18.5721,              48.3734,              17.6398,              48.5765,              48.4407,              48.2286,          ],          \"Lon\": [              -112.8352,              -65.804,              -113.4784,              -114.0702,              -111.0188,              -110.7939,              -109.4629,              -114.9123,              -112.9705,              -113.965,              -66.5401,              -111.5245,              -64.7246,              -112.1932,              -113.3159,              -104.5863,          ],          \"Globvalue\": [              0.0875,              0.0892,              0.0908,              0.0933,              0.0942,              0.095,              0.095,              0.095,              0.0958,              0.0958,              0.0958,              0.0958,              0.0958,              0.0975,              0.0983,              0.0992,          ],      }      marker = {\"color\": \"fuchsia\", \"size\": 4}  # noqa: F841      layout = {  # noqa: F841          \"dragmode\": \"zoom\",          \"mapbox\": {\"style\": \"open-street-map\", \"center\": {\"lat\": 38, \"lon\": -90}, \"zoom\": 3},          \"margin\": {\"r\": 0, \"t\": 0, \"b\": 0, \"l\": 0},      }      with tgb.Page(frame=None) as page:          tgb.chart(              data=\"{mapData}\",              type=\"scattermapbox\",              marker=\"{marker}\",              layout=\"{layout}\",              lat=\"Lat\",              lon=\"Lon\",              text=\"Globvalue\",              mode=\"markers\",          )      gui._set_frame(inspect.currentframe())      expected_list = [          \"<Chart\",          \"&quot;Lat&quot;: &#x7B;&quot;index&quot;:\",          \"&quot;Lon&quot;: &#x7B;&quot;index&quot;:\",          \"data={_TpD_tpec_TpExPr_mapData_TPMDL_0}\",          'defaultLayout=\"{&quot;dragmode&quot;: &quot;zoom&quot;, &quot;mapbox&quot;: &#x7B;&quot;style&quot;: &quot;open-street-map&quot;, &quot;center&quot;: &#x7B;&quot;lat&quot;: 38, &quot;lon&quot;: -90&#x7D;, &quot;zoom&quot;: 3&#x7D;, &quot;margin&quot;: &#x7B;&quot;r&quot;: 0, &quot;t&quot;: 0, &quot;b&quot;: 0, &quot;l&quot;: 0&#x7D;}\"',          'updateVarName=\"_TpD_tpec_TpExPr_mapData_TPMDL_0\"',      ]      helpers.test_control_builder(gui, page, expected_list)      def test_chart_indexed_properties_builder(gui: Gui, helpers):      data: t.Dict[str, t.Any] = {}      data[\"Date\"] = [datetime.datetime(2021, 12, i) for i in range(1, 31)]        data[\"La Rochelle\"] = [10 + 6 * random.random() for _ in range(1, 31)]      data[\"Montpellier\"] = [16 + 6 * random.random() for _ in range(1, 31)]      data[\"Paris\"] = [6 + 6 * random.random() for _ in range(1, 31)]        data[\"La Rochelle 1\"] = [x * (1 + (random.random() / 10)) for x in data[\"La Rochelle\"]]      data[\"La Rochelle 2\"] = [x * (1 - (random.random() / 10)) for x in data[\"La Rochelle\"]]        data[\"Montpellier 1\"] = [x * (1 + (random.random() / 10)) for x in data[\"Montpellier\"]]      data[\"Montpellier 2\"] = [x * (1 - (random.random() / 10)) for x in data[\"Montpellier\"]]        with tgb.Page(frame=None) as page:          tgb.chart(              data=\"{data}\",              x=\"Date\",              mode=\"lines\",              y=[\"La Rochelle\", \"La Rochelle 1\", \"La Rochelle 2\", \"Montpellier\", \"Montpellier 1\", \"Montpellier 2\"],              line=[None, \"dashdot\", \"dash\", None, \"dashdot\", \"dash\"],              color=[None, \"blue\", \"blue\", None, \"red\", \"red\"],          )        gui._set_frame(inspect.currentframe())      expected_list = [          \"<Chart\",          \"&quot;traces&quot;: [[&quot;Date_str&quot;, &quot;La Rochelle&quot;], [&quot;Date_str&quot;, &quot;La Rochelle 1&quot;], [&quot;Date_str&quot;, &quot;La Rochelle 2&quot;], [&quot;Date_str&quot;, &quot;Montpellier&quot;], [&quot;Date_str&quot;, &quot;Montpellier 1&quot;], [&quot;Date_str&quot;, &quot;Montpellier 2&quot;]]\",          \"&quot;lines&quot;: [null, &#x7B;&quot;dash&quot;: &quot;dashdot&quot;&#x7D;, &#x7B;&quot;dash&quot;: &quot;dash&quot;&#x7D;, null, &#x7B;&quot;dash&quot;: &quot;dashdot&quot;&#x7D;, &#x7B;&quot;dash&quot;: &quot;dash&quot;&#x7D;]\",      ]      helpers.test_control_builder(gui, page, expected_list)      def test_chart_indexed_properties_with_arrays_builder(gui: Gui, helpers):      data: t.Dict[str, t.Any] = {}      data[\"Date\"] = [datetime.datetime(2021, 12, i) for i in range(1, 31)]        data[\"La Rochelle\"] = [10 + 6 * random.random() for _ in range(1, 31)]      data[\"Montpellier\"] = [16 + 6 * random.random() for _ in range(1, 31)]      data[\"Paris\"] = [6 + 6 * random.random() for _ in range(1, 31)]        data[\"La Rochelle 1\"] = [x * (1 + (random.random() / 10)) for x in data[\"La Rochelle\"]]      data[\"La Rochelle 2\"] = [x * (1 - (random.random() / 10)) for x in data[\"La Rochelle\"]]        data[\"Montpellier 1\"] = [x * (1 + (random.random() / 10)) for x in data[\"Montpellier\"]]      data[\"Montpellier 2\"] = [x * (1 - (random.random() / 10)) for x in data[\"Montpellier\"]]        ys = [  # noqa: F841          \"La Rochelle\",          \"La Rochelle 1\",          \"La Rochelle 2\",          \"Montpellier\",          \"Montpellier 1\",          \"Montpellier 2\",      ]      lines = [None, \"dashdot\", \"dash\", None, \"dashdot\", \"dash\"]  # noqa: F841      colors = [None, \"blue\", \"blue\", None, \"red\", \"red\"]  # noqa: F841        with tgb.Page(frame=None) as page:          tgb.chart(              data=\"{data}\",              x=\"Date\",              mode=\"lines\",              y=\"{ys}\",              line=\"{lines}\",              color=\"{colors}\",          )        gui._set_frame(inspect.currentframe())      expected_list = [          \"<Chart\",          \"&quot;traces&quot;: [[&quot;Date_str&quot;, &quot;La Rochelle&quot;], [&quot;Date_str&quot;, &quot;La Rochelle 1&quot;], [&quot;Date_str&quot;, &quot;La Rochelle 2&quot;], [&quot;Date_str&quot;, &quot;Montpellier&quot;], [&quot;Date_str&quot;, &quot;Montpellier 1&quot;], [&quot;Date_str&quot;, &quot;Montpellier 2&quot;]]\",          \"&quot;lines&quot;: [null, &#x7B;&quot;dash&quot;: &quot;dashdot&quot;&#x7D;, &#x7B;&quot;dash&quot;: &quot;dash&quot;&#x7D;, null, &#x7B;&quot;dash&quot;: &quot;dashdot&quot;&#x7D;, &#x7B;&quot;dash&quot;: &quot;dash&quot;&#x7D;]\",      ]      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": "import inspect    from taipy.gui import Gui      def test_table_md_1(gui: Gui, helpers, csvdata):      md_string = \"<|{csvdata}|table|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_md(gui, md_string, expected_list)      def test_table_reset_md(gui: Gui, helpers, csvdata):      md_string = \"<|{csvdata}|table|rebuild|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_md(gui, md_string, expected_list)      def test_table_md_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\",      }      md_string = \"<|{csvdata}|table|properties=table_properties|auto_loading|not editable|>\"      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_md(gui, md_string, expected_list)      def test_table_html_1(gui: Gui, helpers, csvdata):      html_string = '<taipy: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_html(gui, html_string, expected_list)      def test_table_html_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\",      }      html_string = '<taipy:table data=\"{csvdata}\" properties=\"table_properties\" auto_loading=\"Yes\" show_all=\"Sure\" />'      expected_list = [          \"<Table\",          \"allowAllRows={true}\",          \"autoLoading={true}\",          \"showAll={true}\",          '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_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": "import datetime  import inspect  import random  import typing as t    from taipy.gui import Gui      def test_chart_md_1(gui: Gui, helpers, csvdata):      selected_indices = [14258]  # noqa: F841      subplot_layout = {  # noqa: F841          \"grid\": {\"rows\": 1, \"columns\": 2, \"subplots\": [[\"xy\", \"x2y\"]], \"roworder\": \"bottom to top\"}      }      md_string = \"<|{csvdata}|chart|x=Day|selected_color=green|y[1]=Daily hospital occupancy|label[1]=Entity|y[2]=Daily hospital occupancy|label[2]=Code|mode[2]=markers|color[2]=red|type[2]=scatter|xaxis[2]=x2|layout={subplot_layout}|on_range_change=range_change|width=100%|height=100%|selected={selected_indices}|>\"      expected_list = [          \"<Chart\",          \"selected0={tpec_TpExPr_selected_indices_TPMDL_0}\",          \"selected1={tpec_TpExPr_selected_indices_TPMDL_0}\",          'height=\"100%\"',          'defaultLayout=\"{&quot;grid&quot;: &#x7B;&quot;rows&quot;: 1, &quot;columns&quot;: 2, &quot;subplots&quot;: [[&quot;xy&quot;, &quot;x2y&quot;]], &quot;roworder&quot;: &quot;bottom to top&quot;&#x7D;}\"',          'onRangeChange=\"range_change\"',          'updateVars=\"layout=_TpDi_tpec_TpExPr_subplot_layout_TPMDL_0;selected0=tpec_TpExPr_selected_indices_TPMDL_0;selected1=tpec_TpExPr_selected_indices_TPMDL_0\"',          'updateVarName=\"_TpD_tpec_TpExPr_csvdata_TPMDL_0\"',          \"data={_TpD_tpec_TpExPr_csvdata_TPMDL_0}\",          'width=\"100%\"',      ]      gui._set_frame(inspect.currentframe())      helpers.test_control_md(gui, md_string, expected_list)      def test_chart_html_1(gui: Gui, helpers, csvdata):      selected_indices = [14258]  # noqa: F841      subplot_layout = {  # noqa: F841          \"grid\": {\"rows\": 1, \"columns\": 2, \"subplots\": [[\"xy\", \"x2y\"]], \"roworder\": \"bottom to top\"}      }      html_string = '<taipy:chart data=\"{csvdata}\" x=\"Day\" selected_color=\"green\" y[1]=\"Daily hospital occupancy\" label[1]=\"Entity\" y[2]=\"Daily hospital occupancy\" label[2]=\"Code\" mode[2]=\"markers\" color[2]=\"red\" type[2]=\"scatter\" xaxis[2]=\"x2\" layout=\"{subplot_layout}\" on_range_change=\"range_change\" width=\"100%\" height=\"100%\" selected=\"{selected_indices}\"  />'      expected_list = [          \"<Chart\",          \"selected0={tpec_TpExPr_selected_indices_TPMDL_0}\",          \"selected1={tpec_TpExPr_selected_indices_TPMDL_0}\",          'height=\"100%\"',          'defaultLayout=\"{&quot;grid&quot;: &#x7B;&quot;rows&quot;: 1, &quot;columns&quot;: 2, &quot;subplots&quot;: [[&quot;xy&quot;, &quot;x2y&quot;]], &quot;roworder&quot;: &quot;bottom to top&quot;&#x7D;}\"',          'onRangeChange=\"range_change\"',          'updateVars=\"layout=_TpDi_tpec_TpExPr_subplot_layout_TPMDL_0;selected0=tpec_TpExPr_selected_indices_TPMDL_0;selected1=tpec_TpExPr_selected_indices_TPMDL_0\"',          'updateVarName=\"_TpD_tpec_TpExPr_csvdata_TPMDL_0\"',          \"data={_TpD_tpec_TpExPr_csvdata_TPMDL_0}\",          'width=\"100%\"',      ]      gui._set_frame(inspect.currentframe())      helpers.test_control_html(gui, html_string, expected_list)      def test_chart_html_2(gui: Gui, helpers, csvdata):      selected_indices = [14258]  # noqa: F841      subplot_layout = {  # noqa: F841          \"grid\": {\"rows\": 1, \"columns\": 2, \"subplots\": [[\"xy\", \"x2y\"]], \"roworder\": \"bottom to top\"}      }      html_string = '<taipy:chart x=\"Day\" selected_color=\"green\" y[1]=\"Daily hospital occupancy\" label[1]=\"Entity\" y[2]=\"Daily hospital occupancy\" label[2]=\"Code\" mode[2]=\"markers\" color[2]=\"red\" type[2]=\"scatter\" xaxis[2]=\"x2\" layout=\"{subplot_layout}\" on_range_change=\"range_change\" width=\"100%\" height=\"100%\" selected=\"{selected_indices}\" >{csvdata}</taipy:chart>'      expected_list = [          \"<Chart\",          \"selected0={tpec_TpExPr_selected_indices_TPMDL_0}\",          \"selected1={tpec_TpExPr_selected_indices_TPMDL_0}\",          'height=\"100%\"',          'defaultLayout=\"{&quot;grid&quot;: &#x7B;&quot;rows&quot;: 1, &quot;columns&quot;: 2, &quot;subplots&quot;: [[&quot;xy&quot;, &quot;x2y&quot;]], &quot;roworder&quot;: &quot;bottom to top&quot;&#x7D;}\"',          'onRangeChange=\"range_change\"',          'updateVars=\"layout=_TpDi_tpec_TpExPr_subplot_layout_TPMDL_0;selected0=tpec_TpExPr_selected_indices_TPMDL_0;selected1=tpec_TpExPr_selected_indices_TPMDL_0\"',          'updateVarName=\"_TpD_tpec_TpExPr_csvdata_TPMDL_0\"',          \"data={_TpD_tpec_TpExPr_csvdata_TPMDL_0}\",          'width=\"100%\"',      ]      gui._set_frame(inspect.currentframe())      helpers.test_control_html(gui, html_string, expected_list)      def test_map_md(gui: Gui, helpers):      mapData = {  # noqa: F841          \"Lat\": [              48.4113,              18.0057,              48.6163,              48.5379,              48.5843,              48.612,              48.6286,              48.6068,              48.4489,              48.6548,              18.5721,              48.3734,              17.6398,              48.5765,              48.4407,              48.2286,          ],          \"Lon\": [              -112.8352,              -65.804,              -113.4784,              -114.0702,              -111.0188,              -110.7939,              -109.4629,              -114.9123,              -112.9705,              -113.965,              -66.5401,              -111.5245,              -64.7246,              -112.1932,              -113.3159,              -104.5863,          ],          \"Globvalue\": [              0.0875,              0.0892,              0.0908,              0.0933,              0.0942,              0.095,              0.095,              0.095,              0.0958,              0.0958,              0.0958,              0.0958,              0.0958,              0.0975,              0.0983,              0.0992,          ],      }      marker = {\"color\": \"fuchsia\", \"size\": 4}  # noqa: F841      layout = {  # noqa: F841          \"dragmode\": \"zoom\",          \"mapbox\": {\"style\": \"open-street-map\", \"center\": {\"lat\": 38, \"lon\": -90}, \"zoom\": 3},          \"margin\": {\"r\": 0, \"t\": 0, \"b\": 0, \"l\": 0},      }      md = \"<|{mapData}|chart|type=scattermapbox|marker={marker}|layout={layout}|lat=Lat|lon=Lon|text=Globvalue|mode=markers|>\"      gui._set_frame(inspect.currentframe())      expected_list = [          \"<Chart\",          \"&quot;Lat&quot;: &#x7B;&quot;index&quot;:\",          \"&quot;Lon&quot;: &#x7B;&quot;index&quot;:\",          \"data={_TpD_tpec_TpExPr_mapData_TPMDL_0}\",          'defaultLayout=\"{&quot;dragmode&quot;: &quot;zoom&quot;, &quot;mapbox&quot;: &#x7B;&quot;style&quot;: &quot;open-street-map&quot;, &quot;center&quot;: &#x7B;&quot;lat&quot;: 38, &quot;lon&quot;: -90&#x7D;, &quot;zoom&quot;: 3&#x7D;, &quot;margin&quot;: &#x7B;&quot;r&quot;: 0, &quot;t&quot;: 0, &quot;b&quot;: 0, &quot;l&quot;: 0&#x7D;}\"',          'updateVarName=\"_TpD_tpec_TpExPr_mapData_TPMDL_0\"',      ]      helpers.test_control_md(gui, md, expected_list)      def test_chart_indexed_properties(gui: Gui, helpers):      data: t.Dict[str, t.Any] = {}      data[\"Date\"] = [datetime.datetime(2021, 12, i) for i in range(1, 31)]        data[\"La Rochelle\"] = [10 + 6 * random.random() for _ in range(1, 31)]      data[\"Montpellier\"] = [16 + 6 * random.random() for _ in range(1, 31)]      data[\"Paris\"] = [6 + 6 * random.random() for _ in range(1, 31)]        data[\"La Rochelle 1\"] = [x * (1 + (random.random() / 10)) for x in data[\"La Rochelle\"]]      data[\"La Rochelle 2\"] = [x * (1 - (random.random() / 10)) for x in data[\"La Rochelle\"]]        data[\"Montpellier 1\"] = [x * (1 + (random.random() / 10)) for x in data[\"Montpellier\"]]      data[\"Montpellier 2\"] = [x * (1 - (random.random() / 10)) for x in data[\"Montpellier\"]]        md = \"<|{data}|chart|x=Date|mode=lines|y[1]=La Rochelle|y[2]=La Rochelle 1|y[3]=La Rochelle 2|y[4]=Montpellier|y[5]=Montpellier 1|y[6]=Montpellier 2|line[2]=dashdot|line[3]=dash|line[5]=dashdot|line[6]=dash|color[2]=blue|color[3]=blue|color[5]=red|color[6]=red|>\"        gui._set_frame(inspect.currentframe())      expected_list = [          \"<Chart\",          \"&quot;traces&quot;: [[&quot;Date_str&quot;, &quot;La Rochelle&quot;], [&quot;Date_str&quot;, &quot;La Rochelle 1&quot;], [&quot;Date_str&quot;, &quot;La Rochelle 2&quot;], [&quot;Date_str&quot;, &quot;Montpellier&quot;], [&quot;Date_str&quot;, &quot;Montpellier 1&quot;], [&quot;Date_str&quot;, &quot;Montpellier 2&quot;]]\",          \"&quot;lines&quot;: [null, &#x7B;&quot;dash&quot;: &quot;dashdot&quot;&#x7D;, &#x7B;&quot;dash&quot;: &quot;dash&quot;&#x7D;, null, &#x7B;&quot;dash&quot;: &quot;dashdot&quot;&#x7D;, &#x7B;&quot;dash&quot;: &quot;dash&quot;&#x7D;]\",      ]      helpers.test_control_md(gui, md, expected_list)      def test_chart_indexed_properties_with_arrays(gui: Gui, helpers):      data: t.Dict[str, t.Any] = {}      data[\"Date\"] = [datetime.datetime(2021, 12, i) for i in range(1, 31)]        data[\"La Rochelle\"] = [10 + 6 * random.random() for _ in range(1, 31)]      data[\"Montpellier\"] = [16 + 6 * random.random() for _ in range(1, 31)]      data[\"Paris\"] = [6 + 6 * random.random() for _ in range(1, 31)]        data[\"La Rochelle 1\"] = [x * (1 + (random.random() / 10)) for x in data[\"La Rochelle\"]]      data[\"La Rochelle 2\"] = [x * (1 - (random.random() / 10)) for x in data[\"La Rochelle\"]]        data[\"Montpellier 1\"] = [x * (1 + (random.random() / 10)) for x in data[\"Montpellier\"]]      data[\"Montpellier 2\"] = [x * (1 - (random.random() / 10)) for x in data[\"Montpellier\"]]        ys = [  # noqa: F841          \"La Rochelle\",          \"La Rochelle 1\",          \"La Rochelle 2\",          \"Montpellier\",          \"Montpellier 1\",          \"Montpellier 2\",      ]      lines = [None, \"dashdot\", \"dash\", None, \"dashdot\", \"dash\"]  # noqa: F841      colors = [None, \"blue\", \"blue\", None, \"red\", \"red\"]  # noqa: F841        md = \"<|{data}|chart|x=Date|mode=lines|y={ys}|line={lines}|color={colors}|>\"        gui._set_frame(inspect.currentframe())      expected_list = [          \"<Chart\",          \"&quot;traces&quot;: [[&quot;Date_str&quot;, &quot;La Rochelle&quot;], [&quot;Date_str&quot;, &quot;La Rochelle 1&quot;], [&quot;Date_str&quot;, &quot;La Rochelle 2&quot;], [&quot;Date_str&quot;, &quot;Montpellier&quot;], [&quot;Date_str&quot;, &quot;Montpellier 1&quot;], [&quot;Date_str&quot;, &quot;Montpellier 2&quot;]]\",          \"&quot;lines&quot;: [null, &#x7B;&quot;dash&quot;: &quot;dashdot&quot;&#x7D;, &#x7B;&quot;dash&quot;: &quot;dash&quot;&#x7D;, null, &#x7B;&quot;dash&quot;: &quot;dashdot&quot;&#x7D;, &#x7B;&quot;dash&quot;: &quot;dash&quot;&#x7D;]\",      ]      helpers.test_control_md(gui, md, 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    # Busiest US airports  # Source: https://en.wikipedia.org/wiki/List_of_busiest_airports_by_passenger_traffic  airports = {      \"AMS\": {\"lat\": 52.31047296675518, \"lon\": 4.76819929439927},      \"ATL\": {\"lat\": 33.64086185344307, \"lon\": -84.43600501711686},      \"AYT\": {\"lat\": 36.90419539293911, \"lon\": 30.801855337974292},      \"BOS\": {\"lat\": 42.36556559649881, \"lon\": -71.00960311751096},      \"CAN\": {\"lat\": 23.38848323741897, \"lon\": 113.30277713668413},      \"CDG\": {\"lat\": 49.008029034119915, \"lon\": 2.550879924581871},      \"CJU\": {\"lat\": 33.51035978854847, \"lon\": 126.4913319405336},      \"CKG\": {\"lat\": 29.71931573810283, \"lon\": 106.64211731662628},      \"CLT\": {\"lat\": 35.214730980190616, \"lon\": -80.9474735034797},      \"CSX\": {\"lat\": 28.196638298182446, \"lon\": 113.22083329905352},      \"CTU\": {\"lat\": 30.567492917634063, \"lon\": 103.94912193845805},      \"CUN\": {\"lat\": 21.04160313837335, \"lon\": -86.87407057500725},      \"DEL\": {\"lat\": 28.556426221725868, \"lon\": 77.10031185913002},      \"DEN\": {\"lat\": 39.85589532386815, \"lon\": -104.67329901305273},      \"DFW\": {\"lat\": 32.89998507111719, \"lon\": -97.04044513206443},      \"DME\": {\"lat\": 55.41032513421412, \"lon\": 37.902386927376234},      \"DTW\": {\"lat\": 42.216145762248594, \"lon\": -83.35541784824225},      \"DXB\": {\"lat\": 25.253155060720765, \"lon\": 55.365672799304534},      \"EWR\": {\"lat\": 40.68951508829295, \"lon\": -74.17446240095387},      \"FLL\": {\"lat\": 26.072469069499288, \"lon\": -80.1502073285754},      \"FRA\": {\"lat\": 50.037870541116, \"lon\": 8.562119610188235},      \"GMP\": {\"lat\": 37.558628944763534, \"lon\": 126.79445244110332},      \"GRU\": {\"lat\": -23.430691200492866, \"lon\": -46.473107371367846},      \"HGH\": {\"lat\": 30.2359856421667, \"lon\": 120.43880486944619},      \"HND\": {\"lat\": 35.54938443207139, \"lon\": 139.77979568388005},      \"IAH\": {\"lat\": 29.98997826322153, \"lon\": -95.33684707873988},      \"IST\": {\"lat\": 41.27696594578831, \"lon\": 28.73004303446375},      \"JFK\": {\"lat\": 40.64129497654287, \"lon\": -73.77813830094803},      \"KMG\": {\"lat\": 24.99723271310971, \"lon\": 102.74030761670535},      \"LAS\": {\"lat\": 36.08256046166282, \"lon\": -115.15700045025673},      \"LAX\": {\"lat\": 33.94157995977848, \"lon\": -118.40848708486908},      \"MAD\": {\"lat\": 40.49832400063489, \"lon\": -3.5676196584173754},      \"MCO\": {\"lat\": 28.419119921670067, \"lon\": -81.30451008534465},      \"MEX\": {\"lat\": 19.436096410278736, \"lon\": -99.07204777544095},      \"MIA\": {\"lat\": 25.795823878101675, \"lon\": -80.28701871639629},      \"MSP\": {\"lat\": 44.88471735079015, \"lon\": -93.22233824616785},      \"ORD\": {\"lat\": 41.98024003208415, \"lon\": -87.9089657513565},      \"PEK\": {\"lat\": 40.079816213451416, \"lon\": 116.60309064055198},      \"PHX\": {\"lat\": 33.43614430802288, \"lon\": -112.01128270596944},      \"PKX\": {\"lat\": 39.50978840400886, \"lon\": 116.41050689906415},      \"PVG\": {\"lat\": 31.144398958515847, \"lon\": 121.80823008537978},      \"SAW\": {\"lat\": 40.9053709590178, \"lon\": 29.316838841845318},      \"SEA\": {\"lat\": 47.448024349661814, \"lon\": -122.30897973141963},      \"SFO\": {\"lat\": 37.62122788155908, \"lon\": -122.37901977603573},      \"SHA\": {\"lat\": 31.192227319334787, \"lon\": 121.33425408454256},      \"SLC\": {\"lat\": 40.78985913031307, \"lon\": -111.97911351851535},      \"SVO\": {\"lat\": 55.97381026156798, \"lon\": 37.412288430689664},      \"SZX\": {\"lat\": 22.636827890877626, \"lon\": 113.81454162446936},      \"WUH\": {\"lat\": 30.776589409566686, \"lon\": 114.21244949898504},      \"XIY\": {\"lat\": 34.437119809208546, \"lon\": 108.7573508575816},  }    # Inter US airports flights  # Source: https://www.faa.gov/air_traffic/by_the_numbers  flights = [      {\"from\": \"ATL\", \"to\": \"DFW\", \"traffic\": 580},      {\"from\": \"ATL\", \"to\": \"MIA\", \"traffic\": 224},      {\"from\": \"BOS\", \"to\": \"LAX\", \"traffic\": 168},      {\"from\": \"DEN\", \"to\": \"DFW\", \"traffic\": 558},      {\"from\": \"DFW\", \"to\": \"BOS\", \"traffic\": 422},      {\"from\": \"DFW\", \"to\": \"CLT\", \"traffic\": 360},      {\"from\": \"DFW\", \"to\": \"JFK\", \"traffic\": 56},      {\"from\": \"DFW\", \"to\": \"LAS\", \"traffic\": 569},      {\"from\": \"DFW\", \"to\": \"SEA\", \"traffic\": 392},      {\"from\": \"DTW\", \"to\": \"DFW\", \"traffic\": 260},      {\"from\": \"EWR\", \"to\": \"DFW\", \"traffic\": 310},      {\"from\": \"EWR\", \"to\": \"ORD\", \"traffic\": 168},      {\"from\": \"FLL\", \"to\": \"DFW\", \"traffic\": 336},      {\"from\": \"FLL\", \"to\": \"ORD\", \"traffic\": 168},      {\"from\": \"IAH\", \"to\": \"DFW\", \"traffic\": 324},      {\"from\": \"JFK\", \"to\": \"FLL\", \"traffic\": 112},      {\"from\": \"JFK\", \"to\": \"LAS\", \"traffic\": 112},      {\"from\": \"JFK\", \"to\": \"LAX\", \"traffic\": 548},      {\"from\": \"JFK\", \"to\": \"ORD\", \"traffic\": 56},      {\"from\": \"LAS\", \"to\": \"MIA\", \"traffic\": 168},      {\"from\": \"LAX\", \"to\": \"DFW\", \"traffic\": 914},      {\"from\": \"LAX\", \"to\": \"EWR\", \"traffic\": 54},      {\"from\": \"LAX\", \"to\": \"LAS\", \"traffic\": 222},      {\"from\": \"LAX\", \"to\": \"MCO\", \"traffic\": 56},      {\"from\": \"LAX\", \"to\": \"MIA\", \"traffic\": 392},      {\"from\": \"LAX\", \"to\": \"SFO\", \"traffic\": 336},      {\"from\": \"MCO\", \"to\": \"DFW\", \"traffic\": 500},      {\"from\": \"MCO\", \"to\": \"JFK\", \"traffic\": 224},      {\"from\": \"MCO\", \"to\": \"ORD\", \"traffic\": 224},      {\"from\": \"MIA\", \"to\": \"BOS\", \"traffic\": 392},      {\"from\": \"MIA\", \"to\": \"DEN\", \"traffic\": 112},      {\"from\": \"MIA\", \"to\": \"DFW\", \"traffic\": 560},      {\"from\": \"MIA\", \"to\": \"DTW\", \"traffic\": 112},      {\"from\": \"MIA\", \"to\": \"EWR\", \"traffic\": 168},      {\"from\": \"MIA\", \"to\": \"IAH\", \"traffic\": 168},      {\"from\": \"MIA\", \"to\": \"JFK\", \"traffic\": 392},      {\"from\": \"MIA\", \"to\": \"MCO\", \"traffic\": 448},      {\"from\": \"MSP\", \"to\": \"DFW\", \"traffic\": 326},      {\"from\": \"MSP\", \"to\": \"MIA\", \"traffic\": 56},      {\"from\": \"ORD\", \"to\": \"BOS\", \"traffic\": 430},      {\"from\": \"ORD\", \"to\": \"DEN\", \"traffic\": 112},      {\"from\": \"ORD\", \"to\": \"DFW\", \"traffic\": 825},      {\"from\": \"ORD\", \"to\": \"LAS\", \"traffic\": 280},      {\"from\": \"ORD\", \"to\": \"LAX\", \"traffic\": 496},      {\"from\": \"ORD\", \"to\": \"MIA\", \"traffic\": 505},      {\"from\": \"ORD\", \"to\": \"MSP\", \"traffic\": 160},      {\"from\": \"ORD\", \"to\": \"PHX\", \"traffic\": 280},      {\"from\": \"ORD\", \"to\": \"SEA\", \"traffic\": 214},      {\"from\": \"ORD\", \"to\": \"SFO\", \"traffic\": 326},      {\"from\": \"PHX\", \"to\": \"DFW\", \"traffic\": 550},      {\"from\": \"PHX\", \"to\": \"MIA\", \"traffic\": 56},      {\"from\": \"SEA\", \"to\": \"JFK\", \"traffic\": 56},      {\"from\": \"SFO\", \"to\": \"DFW\", \"traffic\": 526},      {\"from\": \"SFO\", \"to\": \"JFK\", \"traffic\": 278},      {\"from\": \"SFO\", \"to\": \"MIA\", \"traffic\": 168},      {\"from\": \"SLC\", \"to\": \"DFW\", \"traffic\": 280},  ]    data = []  max_traffic = 0  for flight in flights:      airport_from = airports[flight[\"from\"]]      airport_to = airports[flight[\"to\"]]      # Define data source to plot this flight      data.append({\"lat\": [airport_from[\"lat\"], airport_to[\"lat\"]], \"lon\": [airport_from[\"lon\"], airport_to[\"lon\"]]})      # Store the maximum traffic      if flight[\"traffic\"] > max_traffic:          max_traffic = flight[\"traffic\"]    properties = {      # Chart data      \"data\": data,      # Chart type      \"type\": \"scattergeo\",      # Keep lines only      \"mode\": \"lines\",      # Flights display as redish lines      \"line\": {\"width\": 2, \"color\": \"E22\"},      \"layout\": {          # Focus on the USA region          \"geo\": {\"scope\": \"usa\"}      },  }    # Set the proper data source and opacity for each trace  for i, flight in enumerate(flights):      # lat[trace_index] = \"[index_in_data]/lat\"      properties[f\"lat[{i+1}]\"] = f\"{i}/lat\"      # lon[trace_index] = \"[index_in_data]/lon\"      properties[f\"lon[{i+1}]\"] = f\"{i}/lon\"      # Set flight opacity (max traffic -> max opacity)      # Hide legend for all flights      properties[f\"options[{i+1}]\"] = {\"opacity\": flight[\"traffic\"] / max_traffic, \"showlegend\": False}    page = \"\"\"  # Maps - Multiple Lines    <|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    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>  # -----------------------------------------------------------------------------------------  import pandas    from taipy.gui import Gui    dates = pandas.date_range(\"2023-01-01\", periods=365, freq=\"D\")  temp = [      -11.33333333,      -6,      -0.111111111,      1.444444444,      2.388888889,      4.555555556,      4.333333333,      0.666666667,      9,      9.611111111,      -0.555555556,      1.833333333,      -0.444444444,      2.166666667,      -4,      -12.05555556,      -2.722222222,      5,      9.888888889,      6.611111111,      -2.833333333,      -3.277777778,      -1.611111111,      -1.388888889,      5.777777778,      2.166666667,      -1.055555556,      1.777777778,      1.5,      8.444444444,      6.222222222,      -2.5,      -0.388888889,      6.111111111,      -1.5,      2.666666667,      -2.5,      0.611111111,      8.222222222,      2.333333333,      -9.333333333,      -7.666666667,      -6.277777778,      -0.611111111,      7.722222222,      6.111111111,      -4,      3.388888889,      9.333333333,      -6.333333333,      -15,      -12.94444444,      -8.722222222,      -6.222222222,      -2.833333333,      -2.5,      1.5,      3.444444444,      2.666666667,      0.888888889,      7.555555556,      12.66666667,      12.83333333,      1.777777778,      -0.111111111,      -1.055555556,      4.611111111,      11.16666667,      8.5,      0.5,      2.111111111,      4.722222222,      8.277777778,      10.66666667,      5.833333333,      5.555555556,      6.944444444,      1.722222222,      2.444444444,      6.111111111,      12.11111111,      15.55555556,      9.944444444,      10.27777778,      5.888888889,      1.388888889,      3.555555556,      1.222222222,      4.055555556,      7.833333333,      0.666666667,      10.05555556,      6.444444444,      4.555555556,      11,      3.555555556,      -0.555555556,      11.83333333,      7.222222222,      10.16666667,      17.5,      14.55555556,      6.777777778,      3.611111111,      5.888888889,      10.05555556,      16.61111111,      5.5,      7.055555556,      10.5,      1.555555556,      6.166666667,      11.05555556,      5.111111111,      6.055555556,      11,      11.05555556,      14.72222222,      19.16666667,      16.5,      12.61111111,      8.277777778,      6.611111111,      10.38888889,      15.38888889,      17.22222222,      18.27777778,      18.72222222,      17.05555556,      19.72222222,      16.83333333,      12.66666667,      11.66666667,      12.88888889,      14.77777778,      18,      19.44444444,      16.5,      9.722222222,      7.888888889,      13.72222222,      17.55555556,      18.27777778,      20.11111111,      21.66666667,      23.38888889,      23.5,      16.94444444,      16.27777778,      18.61111111,      20.83333333,      24.61111111,      18.27777778,      17.88888889,      22.27777778,      25.94444444,      25.27777778,      24.72222222,      25.61111111,      23.94444444,      26.33333333,      22.05555556,      20.83333333,      24.5,      27.83333333,      25.61111111,      23.11111111,      19.27777778,      16.44444444,      19.44444444,      17.22222222,      19.44444444,      22.16666667,      21.77777778,      17.38888889,      17.22222222,      23.88888889,      28.44444444,      29.44444444,      29.61111111,      21.05555556,      18.55555556,      25.27777778,      26.55555556,      24.55555556,      23.38888889,      22.55555556,      27.05555556,      27.66666667,      26.66666667,      27.61111111,      26.66666667,      24.77777778,      23,      26.5,      23.11111111,      19.83333333,      22.27777778,      24.61111111,      27.05555556,      27.05555556,      27.94444444,      27.33333333,      22.05555556,      21.5,      22,      19.72222222,      20.27777778,      17.88888889,      18.55555556,      18.94444444,      20,      22.05555556,      23.22222222,      24.38888889,      24.5,      24.5,      21.22222222,      20.83333333,      20.61111111,      22.05555556,      23.77777778,      24.16666667,      24.22222222,      21.83333333,      21.33333333,      21.88888889,      22.44444444,      23.11111111,      20.44444444,      16.88888889,      15.77777778,      17.44444444,      17.72222222,      23.11111111,      24.55555556,      24.88888889,      25.11111111,      25.27777778,      19.5,      19.55555556,      24.05555556,      24.27777778,      21.05555556,      19.88888889,      20.66666667,      20.27777778,      17.66666667,      16.44444444,      15.88888889,      18.44444444,      22.44444444,      23,      24.72222222,      24.16666667,      25.94444444,      24.44444444,      23.33333333,      25.22222222,      25,      23.88888889,      23.72222222,      18.94444444,      16.22222222,      19.5,      21.22222222,      19.72222222,      13.22222222,      11.88888889,      16.55555556,      10.05555556,      12.16666667,      11.5,      10.22222222,      17.27777778,      21.72222222,      13.83333333,      13,      6.944444444,      6.388888889,      4.222222222,      2.5,      1.111111111,      3.055555556,      6.388888889,      10.44444444,      -2,      -2.222222222,      4.388888889,      8.333333333,      11.11111111,      12.66666667,      10.88888889,      12.83333333,      14.16666667,      12.55555556,      12.05555556,      11.22222222,      12.44444444,      14.38888889,      12,      15.83333333,      6.722222222,      2.5,      4.833333333,      7.5,      8.888888889,      4,      7.388888889,      3.888888889,      1.611111111,      -0.333333333,      -2,      4.833333333,      -1.055555556,      -5.611111111,      -2.388888889,      5.722222222,      8.444444444,      5.277777778,      0.5,      -2.5,      1.111111111,      2.111111111,      5.777777778,      7.555555556,      7.555555556,      4.111111111,      -0.388888889,      -1,      4.944444444,      9.444444444,      4.722222222,      -0.166666667,      0.5,      -2.444444444,      -2.722222222,      -2.888888889,      -1.111111111,      -4.944444444,      -3.111111111,      -1.444444444,      -0.833333333,      2.333333333,      6.833333333,      4.722222222,      0.888888889,      0.666666667,      4.611111111,      4.666666667,      4.444444444,      6.777777778,      5.833333333,      0.5,      4.888888889,      1.444444444,      -2.111111111,      2.444444444,      -0.111111111,      -2.555555556,      -4.611111111,      -8.666666667,      -8.055555556,      1.555555556,      -4.777777778,  ]  min = [      -14.33333333,      -12.9,      -3.311111111,      -4.955555556,      -3.611111111,      0.555555556,      1.133333333,      -5.133333333,      2.3,      3.911111111,      -7.055555556,      -1.366666667,      -4.844444444,      -3.333333333,      -6.1,      -17.15555556,      -4.822222222,      0.4,      3.488888889,      4.211111111,      -6.433333333,      -7.577777778,      -7.111111111,      -7.088888889,      1.577777778,      -3.433333333,      -4.355555556,      -0.722222222,      -2.1,      2.044444444,      2.222222222,      -4.7,      -2.388888889,      4.111111111,      -5,      -0.133333333,      -5.3,      -2.288888889,      6.022222222,      -1.766666667,      -15.53333333,      -13.46666667,      -9.277777778,      -3.211111111,      3.122222222,      1.411111111,      -6.8,      1.388888889,      5.333333333,      -9.833333333,      -22,      -19.74444444,      -14.62222222,      -9.622222222,      -8.433333333,      -8.5,      -2.8,      0.144444444,      -3.233333333,      -3.411111111,      5.355555556,      8.366666667,      7.333333333,      -0.322222222,      -6.911111111,      -4.955555556,      -1.588888889,      4.966666667,      2.5,      -4.3,      -1.888888889,      -1.777777778,      2.477777778,      3.766666667,      0.533333333,      1.755555556,      2.944444444,      -4.977777778,      -4.055555556,      1.711111111,      6.011111111,      13.15555556,      5.044444444,      6.577777778,      3.388888889,      -1.011111111,      -0.244444444,      -2.477777778,      -1.444444444,      2.533333333,      -6.333333333,      4.255555556,      1.944444444,      0.855555556,      5.4,      -1.244444444,      -2.855555556,      4.833333333,      2.722222222,      6.466666667,      14.5,      9.855555556,      2.277777778,      -3.188888889,      0.788888889,      4.155555556,      13.41111111,      2.3,      0.855555556,      8.4,      -0.444444444,      1.166666667,      7.755555556,      -0.288888889,      -0.244444444,      8.7,      5.555555556,      8.222222222,      16.26666667,      14.4,      5.711111111,      5.177777778,      4.511111111,      5.988888889,      10.08888889,      10.52222222,      15.37777778,      12.42222222,      14.95555556,      15.22222222,      11.93333333,      6.866666667,      6.866666667,      9.688888889,      11.57777778,      12,      13.34444444,      11.3,      6.222222222,      2.088888889,      8.322222222,      14.05555556,      13.77777778,      16.91111111,      16.86666667,      16.68888889,      18.5,      12.54444444,      12.27777778,      15.91111111,      15.03333333,      22.11111111,      15.77777778,      13.68888889,      17.87777778,      19.94444444,      18.57777778,      18.62222222,      20.11111111,      17.14444444,      20.43333333,      15.75555556,      17.33333333,      20,      23.03333333,      19.61111111,      18.51111111,      15.27777778,      11.44444444,      13.64444444,      11.42222222,      16.14444444,      19.76666667,      18.77777778,      11.88888889,      12.32222222,      20.78888889,      25.04444444,      25.34444444,      23.81111111,      18.35555556,      11.85555556,      18.37777778,      23.15555556,      21.55555556,      17.48888889,      19.05555556,      20.25555556,      23.86666667,      23.86666667,      21.41111111,      21.16666667,      18.67777778,      18.1,      24.4,      19.01111111,      17.13333333,      18.27777778,      21.71111111,      22.85555556,      22.65555556,      25.14444444,      24.13333333,      17.95555556,      14.7,      15.1,      16.02222222,      14.27777778,      11.18888889,      13.65555556,      16.74444444,      16.7,      17.65555556,      16.62222222,      21.68888889,      19.6,      18.6,      15.52222222,      18.53333333,      17.01111111,      17.75555556,      20.47777778,      17.76666667,      22.22222222,      18.23333333,      17.83333333,      15.38888889,      19.64444444,      17.81111111,      15.44444444,      14.88888889,      13.07777778,      15.24444444,      11.82222222,      20.81111111,      21.45555556,      18.98888889,      19.71111111,      19.27777778,      12.7,      15.05555556,      19.15555556,      20.77777778,      15.35555556,      17.68888889,      18.26666667,      15.47777778,      12.76666667,      10.54444444,      13.38888889,      12.54444444,      19.84444444,      19.5,      21.92222222,      17.86666667,      22.44444444,      19.64444444,      20.73333333,      22.02222222,      19,      20.48888889,      19.02222222,      16.44444444,      14.22222222,      16.3,      16.42222222,      17.22222222,      8.322222222,      8.288888889,      13.95555556,      5.555555556,      5.666666667,      7.7,      4.022222222,      11.77777778,      16.42222222,      11.83333333,      9.7,      0.044444444,      3.688888889,      -2.077777778,      0.1,      -5.388888889,      -3.244444444,      0.688888889,      5.744444444,      -7.7,      -7.022222222,      -0.211111111,      4.833333333,      8.111111111,      5.766666667,      7.888888889,      10.43333333,      11.56666667,      10.15555556,      7.155555556,      4.522222222,      7.144444444,      10.88888889,      9.5,      12.13333333,      4.022222222,      -3.9,      1.433333333,      0.7,      3.188888889,      -1.7,      3.588888889,      -0.111111111,      -2.788888889,      -7.133333333,      -5,      0.733333333,      -7.555555556,      -12.51111111,      -8.188888889,      3.122222222,      2.944444444,      0.477777778,      -3.2,      -9.2,      -4.788888889,      -0.288888889,      1.077777778,      4.755555556,      5.455555556,      0.511111111,      -3.888888889,      -7.4,      -1.355555556,      5.144444444,      0.122222222,      -5.166666667,      -5,      -5.144444444,      -8.822222222,      -6.388888889,      -6.811111111,      -8.944444444,      -10.11111111,      -7.144444444,      -5.133333333,      -1.166666667,      1.833333333,      -1.477777778,      -1.811111111,      -2.433333333,      -1.188888889,      -2.333333333,      0.744444444,      1.877777778,      1.333333333,      -1.7,      0.888888889,      -3.855555556,      -8.211111111,      -1.055555556,      -4.211111111,      -7.355555556,      -8.111111111,      -10.96666667,      -13.05555556,      -4.644444444,      -7.577777778,  ]  max = [      -7.233333333,      -1.6,      5.488888889,      7.744444444,      6.188888889,      6.555555556,      10.53333333,      6.766666667,      14.1,      14.11111111,      2.044444444,      4.633333333,      2.055555556,      8.666666667,      -1.4,      -5.555555556,      4.177777778,      11.8,      15.58888889,      12.31111111,      3.666666667,      -0.977777778,      1.288888889,      4.211111111,      9.377777778,      5.266666667,      2.144444444,      3.977777778,      7.2,      11.94444444,      11.32222222,      4,      6.611111111,      8.211111111,      3.5,      8.866666667,      3.6,      3.711111111,      13.12222222,      7.833333333,      -3.333333333,      -2.166666667,      -2.877777778,      5.188888889,      13.12222222,      12.11111111,      -0.7,      6.688888889,      14.03333333,      -2.433333333,      -8.6,      -8.244444444,      -2.122222222,      -2.722222222,      1.266666667,      2.8,      5.7,      6.944444444,      5.066666667,      5.688888889,      13.35555556,      16.66666667,      17.33333333,      7.277777778,      6.388888889,      1.344444444,      9.111111111,      17.96666667,      12.8,      5.8,      6.911111111,      6.822222222,      11.87777778,      13.16666667,      9.233333333,      8.655555556,      10.04444444,      7.022222222,      7.644444444,      8.311111111,      16.71111111,      18.85555556,      12.14444444,      13.27777778,      11.18888889,      7.088888889,      8.255555556,      7.522222222,      9.955555556,      9.933333333,      4.866666667,      15.25555556,      9.244444444,      9.755555556,      14,      8.955555556,      2.344444444,      17.43333333,      12.12222222,      13.46666667,      23,      18.45555556,      12.77777778,      7.211111111,      8.588888889,      14.35555556,      19.01111111,      12.4,      9.155555556,      15.6,      4.955555556,      8.966666667,      16.95555556,      9.511111111,      10.15555556,      16,      14.45555556,      21.02222222,      25.76666667,      20.5,      15.71111111,      11.67777778,      12.81111111,      12.88888889,      17.58888889,      23.12222222,      21.77777778,      24.42222222,      20.05555556,      24.32222222,      18.83333333,      19.56666667,      14.96666667,      19.68888889,      18.57777778,      23,      23.34444444,      20.7,      11.82222222,      11.48888889,      17.52222222,      22.55555556,      20.47777778,      23.01111111,      27.86666667,      30.28888889,      30.3,      22.94444444,      18.57777778,      25.51111111,      24.13333333,      30.01111111,      24.77777778,      20.28888889,      28.67777778,      32.74444444,      31.37777778,      28.52222222,      31.81111111,      27.24444444,      32.53333333,      26.15555556,      24.63333333,      28.3,      31.23333333,      32.21111111,      28.21111111,      23.07777778,      21.64444444,      24.34444444,      19.62222222,      25.14444444,      24.46666667,      23.87777778,      21.28888889,      20.22222222,      29.98888889,      32.04444444,      36.44444444,      36.01111111,      24.85555556,      23.45555556,      29.17777778,      32.25555556,      28.75555556,      30.28888889,      28.85555556,      30.45555556,      31.26666667,      28.86666667,      33.31111111,      30.66666667,      28.67777778,      27.4,      32.2,      25.41111111,      22.23333333,      26.67777778,      30.21111111,      29.15555556,      29.65555556,      31.94444444,      31.43333333,      28.35555556,      24.8,      25.5,      25.42222222,      24.17777778,      20.88888889,      24.35555556,      25.54444444,      22,      27.95555556,      29.42222222,      28.88888889,      26.8,      28.2,      26.92222222,      24.13333333,      22.61111111,      26.15555556,      30.57777778,      30.86666667,      29.92222222,      27.33333333,      23.43333333,      24.68888889,      26.94444444,      28.81111111,      25.54444444,      22.48888889,      21.67777778,      19.74444444,      23.82222222,      25.91111111,      30.85555556,      28.48888889,      29.21111111,      28.37777778,      22.4,      25.55555556,      27.35555556,      30.67777778,      27.95555556,      25.98888889,      23.46666667,      25.37777778,      20.46666667,      22.54444444,      20.18888889,      22.24444444,      26.84444444,      25.8,      29.62222222,      26.36666667,      32.24444444,      29.84444444,      28.33333333,      31.22222222,      29.9,      29.98888889,      27.42222222,      25.54444444,      20.22222222,      24,      24.52222222,      25.02222222,      16.12222222,      17.58888889,      23.25555556,      15.75555556,      18.66666667,      18.4,      12.52222222,      20.07777778,      28.62222222,      17.23333333,      16.6,      13.34444444,      10.98888889,      9.522222222,      5.8,      6.811111111,      6.555555556,      12.18888889,      12.64444444,      4.2,      3.577777778,      8.888888889,      15.23333333,      16.11111111,      18.36666667,      16.98888889,      15.63333333,      16.46666667,      15.55555556,      15.65555556,      17.42222222,      18.74444444,      19.48888889,      15.9,      19.73333333,      13.02222222,      8.1,      8.933333333,      11.3,      12.38888889,      8.3,      12.38888889,      6.388888889,      4.211111111,      4.666666667,      0.7,      7.133333333,      2.344444444,      1.088888889,      0.111111111,      11.62222222,      10.84444444,      8.777777778,      3.5,      3.4,      7.211111111,      5.711111111,      9.677777778,      12.25555556,      10.15555556,      6.511111111,      4.911111111,      1.5,      11.44444444,      15.54444444,      8.122222222,      6.233333333,      7,      4.355555556,      0.277777778,      3.711111111,      2.888888889,      1.555555556,      3.888888889,      4.555555556,      5.666666667,      7.833333333,      9.833333333,      10.02222222,      6.288888889,      5.366666667,      11.41111111,      9.566666667,      9.744444444,      13.57777778,      9.433333333,      3.1,      11.08888889,      3.844444444,      2.488888889,      7.544444444,      4.488888889,      -0.455555556,      -2.111111111,      -3.566666667,      -1.955555556,      3.955555556,      1.222222222,  ]    start = 50  size = 100  data = {\"Date\": dates[start:size], \"Temp\u00b0C\": temp[start:size], \"Min\": min[start:size], \"Max\": max[start:size]}    page = \"\"\"  # Line - Style    <|{data}|chart|mode=lines|x=Date|y[1]=Temp\u00b0C|y[2]=Min|y[3]=Max|line[1]=dash|color[2]=blue|color[3]=red|>  \"\"\"    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>  # -----------------------------------------------------------------------------------------  import numpy  import pandas    from taipy.gui import Gui    # Largest cities: name, location and population  # Source: https://simplemaps.com/data/world-cities  cities = [      {\"name\": \"Tokyo\", \"lat\": 35.6839, \"lon\": 139.7744, \"population\": 39105000},      {\"name\": \"Jakarta\", \"lat\": -6.2146, \"lon\": 106.8451, \"population\": 35362000},      {\"name\": \"Delhi\", \"lat\": 28.6667, \"lon\": 77.2167, \"population\": 31870000},      {\"name\": \"Manila\", \"lat\": 14.6, \"lon\": 120.9833, \"population\": 23971000},      {\"name\": \"S\u00e3o Paulo\", \"lat\": -23.5504, \"lon\": -46.6339, \"population\": 22495000},      {\"name\": \"Seoul\", \"lat\": 37.56, \"lon\": 126.99, \"population\": 22394000},      {\"name\": \"Mumbai\", \"lat\": 19.0758, \"lon\": 72.8775, \"population\": 22186000},      {\"name\": \"Shanghai\", \"lat\": 31.1667, \"lon\": 121.4667, \"population\": 22118000},      {\"name\": \"Mexico City\", \"lat\": 19.4333, \"lon\": -99.1333, \"population\": 21505000},      {\"name\": \"Guangzhou\", \"lat\": 23.1288, \"lon\": 113.259, \"population\": 21489000},      {\"name\": \"Cairo\", \"lat\": 30.0444, \"lon\": 31.2358, \"population\": 19787000},      {\"name\": \"Beijing\", \"lat\": 39.904, \"lon\": 116.4075, \"population\": 19437000},      {\"name\": \"New York\", \"lat\": 40.6943, \"lon\": -73.9249, \"population\": 18713220},      {\"name\": \"Kolk\u0101ta\", \"lat\": 22.5727, \"lon\": 88.3639, \"population\": 18698000},      {\"name\": \"Moscow\", \"lat\": 55.7558, \"lon\": 37.6178, \"population\": 17693000},      {\"name\": \"Bangkok\", \"lat\": 13.75, \"lon\": 100.5167, \"population\": 17573000},      {\"name\": \"Dhaka\", \"lat\": 23.7289, \"lon\": 90.3944, \"population\": 16839000},      {\"name\": \"Buenos Aires\", \"lat\": -34.5997, \"lon\": -58.3819, \"population\": 16216000},      {\"name\": \"\u014csaka\", \"lat\": 34.752, \"lon\": 135.4582, \"population\": 15490000},      {\"name\": \"Lagos\", \"lat\": 6.45, \"lon\": 3.4, \"population\": 15487000},      {\"name\": \"Istanbul\", \"lat\": 41.01, \"lon\": 28.9603, \"population\": 15311000},      {\"name\": \"Karachi\", \"lat\": 24.86, \"lon\": 67.01, \"population\": 15292000},      {\"name\": \"Kinshasa\", \"lat\": -4.3317, \"lon\": 15.3139, \"population\": 15056000},      {\"name\": \"Shenzhen\", \"lat\": 22.535, \"lon\": 114.054, \"population\": 14678000},      {\"name\": \"Bangalore\", \"lat\": 12.9791, \"lon\": 77.5913, \"population\": 13999000},      {\"name\": \"Ho Chi Minh City\", \"lat\": 10.8167, \"lon\": 106.6333, \"population\": 13954000},      {\"name\": \"Tehran\", \"lat\": 35.7, \"lon\": 51.4167, \"population\": 13819000},      {\"name\": \"Los Angeles\", \"lat\": 34.1139, \"lon\": -118.4068, \"population\": 12750807},      {\"name\": \"Rio de Janeiro\", \"lat\": -22.9083, \"lon\": -43.1964, \"population\": 12486000},      {\"name\": \"Chengdu\", \"lat\": 30.66, \"lon\": 104.0633, \"population\": 11920000},      {\"name\": \"Baoding\", \"lat\": 38.8671, \"lon\": 115.4845, \"population\": 11860000},      {\"name\": \"Chennai\", \"lat\": 13.0825, \"lon\": 80.275, \"population\": 11564000},      {\"name\": \"Lahore\", \"lat\": 31.5497, \"lon\": 74.3436, \"population\": 11148000},      {\"name\": \"London\", \"lat\": 51.5072, \"lon\": -0.1275, \"population\": 11120000},      {\"name\": \"Paris\", \"lat\": 48.8566, \"lon\": 2.3522, \"population\": 11027000},      {\"name\": \"Tianjin\", \"lat\": 39.1467, \"lon\": 117.2056, \"population\": 10932000},      {\"name\": \"Linyi\", \"lat\": 35.0606, \"lon\": 118.3425, \"population\": 10820000},      {\"name\": \"Shijiazhuang\", \"lat\": 38.0422, \"lon\": 114.5086, \"population\": 10784600},      {\"name\": \"Zhengzhou\", \"lat\": 34.7492, \"lon\": 113.6605, \"population\": 10136000},      {\"name\": \"Nanyang\", \"lat\": 32.9987, \"lon\": 112.5292, \"population\": 10013600},      {\"name\": \"Hyder\u0101b\u0101d\", \"lat\": 17.3617, \"lon\": 78.4747, \"population\": 9840000},      {\"name\": \"Wuhan\", \"lat\": 30.5872, \"lon\": 114.2881, \"population\": 9729000},      {\"name\": \"Handan\", \"lat\": 36.6116, \"lon\": 114.4894, \"population\": 9549700},      {\"name\": \"Nagoya\", \"lat\": 35.1167, \"lon\": 136.9333, \"population\": 9522000},      {\"name\": \"Weifang\", \"lat\": 36.7167, \"lon\": 119.1, \"population\": 9373000},      {\"name\": \"Lima\", \"lat\": -12.06, \"lon\": -77.0375, \"population\": 8992000},      {\"name\": \"Zhoukou\", \"lat\": 33.625, \"lon\": 114.6418, \"population\": 8953172},      {\"name\": \"Luanda\", \"lat\": -8.8383, \"lon\": 13.2344, \"population\": 8883000},      {\"name\": \"Ganzhou\", \"lat\": 25.8292, \"lon\": 114.9336, \"population\": 8677600},      {\"name\": \"Tongshan\", \"lat\": 34.261, \"lon\": 117.1859, \"population\": 8669000},      {\"name\": \"Kuala Lumpur\", \"lat\": 3.1478, \"lon\": 101.6953, \"population\": 8639000},      {\"name\": \"Chicago\", \"lat\": 41.8373, \"lon\": -87.6862, \"population\": 8604203},      {\"name\": \"Heze\", \"lat\": 35.2333, \"lon\": 115.4333, \"population\": 8287693},      {\"name\": \"Chongqing\", \"lat\": 29.55, \"lon\": 106.5069, \"population\": 8261000},      {\"name\": \"Hanoi\", \"lat\": 21.0245, \"lon\": 105.8412, \"population\": 8246600},      {\"name\": \"Fuyang\", \"lat\": 32.8986, \"lon\": 115.8045, \"population\": 8200264},      {\"name\": \"Changsha\", \"lat\": 28.1987, \"lon\": 112.9709, \"population\": 8154700},      {\"name\": \"Dongguan\", \"lat\": 23.0475, \"lon\": 113.7493, \"population\": 8142000},      {\"name\": \"Jining\", \"lat\": 35.4, \"lon\": 116.5667, \"population\": 8081905},      {\"name\": \"Jinan\", \"lat\": 36.6667, \"lon\": 116.9833, \"population\": 7967400},      {\"name\": \"Pune\", \"lat\": 18.5196, \"lon\": 73.8553, \"population\": 7948000},      {\"name\": \"Foshan\", \"lat\": 23.0292, \"lon\": 113.1056, \"population\": 7905700},      {\"name\": \"Bogot\u00e1\", \"lat\": 4.6126, \"lon\": -74.0705, \"population\": 7743955},      {\"name\": \"Ahmedabad\", \"lat\": 23.03, \"lon\": 72.58, \"population\": 7717000},      {\"name\": \"Nanjing\", \"lat\": 32.05, \"lon\": 118.7667, \"population\": 7729000},      {\"name\": \"Changchun\", \"lat\": 43.9, \"lon\": 125.2, \"population\": 7674439},      {\"name\": \"Tangshan\", \"lat\": 39.6292, \"lon\": 118.1742, \"population\": 7577289},      {\"name\": \"Cangzhou\", \"lat\": 38.3037, \"lon\": 116.8452, \"population\": 7544300},      {\"name\": \"Dar es Salaam\", \"lat\": -6.8, \"lon\": 39.2833, \"population\": 7461000},      {\"name\": \"Hefei\", \"lat\": 31.8639, \"lon\": 117.2808, \"population\": 7457027},      {\"name\": \"Hong Kong\", \"lat\": 22.3069, \"lon\": 114.1831, \"population\": 7398000},      {\"name\": \"Shaoyang\", \"lat\": 27.2418, \"lon\": 111.4725, \"population\": 7370500},      {\"name\": \"Zhanjiang\", \"lat\": 21.1967, \"lon\": 110.4031, \"population\": 7332000},      {\"name\": \"Shangqiu\", \"lat\": 34.4259, \"lon\": 115.6467, \"population\": 7325300},      {\"name\": \"Nantong\", \"lat\": 31.9829, \"lon\": 120.8873, \"population\": 7283622},      {\"name\": \"Yancheng\", \"lat\": 33.3936, \"lon\": 120.1339, \"population\": 7260240},      {\"name\": \"Nanning\", \"lat\": 22.8192, \"lon\": 108.315, \"population\": 7254100},      {\"name\": \"Hengyang\", \"lat\": 26.8968, \"lon\": 112.5857, \"population\": 7243400},      {\"name\": \"Zhumadian\", \"lat\": 32.9773, \"lon\": 114.0253, \"population\": 7231234},      {\"name\": \"Shenyang\", \"lat\": 41.8039, \"lon\": 123.4258, \"population\": 7208000},      {\"name\": \"Xingtai\", \"lat\": 37.0659, \"lon\": 114.4753, \"population\": 7104103},      {\"name\": \"Xi\u2019an\", \"lat\": 34.2667, \"lon\": 108.9, \"population\": 7090000},      {\"name\": \"Santiago\", \"lat\": -33.45, \"lon\": -70.6667, \"population\": 7026000},      {\"name\": \"Yantai\", \"lat\": 37.3997, \"lon\": 121.2664, \"population\": 6968202},      {\"name\": \"Riyadh\", \"lat\": 24.65, \"lon\": 46.71, \"population\": 6889000},      {\"name\": \"Luoyang\", \"lat\": 34.6587, \"lon\": 112.4245, \"population\": 6888500},      {\"name\": \"Kunming\", \"lat\": 25.0433, \"lon\": 102.7061, \"population\": 6850000},      {\"name\": \"Shangrao\", \"lat\": 28.4419, \"lon\": 117.9633, \"population\": 6810700},      {\"name\": \"Hangzhou\", \"lat\": 30.25, \"lon\": 120.1675, \"population\": 6713000},      {\"name\": \"Bijie\", \"lat\": 27.3019, \"lon\": 105.2863, \"population\": 6686100},      {\"name\": \"Quanzhou\", \"lat\": 24.9139, \"lon\": 118.5858, \"population\": 6480000},      {\"name\": \"Miami\", \"lat\": 25.7839, \"lon\": -80.2102, \"population\": 6445545},      {\"name\": \"Wuxi\", \"lat\": 31.5667, \"lon\": 120.2833, \"population\": 6372624},      {\"name\": \"Huanggang\", \"lat\": 30.45, \"lon\": 114.875, \"population\": 6333000},      {\"name\": \"Maoming\", \"lat\": 21.6618, \"lon\": 110.9178, \"population\": 6313200},      {\"name\": \"Nanchong\", \"lat\": 30.7991, \"lon\": 106.0784, \"population\": 6278614},      {\"name\": \"Zunyi\", \"lat\": 27.705, \"lon\": 106.9336, \"population\": 6270700},      {\"name\": \"Qujing\", \"lat\": 25.5102, \"lon\": 103.8029, \"population\": 6155400},      {\"name\": \"Baghdad\", \"lat\": 33.35, \"lon\": 44.4167, \"population\": 6107000},      {\"name\": \"Xinyang\", \"lat\": 32.1264, \"lon\": 114.0672, \"population\": 6109106},  ]    # Convert to Pandas DataFrame  data = pandas.DataFrame(cities)    # Add a column holding the bubble size:  #   Min(population) -> size =  5  #   Max(population) -> size = 60  solve = numpy.linalg.solve([[data[\"population\"].min(), 1], [data[\"population\"].max(), 1]], [5, 60])  data[\"size\"] = data[\"population\"].apply(lambda p: p * solve[0] + solve[1])    # Add a column holding the bubble hover texts  # Format is \"<city name> [<population>]\"  data[\"text\"] = data.apply(lambda row: f\"{row['name']} [{row['population']}]\", axis=1)    marker = {      # Use the \"size\" column to set the bubble size      \"size\": \"size\"  }    layout = {\"geo\": {\"showland\": True, \"landcolor\": \"4A4\"}}    page = \"\"\"  # Maps - Bubbles    <|{data}|chart|type=scattergeo|lat=lat|lon=lon|mode=markers|marker={marker}|text=text|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>  # -----------------------------------------------------------------------------------------  # 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>  # -----------------------------------------------------------------------------------------  import numpy  import pandas    from taipy.gui import Gui    dates = pandas.date_range(\"2023-01-01\", periods=365, freq=\"D\")  temp = [      -11.33333333,      -6,      -0.111111111,      1.444444444,      2.388888889,      4.555555556,      4.333333333,      0.666666667,      9,      9.611111111,      -0.555555556,      1.833333333,      -0.444444444,      2.166666667,      -4,      -12.05555556,      -2.722222222,      5,      9.888888889,      6.611111111,      -2.833333333,      -3.277777778,      -1.611111111,      -1.388888889,      5.777777778,      2.166666667,      -1.055555556,      1.777777778,      1.5,      8.444444444,      6.222222222,      -2.5,      -0.388888889,      6.111111111,      -1.5,      2.666666667,      -2.5,      0.611111111,      8.222222222,      2.333333333,      -9.333333333,      -7.666666667,      -6.277777778,      -0.611111111,      7.722222222,      6.111111111,      -4,      3.388888889,      9.333333333,      -6.333333333,      -15,      -12.94444444,      -8.722222222,      -6.222222222,      -2.833333333,      -2.5,      1.5,      3.444444444,      2.666666667,      0.888888889,      7.555555556,      12.66666667,      12.83333333,      1.777777778,      -0.111111111,      -1.055555556,      4.611111111,      11.16666667,      8.5,      0.5,      2.111111111,      4.722222222,      8.277777778,      10.66666667,      5.833333333,      5.555555556,      6.944444444,      1.722222222,      2.444444444,      6.111111111,      12.11111111,      15.55555556,      9.944444444,      10.27777778,      5.888888889,      1.388888889,      3.555555556,      1.222222222,      4.055555556,      7.833333333,      0.666666667,      10.05555556,      6.444444444,      4.555555556,      11,      3.555555556,      -0.555555556,      11.83333333,      7.222222222,      10.16666667,      17.5,      14.55555556,      6.777777778,      3.611111111,      5.888888889,      10.05555556,      16.61111111,      5.5,      7.055555556,      10.5,      1.555555556,      6.166666667,      11.05555556,      5.111111111,      6.055555556,      11,      11.05555556,      14.72222222,      19.16666667,      16.5,      12.61111111,      8.277777778,      6.611111111,      10.38888889,      15.38888889,      17.22222222,      18.27777778,      18.72222222,      17.05555556,      19.72222222,      16.83333333,      12.66666667,      11.66666667,      12.88888889,      14.77777778,      18,      19.44444444,      16.5,      9.722222222,      7.888888889,      13.72222222,      17.55555556,      18.27777778,      20.11111111,      21.66666667,      23.38888889,      23.5,      16.94444444,      16.27777778,      18.61111111,      20.83333333,      24.61111111,      18.27777778,      17.88888889,      22.27777778,      25.94444444,      25.27777778,      24.72222222,      25.61111111,      23.94444444,      26.33333333,      22.05555556,      20.83333333,      24.5,      27.83333333,      25.61111111,      23.11111111,      19.27777778,      16.44444444,      19.44444444,      17.22222222,      19.44444444,      22.16666667,      21.77777778,      17.38888889,      17.22222222,      23.88888889,      28.44444444,      29.44444444,      29.61111111,      21.05555556,      18.55555556,      25.27777778,      26.55555556,      24.55555556,      23.38888889,      22.55555556,      27.05555556,      27.66666667,      26.66666667,      27.61111111,      26.66666667,      24.77777778,      23,      26.5,      23.11111111,      19.83333333,      22.27777778,      24.61111111,      27.05555556,      27.05555556,      27.94444444,      27.33333333,      22.05555556,      21.5,      22,      19.72222222,      20.27777778,      17.88888889,      18.55555556,      18.94444444,      20,      22.05555556,      23.22222222,      24.38888889,      24.5,      24.5,      21.22222222,      20.83333333,      20.61111111,      22.05555556,      23.77777778,      24.16666667,      24.22222222,      21.83333333,      21.33333333,      21.88888889,      22.44444444,      23.11111111,      20.44444444,      16.88888889,      15.77777778,      17.44444444,      17.72222222,      23.11111111,      24.55555556,      24.88888889,      25.11111111,      25.27777778,      19.5,      19.55555556,      24.05555556,      24.27777778,      21.05555556,      19.88888889,      20.66666667,      20.27777778,      17.66666667,      16.44444444,      15.88888889,      18.44444444,      22.44444444,      23,      24.72222222,      24.16666667,      25.94444444,      24.44444444,      23.33333333,      25.22222222,      25,      23.88888889,      23.72222222,      18.94444444,      16.22222222,      19.5,      21.22222222,      19.72222222,      13.22222222,      11.88888889,      16.55555556,      10.05555556,      12.16666667,      11.5,      10.22222222,      17.27777778,      21.72222222,      13.83333333,      13,      6.944444444,      6.388888889,      4.222222222,      2.5,      1.111111111,      3.055555556,      6.388888889,      10.44444444,      -2,      -2.222222222,      4.388888889,      8.333333333,      11.11111111,      12.66666667,      10.88888889,      12.83333333,      14.16666667,      12.55555556,      12.05555556,      11.22222222,      12.44444444,      14.38888889,      12,      15.83333333,      6.722222222,      2.5,      4.833333333,      7.5,      8.888888889,      4,      7.388888889,      3.888888889,      1.611111111,      -0.333333333,      -2,      4.833333333,      -1.055555556,      -5.611111111,      -2.388888889,      5.722222222,      8.444444444,      5.277777778,      0.5,      -2.5,      1.111111111,      2.111111111,      5.777777778,      7.555555556,      7.555555556,      4.111111111,      -0.388888889,      -1,      4.944444444,      9.444444444,      4.722222222,      -0.166666667,      0.5,      -2.444444444,      -2.722222222,      -2.888888889,      -1.111111111,      -4.944444444,      -3.111111111,      -1.444444444,      -0.833333333,      2.333333333,      6.833333333,      4.722222222,      0.888888889,      0.666666667,      4.611111111,      4.666666667,      4.444444444,      6.777777778,      5.833333333,      0.5,      4.888888889,      1.444444444,      -2.111111111,      2.444444444,      -0.111111111,      -2.555555556,      -4.611111111,      -8.666666667,      -8.055555556,      1.555555556,      -4.777777778,  ]  min = [      -14.33333333,      -12.9,      -3.311111111,      -4.955555556,      -3.611111111,      0.555555556,      1.133333333,      -5.133333333,      2.3,      3.911111111,      -7.055555556,      -1.366666667,      -4.844444444,      -3.333333333,      -6.1,      -17.15555556,      -4.822222222,      0.4,      3.488888889,      4.211111111,      -6.433333333,      -7.577777778,      -7.111111111,      -7.088888889,      1.577777778,      -3.433333333,      -4.355555556,      -0.722222222,      -2.1,      2.044444444,      2.222222222,      -4.7,      -2.388888889,      4.111111111,      -5,      -0.133333333,      -5.3,      -2.288888889,      6.022222222,      -1.766666667,      -15.53333333,      -13.46666667,      -9.277777778,      -3.211111111,      3.122222222,      1.411111111,      -6.8,      1.388888889,      5.333333333,      -9.833333333,      -22,      -19.74444444,      -14.62222222,      -9.622222222,      -8.433333333,      -8.5,      -2.8,      0.144444444,      -3.233333333,      -3.411111111,      5.355555556,      8.366666667,      7.333333333,      -0.322222222,      -6.911111111,      -4.955555556,      -1.588888889,      4.966666667,      2.5,      -4.3,      -1.888888889,      -1.777777778,      2.477777778,      3.766666667,      0.533333333,      1.755555556,      2.944444444,      -4.977777778,      -4.055555556,      1.711111111,      6.011111111,      13.15555556,      5.044444444,      6.577777778,      3.388888889,      -1.011111111,      -0.244444444,      -2.477777778,      -1.444444444,      2.533333333,      -6.333333333,      4.255555556,      1.944444444,      0.855555556,      5.4,      -1.244444444,      -2.855555556,      4.833333333,      2.722222222,      6.466666667,      14.5,      9.855555556,      2.277777778,      -3.188888889,      0.788888889,      4.155555556,      13.41111111,      2.3,      0.855555556,      8.4,      -0.444444444,      1.166666667,      7.755555556,      -0.288888889,      -0.244444444,      8.7,      5.555555556,      8.222222222,      16.26666667,      14.4,      5.711111111,      5.177777778,      4.511111111,      5.988888889,      10.08888889,      10.52222222,      15.37777778,      12.42222222,      14.95555556,      15.22222222,      11.93333333,      6.866666667,      6.866666667,      9.688888889,      11.57777778,      12,      13.34444444,      11.3,      6.222222222,      2.088888889,      8.322222222,      14.05555556,      13.77777778,      16.91111111,      16.86666667,      16.68888889,      18.5,      12.54444444,      12.27777778,      15.91111111,      15.03333333,      22.11111111,      15.77777778,      13.68888889,      17.87777778,      19.94444444,      18.57777778,      18.62222222,      20.11111111,      17.14444444,      20.43333333,      15.75555556,      17.33333333,      20,      23.03333333,      19.61111111,      18.51111111,      15.27777778,      11.44444444,      13.64444444,      11.42222222,      16.14444444,      19.76666667,      18.77777778,      11.88888889,      12.32222222,      20.78888889,      25.04444444,      25.34444444,      23.81111111,      18.35555556,      11.85555556,      18.37777778,      23.15555556,      21.55555556,      17.48888889,      19.05555556,      20.25555556,      23.86666667,      23.86666667,      21.41111111,      21.16666667,      18.67777778,      18.1,      24.4,      19.01111111,      17.13333333,      18.27777778,      21.71111111,      22.85555556,      22.65555556,      25.14444444,      24.13333333,      17.95555556,      14.7,      15.1,      16.02222222,      14.27777778,      11.18888889,      13.65555556,      16.74444444,      16.7,      17.65555556,      16.62222222,      21.68888889,      19.6,      18.6,      15.52222222,      18.53333333,      17.01111111,      17.75555556,      20.47777778,      17.76666667,      22.22222222,      18.23333333,      17.83333333,      15.38888889,      19.64444444,      17.81111111,      15.44444444,      14.88888889,      13.07777778,      15.24444444,      11.82222222,      20.81111111,      21.45555556,      18.98888889,      19.71111111,      19.27777778,      12.7,      15.05555556,      19.15555556,      20.77777778,      15.35555556,      17.68888889,      18.26666667,      15.47777778,      12.76666667,      10.54444444,      13.38888889,      12.54444444,      19.84444444,      19.5,      21.92222222,      17.86666667,      22.44444444,      19.64444444,      20.73333333,      22.02222222,      19,      20.48888889,      19.02222222,      16.44444444,      14.22222222,      16.3,      16.42222222,      17.22222222,      8.322222222,      8.288888889,      13.95555556,      5.555555556,      5.666666667,      7.7,      4.022222222,      11.77777778,      16.42222222,      11.83333333,      9.7,      0.044444444,      3.688888889,      -2.077777778,      0.1,      -5.388888889,      -3.244444444,      0.688888889,      5.744444444,      -7.7,      -7.022222222,      -0.211111111,      4.833333333,      8.111111111,      5.766666667,      7.888888889,      10.43333333,      11.56666667,      10.15555556,      7.155555556,      4.522222222,      7.144444444,      10.88888889,      9.5,      12.13333333,      4.022222222,      -3.9,      1.433333333,      0.7,      3.188888889,      -1.7,      3.588888889,      -0.111111111,      -2.788888889,      -7.133333333,      -5,      0.733333333,      -7.555555556,      -12.51111111,      -8.188888889,      3.122222222,      2.944444444,      0.477777778,      -3.2,      -9.2,      -4.788888889,      -0.288888889,      1.077777778,      4.755555556,      5.455555556,      0.511111111,      -3.888888889,      -7.4,      -1.355555556,      5.144444444,      0.122222222,      -5.166666667,      -5,      -5.144444444,      -8.822222222,      -6.388888889,      -6.811111111,      -8.944444444,      -10.11111111,      -7.144444444,      -5.133333333,      -1.166666667,      1.833333333,      -1.477777778,      -1.811111111,      -2.433333333,      -1.188888889,      -2.333333333,      0.744444444,      1.877777778,      1.333333333,      -1.7,      0.888888889,      -3.855555556,      -8.211111111,      -1.055555556,      -4.211111111,      -7.355555556,      -8.111111111,      -10.96666667,      -13.05555556,      -4.644444444,      -7.577777778,  ]  max = [      -7.233333333,      -1.6,      5.488888889,      7.744444444,      6.188888889,      6.555555556,      10.53333333,      6.766666667,      14.1,      14.11111111,      2.044444444,      4.633333333,      2.055555556,      8.666666667,      -1.4,      -5.555555556,      4.177777778,      11.8,      15.58888889,      12.31111111,      3.666666667,      -0.977777778,      1.288888889,      4.211111111,      9.377777778,      5.266666667,      2.144444444,      3.977777778,      7.2,      11.94444444,      11.32222222,      4,      6.611111111,      8.211111111,      3.5,      8.866666667,      3.6,      3.711111111,      13.12222222,      7.833333333,      -3.333333333,      -2.166666667,      -2.877777778,      5.188888889,      13.12222222,      12.11111111,      -0.7,      6.688888889,      14.03333333,      -2.433333333,      -8.6,      -8.244444444,      -2.122222222,      -2.722222222,      1.266666667,      2.8,      5.7,      6.944444444,      5.066666667,      5.688888889,      13.35555556,      16.66666667,      17.33333333,      7.277777778,      6.388888889,      1.344444444,      9.111111111,      17.96666667,      12.8,      5.8,      6.911111111,      6.822222222,      11.87777778,      13.16666667,      9.233333333,      8.655555556,      10.04444444,      7.022222222,      7.644444444,      8.311111111,      16.71111111,      18.85555556,      12.14444444,      13.27777778,      11.18888889,      7.088888889,      8.255555556,      7.522222222,      9.955555556,      9.933333333,      4.866666667,      15.25555556,      9.244444444,      9.755555556,      14,      8.955555556,      2.344444444,      17.43333333,      12.12222222,      13.46666667,      23,      18.45555556,      12.77777778,      7.211111111,      8.588888889,      14.35555556,      19.01111111,      12.4,      9.155555556,      15.6,      4.955555556,      8.966666667,      16.95555556,      9.511111111,      10.15555556,      16,      14.45555556,      21.02222222,      25.76666667,      20.5,      15.71111111,      11.67777778,      12.81111111,      12.88888889,      17.58888889,      23.12222222,      21.77777778,      24.42222222,      20.05555556,      24.32222222,      18.83333333,      19.56666667,      14.96666667,      19.68888889,      18.57777778,      23,      23.34444444,      20.7,      11.82222222,      11.48888889,      17.52222222,      22.55555556,      20.47777778,      23.01111111,      27.86666667,      30.28888889,      30.3,      22.94444444,      18.57777778,      25.51111111,      24.13333333,      30.01111111,      24.77777778,      20.28888889,      28.67777778,      32.74444444,      31.37777778,      28.52222222,      31.81111111,      27.24444444,      32.53333333,      26.15555556,      24.63333333,      28.3,      31.23333333,      32.21111111,      28.21111111,      23.07777778,      21.64444444,      24.34444444,      19.62222222,      25.14444444,      24.46666667,      23.87777778,      21.28888889,      20.22222222,      29.98888889,      32.04444444,      36.44444444,      36.01111111,      24.85555556,      23.45555556,      29.17777778,      32.25555556,      28.75555556,      30.28888889,      28.85555556,      30.45555556,      31.26666667,      28.86666667,      33.31111111,      30.66666667,      28.67777778,      27.4,      32.2,      25.41111111,      22.23333333,      26.67777778,      30.21111111,      29.15555556,      29.65555556,      31.94444444,      31.43333333,      28.35555556,      24.8,      25.5,      25.42222222,      24.17777778,      20.88888889,      24.35555556,      25.54444444,      22,      27.95555556,      29.42222222,      28.88888889,      26.8,      28.2,      26.92222222,      24.13333333,      22.61111111,      26.15555556,      30.57777778,      30.86666667,      29.92222222,      27.33333333,      23.43333333,      24.68888889,      26.94444444,      28.81111111,      25.54444444,      22.48888889,      21.67777778,      19.74444444,      23.82222222,      25.91111111,      30.85555556,      28.48888889,      29.21111111,      28.37777778,      22.4,      25.55555556,      27.35555556,      30.67777778,      27.95555556,      25.98888889,      23.46666667,      25.37777778,      20.46666667,      22.54444444,      20.18888889,      22.24444444,      26.84444444,      25.8,      29.62222222,      26.36666667,      32.24444444,      29.84444444,      28.33333333,      31.22222222,      29.9,      29.98888889,      27.42222222,      25.54444444,      20.22222222,      24,      24.52222222,      25.02222222,      16.12222222,      17.58888889,      23.25555556,      15.75555556,      18.66666667,      18.4,      12.52222222,      20.07777778,      28.62222222,      17.23333333,      16.6,      13.34444444,      10.98888889,      9.522222222,      5.8,      6.811111111,      6.555555556,      12.18888889,      12.64444444,      4.2,      3.577777778,      8.888888889,      15.23333333,      16.11111111,      18.36666667,      16.98888889,      15.63333333,      16.46666667,      15.55555556,      15.65555556,      17.42222222,      18.74444444,      19.48888889,      15.9,      19.73333333,      13.02222222,      8.1,      8.933333333,      11.3,      12.38888889,      8.3,      12.38888889,      6.388888889,      4.211111111,      4.666666667,      0.7,      7.133333333,      2.344444444,      1.088888889,      0.111111111,      11.62222222,      10.84444444,      8.777777778,      3.5,      3.4,      7.211111111,      5.711111111,      9.677777778,      12.25555556,      10.15555556,      6.511111111,      4.911111111,      1.5,      11.44444444,      15.54444444,      8.122222222,      6.233333333,      7,      4.355555556,      0.277777778,      3.711111111,      2.888888889,      1.555555556,      3.888888889,      4.555555556,      5.666666667,      7.833333333,      9.833333333,      10.02222222,      6.288888889,      5.366666667,      11.41111111,      9.566666667,      9.744444444,      13.57777778,      9.433333333,      3.1,      11.08888889,      3.844444444,      2.488888889,      7.544444444,      4.488888889,      -0.455555556,      -2.111111111,      -3.566666667,      -1.955555556,      3.955555556,      1.222222222,  ]  week_number = [f\"W{i//7}\" if i % 7 == 0 else None for i in range(0, 365)]    start = 50  size = 100  data = {      \"Date\": dates[start:size],      \"Temp\u00b0C\": temp[start:size],      \"Week\": numpy.array(max[start:size]) + 5,      \"WeekN\": week_number[start:size],  }    page = \"\"\"  # Line - Texts    <|{data}|chart|x=Date|y[1]=Temp\u00b0C|y[2]=Week|mode[2]=text|text[2]=WeekN|>  \"\"\"    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 __future__ import annotations    import contextlib  import logging  import os  import pathlib  import re  import sys  import time  import typing as t  import webbrowser  from importlib import util  from random import randint    import __main__  from flask import Blueprint, Flask, json, jsonify, render_template, send_from_directory  from flask_cors import CORS  from flask_socketio import SocketIO  from gitignore_parser import parse_gitignore  from kthread import KThread  from werkzeug.serving import is_running_from_reloader    from taipy.logger._taipy_logger import _TaipyLogger    from ._renderers.json import _TaipyJsonProvider  from .config import ServerConfig  from .utils import _is_in_notebook, _is_port_open, _RuntimeManager    if t.TYPE_CHECKING:      from .gui import Gui      class _Server:      __RE_OPENING_CURLY = re.compile(r\"([^\\\"])(\\{)\")      __RE_CLOSING_CURLY = re.compile(r\"(\\})([^\\\"])\")      __OPENING_CURLY = r\"\\1&#x7B;\"      __CLOSING_CURLY = r\"&#x7D;\\2\"        def __init__(          self,          gui: Gui,          flask: t.Optional[Flask] = None,          path_mapping: t.Optional[dict] = None,          async_mode: t.Optional[str] = None,          allow_upgrades: bool = True,          server_config: t.Optional[ServerConfig] = None,      ):          self._gui = gui          server_config = server_config or {}          self._flask = flask          if self._flask is None:              flask_config: t.Dict[str, t.Any] = {\"import_name\": \"Taipy\"}              if \"flask\" in server_config and isinstance(server_config[\"flask\"], dict):                  flask_config.update(server_config[\"flask\"])              self._flask = Flask(**flask_config)          if \"SECRET_KEY\" not in self._flask.config or not self._flask.config[\"SECRET_KEY\"]:              self._flask.config[\"SECRET_KEY\"] = \"TaIpY\"            # setup cors          if \"cors\" not in server_config or (              \"cors\" in server_config and (isinstance(server_config[\"cors\"], dict) or server_config[\"cors\"] is True)          ):              cors_config = (                  server_config[\"cors\"] if \"cors\" in server_config and isinstance(server_config[\"cors\"], dict) else {}              )              CORS(self._flask, **cors_config)            # setup socketio          socketio_config: t.Dict[str, t.Any] = {              \"cors_allowed_origins\": \"*\",              \"ping_timeout\": 10,              \"ping_interval\": 5,              \"json\": json,              \"async_mode\": async_mode,              \"allow_upgrades\": allow_upgrades,          }          if \"socketio\" in server_config and isinstance(server_config[\"socketio\"], dict):              socketio_config.update(server_config[\"socketio\"])          self._ws = SocketIO(self._flask, **socketio_config)            self._apply_patch()            # set json encoder (for Taipy specific types)          self._flask.json_provider_class = _TaipyJsonProvider          self._flask.json = self._flask.json_provider_class(self._flask)  # type: ignore            self.__path_mapping = path_mapping or {}          self.__ssl_context = server_config.get(\"ssl_context\", None)          self._is_running = False            # Websocket (handle json message)          # adding args for the one call with a server ack request          @self._ws.on(\"message\")          def handle_message(message, *args) -> None:              if \"status\" in message:                  _TaipyLogger._get_logger().info(message[\"status\"])              elif \"type\" in message:                  gui._manage_message(message[\"type\"], message)        def __is_ignored(self, file_path: str) -> bool:          if not hasattr(self, \"_ignore_matches\"):              __IGNORE_FILE = \".taipyignore\"              ignore_file = (                  (pathlib.Path(__main__.__file__).parent / __IGNORE_FILE) if hasattr(__main__, \"__file__\") else None              )              if not ignore_file or not ignore_file.is_file():                  ignore_file = pathlib.Path(self._gui._root_dir) / __IGNORE_FILE              self._ignore_matches = (                  parse_gitignore(ignore_file) if ignore_file.is_file() and os.access(ignore_file, os.R_OK) else None              )            if callable(self._ignore_matches):              return self._ignore_matches(file_path)          return False        def _get_default_blueprint(          self,          static_folder: str,          template_folder: str,          title: str,          favicon: str,          root_margin: str,          scripts: t.List[str],          styles: t.List[str],          version: str,          client_config: t.Dict[str, t.Any],          watermark: t.Optional[str],          css_vars: str,          base_url: str,      ) -> Blueprint:          taipy_bp = Blueprint(\"Taipy\", __name__, static_folder=static_folder, template_folder=template_folder)          # Serve static react build            @taipy_bp.route(\"/\", defaults={\"path\": \"\"})          @taipy_bp.route(\"/<path:path>\")          def my_index(path):              if path == \"\" or path == \"index.html\" or \".\" not in path:                  try:                      return render_template(                          \"index.html\",                          title=title,                          favicon=favicon,                          root_margin=root_margin,                          watermark=watermark,                          config=client_config,                          scripts=scripts,                          styles=styles,                          version=version,                          css_vars=css_vars,                          base_url=base_url,                      )                  except Exception:  # pragma: no cover                      raise RuntimeError(                          \"Something is wrong with the taipy-gui front-end installation. Check that the js bundle has been properly built (is Node.js installed?).\"                      )                if path == \"taipy.status.json\":                  return self._direct_render_json(self._gui._serve_status(pathlib.Path(template_folder) / path))              if str(os.path.normpath(file_path := ((base_path := static_folder + os.path.sep) + path))).startswith(                  base_path              ) and os.path.isfile(file_path):                  return send_from_directory(base_path, path)              # use the path mapping to detect and find resources              for k, v in self.__path_mapping.items():                  if (                      path.startswith(f\"{k}/\")                      and str(                          os.path.normpath(file_path := ((base_path := v + os.path.sep) + path[len(k) + 1 :]))                      ).startswith(base_path)                      and os.path.isfile(file_path)                  ):                      return send_from_directory(base_path, path[len(k) + 1 :])              if (                  hasattr(__main__, \"__file__\")                  and str(                      os.path.normpath(                          file_path := ((base_path := os.path.dirname(__main__.__file__) + os.path.sep) + path)                      )                  ).startswith(base_path)                  and os.path.isfile(file_path)                  and not self.__is_ignored(file_path)              ):                  return send_from_directory(base_path, path)              if (                  str(os.path.normpath(file_path := (base_path := self._gui._root_dir + os.path.sep) + path)).startswith(                      base_path                  )                  and os.path.isfile(file_path)                  and not self.__is_ignored(file_path)              ):                  return send_from_directory(base_path, path)              return (\"\", 404)            return taipy_bp        # Update to render as JSX      def _render(self, html_fragment, style, head, context):          template_str = _Server.__RE_OPENING_CURLY.sub(_Server.__OPENING_CURLY, html_fragment)          template_str = _Server.__RE_CLOSING_CURLY.sub(_Server.__CLOSING_CURLY, template_str)          template_str = template_str.replace('\"{!', \"{\")          template_str = template_str.replace('!}\"', \"}\")          return self._direct_render_json(              {                  \"jsx\": template_str,                  \"style\": (style + os.linesep) if style else \"\",                  \"head\": head or [],                  \"context\": context or self._gui._get_default_module_name(),              }          )        def _direct_render_json(self, data):          return jsonify(data)        def get_flask(self):          return self._flask        def test_client(self):          return self._flask.test_client()        def _run_notebook(self):          self._is_running = True          self._ws.run(self._flask, host=self._host, port=self._port, debug=False, use_reloader=False)        def _get_async_mode(self) -> str:          return self._ws.async_mode        def _apply_patch(self):          if self._get_async_mode() == \"gevent\" and util.find_spec(\"gevent\"):              from gevent import monkey                if not monkey.is_module_patched(\"time\"):                  monkey.patch_time()          if self._get_async_mode() == \"eventlet\" and util.find_spec(\"eventlet\"):              from eventlet import monkey_patch, patcher                if not patcher.is_monkey_patched(\"time\"):                  monkey_patch(time=True)        def _get_random_port(self):  # pragma: no cover          while True:              port = randint(49152, 65535)              if port not in _RuntimeManager().get_used_port() and not _is_port_open(self._host, port):                  return port        def run(self, host, port, debug, use_reloader, flask_log, run_in_thread, allow_unsafe_werkzeug, notebook_proxy):          host_value = host if host != \"0.0.0.0\" else \"localhost\"          self._host = host          self._port = port          if _is_in_notebook() and notebook_proxy:  # pragma: no cover              from .utils.proxy import NotebookProxy                # Start proxy if not already started              self._proxy = NotebookProxy(gui=self._gui, listening_port=port)              self._proxy.run()              self._port = self._get_random_port()          if _is_in_notebook() or run_in_thread:              runtime_manager = _RuntimeManager()              runtime_manager.add_gui(self._gui, port)          if debug and not is_running_from_reloader() and _is_port_open(host_value, port):              raise ConnectionError(                  f\"Port {port} is already opened on {host_value}. You have another server application running on the same port.\"              )          if not flask_log:              log = logging.getLogger(\"werkzeug\")              log.disabled = True              if not is_running_from_reloader():                  _TaipyLogger._get_logger().info(f\" * Server starting on http://{host_value}:{port}\")              else:                  _TaipyLogger._get_logger().info(f\" * Server reloaded on http://{host_value}:{port}\")          if not is_running_from_reloader() and self._gui._get_config(\"run_browser\", False):              webbrowser.open(f\"http://{host_value}{f':{port}' if port else ''}\", new=2)          if _is_in_notebook() or run_in_thread:              self._thread = KThread(target=self._run_notebook)              self._thread.start()              return          self._is_running = True          run_config = {              \"app\": self._flask,              \"host\": host,              \"port\": port,              \"debug\": debug,              \"use_reloader\": use_reloader,          }          if self.__ssl_context is not None:              run_config[\"ssl_context\"] = self.__ssl_context          # flask-socketio specific conditions for 'allow_unsafe_werkzeug' parameters to be popped out of kwargs          if self._get_async_mode() == \"threading\" and (not sys.stdin or not sys.stdin.isatty()):              run_config = {**run_config, \"allow_unsafe_werkzeug\": allow_unsafe_werkzeug}          self._ws.run(**run_config)        def stop_thread(self):          if hasattr(self, \"_thread\") and self._thread.is_alive() and self._is_running:              self._is_running = False              with contextlib.suppress(Exception):                  if self._get_async_mode() == \"gevent\":                      if self._ws.wsgi_server is not None:                          self._ws.wsgi_server.stop()                      else:                          self._thread.kill()                  else:                      self._thread.kill()              while _is_port_open(self._host, self._port):                  time.sleep(0.1)        def stop_proxy(self):          if hasattr(self, \"_proxy\"):              self._proxy.stop() "}
{"text": "import os  import re  import typing as t  from importlib.util import find_spec    import pytz  import tzlocal  from dotenv import dotenv_values  from werkzeug.serving import is_running_from_reloader    from taipy.logger._taipy_logger import _TaipyLogger    from ._gui_cli import _GuiCLI  from ._page import _Page  from ._warnings import _warn  from .partial import Partial  from .utils import _is_in_notebook    ConfigParameter = t.Literal[      \"allow_unsafe_werkzeug\",      \"async_mode\",      \"change_delay\",      \"chart_dark_template\",      \"base_url\",      \"dark_mode\",      \"dark_theme\",      \"data_url_max_size\",      \"debug\",      \"extended_status\",      \"favicon\",      \"flask_log\",      \"host\",      \"light_theme\",      \"margin\",      \"ngrok_token\",      \"notebook_proxy\",      \"notification_duration\",      \"propagate\",      \"run_browser\",      \"run_in_thread\",      \"run_server\",      \"server_config\",      \"single_client\",      \"system_notification\",      \"theme\",      \"time_zone\",      \"title\",      \"stylekit\",      \"upload_folder\",      \"use_arrow\",      \"use_reloader\",      \"watermark\",      \"webapp_path\",      \"port\",  ]    Stylekit = t.TypedDict(      \"Stylekit\",      {          \"color_primary\": str,          \"color_secondary\": str,          \"color_error\": str,          \"color_warning\": str,          \"color_success\": str,          \"color_background_light\": str,          \"color_paper_light\": str,          \"color_background_dark\": str,          \"color_paper_dark\": str,          \"font_family\": str,          \"root_margin\": str,          \"border_radius\": int,          \"input_button_height\": str,      },      total=False,  )    ServerConfig = t.TypedDict(      \"ServerConfig\",      {          \"cors\": t.Optional[t.Union[bool, t.Dict[str, t.Any]]],          \"socketio\": t.Optional[t.Dict[str, t.Any]],          \"ssl_context\": t.Optional[t.Union[str, t.Tuple[str, str]]],          \"flask\": t.Optional[t.Dict[str, t.Any]],      },      total=False,  )    Config = t.TypedDict(      \"Config\",      {          \"allow_unsafe_werkzeug\": bool,          \"async_mode\": str,          \"change_delay\": t.Optional[int],          \"chart_dark_template\": t.Optional[t.Dict[str, t.Any]],          \"base_url\": t.Optional[str],          \"dark_mode\": bool,          \"dark_theme\": t.Optional[t.Dict[str, t.Any]],          \"data_url_max_size\": t.Optional[int],          \"debug\": bool,          \"extended_status\": bool,          \"favicon\": t.Optional[str],          \"flask_log\": bool,          \"host\": str,          \"light_theme\": t.Optional[t.Dict[str, t.Any]],          \"margin\": t.Optional[str],          \"ngrok_token\": str,          \"notebook_proxy\": bool,          \"notification_duration\": int,          \"propagate\": bool,          \"run_browser\": bool,          \"run_in_thread\": bool,          \"run_server\": bool,          \"server_config\": t.Optional[ServerConfig],          \"single_client\": bool,          \"system_notification\": bool,          \"theme\": t.Optional[t.Dict[str, t.Any]],          \"time_zone\": t.Optional[str],          \"title\": t.Optional[str],          \"stylekit\": t.Union[bool, Stylekit],          \"upload_folder\": t.Optional[str],          \"use_arrow\": bool,          \"use_reloader\": bool,          \"watermark\": t.Optional[str],          \"webapp_path\": t.Optional[str],          \"port\": int,      },      total=False,  )      class _Config(object):      __RE_PORT_NUMBER = re.compile(          r\"^([0-9]{1,4}|[1-5][0-9]{4}|6[0-4][0-9]{3}|65[0-4][0-9]{2}|655[0-2][0-9]|6553[0-5])$\"      )        def __init__(self):          self.pages: t.List[_Page] = []          self.root_page: t.Optional[_Page] = None          self.routes: t.List[str] = []          self.partials: t.List[Partial] = []          self.partial_routes: t.List[str] = []          self.config: Config = {}        def _load(self, config: Config) -> None:          self.config.update(config)          # Check that the user timezone configuration setting is valid          self.get_time_zone()        def _get_config(self, name: ConfigParameter, default_value: t.Any) -> t.Any:  # pragma: no cover          if name in self.config and self.config[name] is not None:              if default_value is not None and not isinstance(self.config[name], type(default_value)):                  try:                      return type(default_value)(self.config[name])                  except Exception as e:                      _warn(f'app_config \"{name}\" value \"{self.config[name]}\" is not of type {type(default_value)}', e)                      return default_value              return self.config[name]          return default_value        def get_time_zone(self) -> t.Optional[str]:          tz = self.config.get(\"time_zone\")          if tz is None or tz == \"client\":              return tz          if tz == \"server\":              # return python tzlocal IANA Time Zone              return str(tzlocal.get_localzone())          # Verify user defined IANA Time Zone is valid          if tz not in pytz.all_timezones_set:              raise Exception(                  \"Time Zone configuration is not valid. Mistyped 'server', 'client' options or invalid IANA Time Zone\"              )          # return user defined IANA Time Zone (https://en.wikipedia.org/wiki/List_of_tz_database_time_zones)          return tz        def _handle_argparse(self):          _GuiCLI.create_parser()          args = _GuiCLI.parse_arguments()            config = self.config          if args.taipy_port:              if not _Config.__RE_PORT_NUMBER.match(args.taipy_port):                  _warn(\"Port value for --port option is not valid.\")              else:                  config[\"port\"] = int(args.taipy_port)          if args.taipy_host:              config[\"host\"] = args.taipy_host          if args.taipy_debug:              config[\"debug\"] = True          if args.taipy_no_debug:              config[\"debug\"] = False          if args.taipy_use_reloader:              config[\"use_reloader\"] = True          if args.taipy_no_reloader:              config[\"use_reloader\"] = False          if args.taipy_ngrok_token:              config[\"ngrok_token\"] = args.taipy_ngrok_token          if args.taipy_webapp_path:              config[\"webapp_path\"] = args.taipy_webapp_path          elif os.environ.get(\"TAIPY_GUI_WEBAPP_PATH\"):              config[\"webapp_path\"] = os.environ.get(\"TAIPY_GUI_WEBAPP_PATH\")        def _build_config(self, root_dir, env_filename, kwargs):  # pragma: no cover          config = self.config          env_file_abs_path = env_filename if os.path.isabs(env_filename) else os.path.join(root_dir, env_filename)          # Load keyword arguments          for key, value in kwargs.items():              key = key.lower()              if value is not None and key in config:                  # Special case for \"stylekit\" that can be a Boolean or a dict                  if key == \"stylekit\" and isinstance(value, bool):                      from ._default_config import _default_stylekit                        config[key] = _default_stylekit if value else {}                      continue                  try:                      if isinstance(value, dict) and isinstance(config[key], dict):                          config[key].update(value)                      else:                          config[key] = value if config[key] is None else type(config[key])(value)  # type: ignore                  except Exception as e:                      _warn(                          f\"Invalid keyword arguments value in Gui.run {key} - {value}. Unable to parse value to the correct type\",                          e,                      )          # Load config from env file          if os.path.isfile(env_file_abs_path):              for key, value in dotenv_values(env_file_abs_path).items():                  key = key.lower()                  if value is not None and key in config:                      try:                          config[key] = value if config[key] is None else type(config[key])(value)  # type: ignore                      except Exception as e:                          _warn(                              f\"Invalid env value in Gui.run(): {key} - {value}. Unable to parse value to the correct type\",                              e,                          )            # Taipy-config          if find_spec(\"taipy\") and find_spec(\"taipy.config\"):              from taipy.config import Config as TaipyConfig                try:                  section = TaipyConfig.unique_sections[\"gui\"]                  self.config.update(section._to_dict())              except KeyError:                  _warn(\"taipy-config section for taipy-gui is not initialized.\")            # Load from system arguments          self._handle_argparse()        def __log_outside_reloader(self, logger, msg):          if not is_running_from_reloader():              logger.info(msg)        def resolve(self):          app_config = self.config          logger = _TaipyLogger._get_logger()          # Special config for notebook runtime          if _is_in_notebook() or app_config[\"run_in_thread\"] and not app_config[\"single_client\"]:              app_config[\"single_client\"] = True              self.__log_outside_reloader(logger, \"Running in 'single_client' mode in notebook environment\")            if app_config[\"run_server\"] and app_config[\"ngrok_token\"] and app_config[\"use_reloader\"]:              app_config[\"use_reloader\"] = False              self.__log_outside_reloader(                  logger, \"'use_reloader' parameter will not be used when 'ngrok_token' parameter is available\"              )            if app_config[\"use_reloader\"] and _is_in_notebook():              app_config[\"use_reloader\"] = False              self.__log_outside_reloader(logger, \"'use_reloader' parameter is not available in notebook environment\")            if app_config[\"use_reloader\"] and not app_config[\"debug\"]:              app_config[\"debug\"] = True              self.__log_outside_reloader(logger, \"application is running in 'debug' mode\")            if app_config[\"debug\"] and not app_config[\"allow_unsafe_werkzeug\"]:              app_config[\"allow_unsafe_werkzeug\"] = True              self.__log_outside_reloader(logger, \"'allow_unsafe_werkzeug' has been set to True\")            if app_config[\"debug\"] and app_config[\"async_mode\"] != \"threading\":              app_config[\"async_mode\"] = \"threading\"              self.__log_outside_reloader(                  logger,                  \"'async_mode' parameter has been overridden to 'threading'. Using Flask built-in development server with debug mode\",              )            self._resolve_notebook_proxy()          self._resolve_stylekit()          self._resolve_url_prefix()        def _resolve_stylekit(self):          app_config = self.config          # support legacy margin variable          stylekit_config = app_config[\"stylekit\"]            if isinstance(app_config[\"stylekit\"], dict) and \"root_margin\" in app_config[\"stylekit\"]:              from ._default_config import _default_stylekit, default_config                stylekit_config = app_config[\"stylekit\"]              if (                  stylekit_config[\"root_margin\"] == _default_stylekit[\"root_margin\"]                  and app_config[\"margin\"] != default_config[\"margin\"]              ):                  app_config[\"stylekit\"][\"root_margin\"] = str(app_config[\"margin\"])              app_config[\"margin\"] = None        def _resolve_url_prefix(self):          app_config = self.config          base_url = app_config.get(\"base_url\")          if base_url is None:              app_config[\"base_url\"] = \"/\"          else:              base_url = f\"{'' if base_url.startswith('/') else '/'}{base_url}\"              base_url = f\"{base_url}{'' if base_url.endswith('/') else '/'}\"              app_config[\"base_url\"] = base_url        def _resolve_notebook_proxy(self):          app_config = self.config          app_config[\"notebook_proxy\"] = app_config[\"notebook_proxy\"] if _is_in_notebook() else False "}
{"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 threading  import typing as t    from ._warnings import _warn  from .gui import Gui  from .state import State      def download(      state: State, content: t.Any, name: t.Optional[str] = \"\", on_action: t.Optional[t.Union[str, t.Callable]] = \"\"  ):      \"\"\"Download content to the client.        Arguments:          state (State^): The current user state as received in any callback.          content: File path or file content. See below.          name: File name for the content on the client browser (defaults to content name).          on_action: Callback function (or callback name) to call when the download ends. See below.        ## Notes:        - *content*: this parameter can hold several values depending on your use case:          - a string: the value must be an existing path name to the file that gets downloaded or            the URL to the resource you want to download.          - a buffer (such as a `bytes` object): if the size of the buffer is smaller than             the [*data_url_max_size*](../gui/configuration.md#p-data_url_max_size) configuration             setting, then the [`python-magic`](https://pypi.org/project/python-magic/) package is             used to determine the [MIME type](https://en.wikipedia.org/wiki/Media_type) of the             buffer content, and the download is performed using a generated \"data:\" URL with             the relevant type, and a base64-encoded version of the buffer content.<br/>             If the buffer is too large, its content is transferred after saving it in a temporary             server file.        - *on_action*: this callback is triggered when the transfer of the content is achieved.</br>             In this function, you can perform any clean-up operation that could be required after             the download is completed.<br/>             This callback can use three optional parameters:             - *state*: the `State^` instance of the caller.             - *id* (optional): a string representing the identifier of the caller. If this function               is called directly, this will always be \"Gui.download\". Some controls may also trigger               download actions, and then *id* would reflect the identifier of those controls.             - *payload* (optional): an optional payload from the caller.<br/>               This is a dictionary with the following keys:                - *action*: the name of the callback;                - *args*: an array of two strings. The first element reflects the *name* parameter,                  and the second element reflects the server-side URL where the file is located.      \"\"\"      if state and isinstance(state._gui, Gui):          state._gui._download(content, name, on_action)      else:          _warn(\"'download()' must be called in the context of a callback.\")      def notify(      state: State,      notification_type: str = \"I\",      message: str = \"\",      system_notification: t.Optional[bool] = None,      duration: t.Optional[int] = None,  ):      \"\"\"Send a notification to the user interface.        Arguments:          state (State^): The current user state as received in any callback.          notification_type: The notification type. This can be one of \"success\", \"info\",              \"warning\", or \"error\".<br/>              To remove the last notification, set this parameter to the empty string.          message: The text message to display.          system_notification: If True, the system will also show the notification.<br/>              If not specified or set to None, this parameter will use the value of              *configuration[system_notification]*.          duration: The time, in milliseconds, during which the notification is shown.              If not specified or set to None, this parameter will use the value of              *configuration[notification_duration]*.        Note that you can also call this function with *notification_type* set to the first letter      or the alert type (i.e. setting *notification_type* to \"i\" is equivalent to setting it to      \"info\").        If *system_notification* is set to True, then the browser requests the system      to display a notification as well. They usually appear in small windows that      fly out of the system tray.<br/>      The first time your browser is requested to show such a system notification for      Taipy applications, you may be prompted to authorize the browser to do so. Please      refer to your browser documentation for details on how to allow or prevent this      feature.      \"\"\"      if state and isinstance(state._gui, Gui):          state._gui._notify(notification_type, message, system_notification, duration)      else:          _warn(\"'notify()' must be called in the context of a callback.\")      def hold_control(      state: State,      callback: t.Optional[t.Union[str, t.Callable]] = None,      message: t.Optional[str] = \"Work in Progress...\",  ):      \"\"\"Hold the User Interface actions.        When the User Interface is held, users cannot interact with visual elements.<br/>      The application must call `resume_control()^` so that users can interact again      with the visual elements.        You can set a callback function (or the name of a function) in the *callback* parameter. Then,      a \"Cancel\" button will be displayed so the user can cancel whatever is happening in the      application. When pressed, the callback is invoked.        Arguments:          state (State^): The current user state received in any callback.          callback (Optional[Union[str, Callable]]): The function to be called if the user              chooses to cancel.<br/>              If empty or None, no cancel action is provided to the user.<br/>              The signature of this function is:              - state (State^): The user state;              - id (str): the id of the button that triggered the callback. That will always be                \"UIBlocker\" since it is created and managed internally;          message: The message to show. The default value is the string \"Work in Progress...\".      \"\"\"      if state and isinstance(state._gui, Gui):          state._gui._hold_actions(callback, message)      else:          _warn(\"'hold_actions()' must be called in the context of a callback.\")      def resume_control(state: State):      \"\"\"Resume the User Interface actions.        This function must be called after `hold_control()^` was invoked, when interaction      must be allowed again for the user.        Arguments:          state (State^): The current user state as received in any callback.      \"\"\"      if state and isinstance(state._gui, Gui):          state._gui._resume_actions()      else:          _warn(\"'resume_actions()' must be called in the context of a callback.\")      def navigate(      state: State,      to: t.Optional[str] = \"\",      params: t.Optional[t.Dict[str, str]] = None,      tab: t.Optional[str] = None,      force: t.Optional[bool] = False,  ):      \"\"\"Navigate to a page.        Arguments:          state (State^): The current user state as received in any callback.          to: The name of the page to navigate to. This can be a page identifier (as created by              `Gui.add_page()^` with no leading '/') or an URL.<br/>              If omitted, the application navigates to the root page.          params: A dictionary of query parameters.          tab: When navigating to a page that is not a known page, the page is opened in a tab identified by              *tab* (as in [window.open](https://developer.mozilla.org/en-US/docs/Web/API/Window/open)).<br/>              The default value creates a new tab for the page (which is equivalent to setting *tab* to \"_blank\").          force: When navigating to a known page, the content is refreshed even it the page is already shown.      \"\"\"      if state and isinstance(state._gui, Gui):          state._gui._navigate(to, params, tab, force)      else:          _warn(\"'navigate()' must be called in the context of a callback.\")      def get_user_content_url(      state: State, path: t.Optional[str] = None, params: t.Optional[t.Dict[str, str]] = None  ) -> t.Optional[str]:      \"\"\"Get a user content URL.        This function can be used if you need to deliver dynamic content to your page: you can create      a path at run-time that, when queried, will deliver some user-defined content defined in the      *on_user_content* callback (see the description of the `Gui^` class for more information).        Arguments:          state (State^): The current user state as received in any callback.          path: An optional additional path to the URL.          params: An optional dictionary sent to the *on_user_content* callback.<br/>              These arguments are added as query parameters to the generated URL and converted into              strings.        Returns:          An URL that, when queried, triggers the *on_user_content* callback.      \"\"\"      if state and isinstance(state._gui, Gui):          return state._gui._get_user_content_url(path, params)      _warn(\"'get_user_content_url()' must be called in the context of a callback.\")      return None      def get_state_id(state: State) -> t.Optional[str]:      \"\"\"Get the identifier of a state.        The state identifier is a string generated by Taipy GUI for a given `State^` that is used      to serialize callbacks.      See the      [User Manual section on Long Running Callbacks](../gui/callbacks.md#long-running-callbacks)      for details on when and how this function can be used.        Arguments:          state (State^): The current user state as received in any callback.        Returns:          A string that uniquely identifies the state.<br/>          If None, then **state** was not handled by a `Gui^` instance.      \"\"\"      if state and isinstance(state._gui, Gui):          return state._gui._get_client_id()      return None      def get_module_context(state: State) -> t.Optional[str]:      \"\"\"Get the name of the module currently in used when using page scopes        Arguments:          state (State^): The current user state as received in any callback.        Returns:          The name of the current module      \"\"\"      if state and isinstance(state._gui, Gui):          return state._gui._get_locals_context()      return None      def get_context_id(state: State) -> t.Any:      _warn(\"'get_context_id()' was deprecated in Taipy GUI 2.0. Use 'get_state_id()' instead.\")      return get_state_id(state)      def get_module_name_from_state(state: State) -> t.Optional[str]:      \"\"\"Get the module name that triggered a callback.        Pages can be defined in different modules yet refer to callback functions declared elsewhere      (typically, the application's main module).        This function returns the name of the module where the page that holds the control that      triggered the callback was declared.  This lets applications implement different behaviors      depending on what page is involved.        This function must be called only in the body of a callback function.        Arguments:          state (State^): The `State^` instance, as received in any callback.        Returns:          The name of the module that holds the definition of the page containing the control              that triggered the callback that was provided the *state* object.      \"\"\"      if state and isinstance(state._gui, Gui):          return state._gui._get_locals_context()      return None      def invoke_callback(      gui: Gui,      state_id: str,      callback: t.Callable,      args: t.Union[t.Tuple, t.List],      module_context: t.Optional[str] = None,  ) -> t.Any:      \"\"\"Invoke a user callback for a given state.        See the      [User Manual section on Long Running Callbacks in a Thread](../gui/callbacks.md#long-running-callbacks-in-a-thread)      for details on when and how this function can be used.        Arguments:          gui (Gui^): The current Gui instance.          state_id: The identifier of the state to use, as returned by `get_state_id()^`.          callback (Callable[[State^, ...], None]): The user-defined function that is invoked.<br/>              The first parameter of this function **must** be a `State^`.          args (Union[Tuple, List]): The remaining arguments, as a List or a Tuple.          module_context (Optional[str]): the name of the module that will be used.      \"\"\"      if isinstance(gui, Gui):          return gui._call_user_callback(state_id, callback, list(args), module_context)      _warn(\"'invoke_callback()' must be called with a valid Gui instance.\")      def broadcast_callback(      gui: Gui,      callback: t.Callable,      args: t.Optional[t.Union[t.Tuple, t.List]] = None,      module_context: t.Optional[str] = None,  ) -> t.Any:      \"\"\"Invoke a callback for every client.        This callback gets invoked for every client connected to the application with the appropriate      `State^` instance. You can then perform client-specific tasks, such as updating the state      variable reflected in the user interface.        Arguments:          gui (Gui^): The current Gui instance.          callback: The user-defined function to be invoked.<br/>              The first parameter of this function must be a `State^` object representing the              client for which it is invoked.<br/>              The other parameters should reflect the ones provided in the *args* collection.          args: The parameters to send to *callback*, if any.      \"\"\"      if isinstance(gui, Gui):          return gui._call_broadcast_callback(callback, list(args) if args else [], module_context)      _warn(\"'broadcast_callback()' must be called with a valid Gui instance.\")      def invoke_state_callback(gui: Gui, state_id: str, callback: t.Callable, args: t.Union[t.Tuple, t.List]) -> t.Any:      _warn(\"'invoke_state_callback()' was deprecated in Taipy GUI 2.0. Use 'invoke_callback()' instead.\")      return invoke_callback(gui, state_id, callback, args)      def invoke_long_callback(      state: State,      user_function: t.Callable,      user_function_args: t.Union[t.Tuple, t.List] = [],      user_status_function: t.Optional[t.Callable] = None,      user_status_function_args: t.Union[t.Tuple, t.List] = [],      period=0,  ):      \"\"\"Invoke a long running user callback.        Long-running callbacks are run in a separate thread to not block the application itself.        This function expects to be provided a function to run in the background (in *user_function*).<br/>      It can also be specified a *status function* that is called when the operation performed by      *user_function* is finished (successfully or not), or periodically (using the *period* parameter).        See the      [User Manual section on Long Running Callbacks](../gui/callbacks.md#long-running-callbacks)      for details on when and how this function can be used.        Arguments:          state (State^): The `State^` instance, as received in any callback.          user_function (Callable[[...], None]): The function that will be run independently of Taipy GUI. Note              that this function must not use *state*, which is not persisted across threads.          user_function_args (Optional[List|Tuple]): The arguments to send to *user_function*.          user_status_function (Optional(Callable[[State^, bool, ...], None])): The optional user-defined status              function that is invoked at the end of and possibly during the runtime of *user_function*:                - The first parameter of this function is set to a `State^` instance.              - The second parameter of this function is set to a bool or an int, depending on the                conditions under which it is called:                   - If this parameter is set to a bool value, then:                       - If True, this indicates that *user_function* has finished properly.                          The last argument passed will be the result of the user_function call.                     - If False, this indicates that *user_function* failed.                   - If this parameter is set to an int value, then this value indicates                   how many periods (as lengthy as indicated in *period*) have elapsed since *user_function* was                   started.          user_status_function_args (Optional[List|Tuple]): The remaining arguments of the user status function.          period (int): The interval, in milliseconds, at which *user_status_function* is called.<br/>              The default value is 0, meaning no call to *user_status_function* will happen until *user_function*              terminates (then the second parameter of that call will be ).</br>              When set to a value smaller than 500, *user_status_function* is called only when *user_function*              terminates (as if *period* was set to 0).      \"\"\"      if not state or not isinstance(state._gui, Gui):          _warn(\"'invoke_long_callback()' must be called in the context of a callback.\")          return        state_id = get_state_id(state)      module_context = get_module_context(state)      if not isinstance(state_id, str) or not isinstance(module_context, str):          return        this_gui = state._gui        def callback_on_exception(state: State, function_name: str, e: Exception):          if not this_gui._call_on_exception(function_name, e):              _warn(f\"invoke_long_callback(): Exception raised in function {function_name}()\", e)        def callback_on_status(          status: t.Union[int, bool],          e: t.Optional[Exception] = None,          function_name: t.Optional[str] = None,          function_result: t.Optional[t.Any] = None,      ):          if callable(user_status_function):              invoke_callback(                  this_gui,                  str(state_id),                  user_status_function,                  [status] + list(user_status_function_args) + [function_result],  # type: ignore                  str(module_context),              )          if e:              invoke_callback(                  this_gui,                  str(state_id),                  callback_on_exception,                  (                      str(function_name),                      e,                  ),                  str(module_context),              )        def user_function_in_thread(*uf_args):          try:              res = user_function(*uf_args)              callback_on_status(True, function_result=res)          except Exception as e:              callback_on_status(False, e, user_function.__name__)        def thread_status(name: str, period_s: float, count: int):          active_thread = next((t for t in threading.enumerate() if t.name == name), None)          if active_thread:              callback_on_status(count)              threading.Timer(period_s, thread_status, (name, period_s, count + 1)).start()        thread = threading.Thread(target=user_function_in_thread, args=user_function_args)      thread.start()      if isinstance(period, int) and period >= 500 and callable(user_status_function):          thread_status(thread.name, period / 1000.0, 0) "}
{"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 __future__ import annotations    import contextlib  import importlib  import inspect  import json  import os  import pathlib  import re  import sys  import tempfile  import time  import typing as t  import warnings  from importlib import metadata, util  from importlib.util import find_spec  from types import FrameType, SimpleNamespace  from urllib.parse import unquote, urlencode, urlparse    import __main__  import markdown as md_lib  import tzlocal  from flask import Blueprint, Flask, g, jsonify, request, send_file, send_from_directory  from werkzeug.utils import secure_filename    from taipy.logger._taipy_logger import _TaipyLogger    if util.find_spec(\"pyngrok\"):      from pyngrok import ngrok    from ._default_config import _default_stylekit, default_config  from ._page import _Page  from ._renderers import _EmptyPage  from ._renderers._markdown import _TaipyMarkdownExtension  from ._renderers.factory import _Factory  from ._renderers.json import _TaipyJsonEncoder  from ._renderers.utils import _get_columns_dict  from ._warnings import TaipyGuiWarning, _warn  from .builder import _ElementApiGenerator  from .config import Config, ConfigParameter, _Config  from .data.content_accessor import _ContentAccessor  from .data.data_accessor import _DataAccessor, _DataAccessors  from .data.data_format import _DataFormat  from .data.data_scope import _DataScopes  from .extension.library import Element, ElementLibrary  from .page import Page  from .partial import Partial  from .server import _Server  from .state import State  from .types import _WsType  from .utils import (      _delscopeattr,      _filter_locals,      _get_broadcast_var_name,      _get_client_var_name,      _get_css_var_value,      _get_expr_var_name,      _get_module_name_from_frame,      _get_non_existent_file_path,      _get_page_from_module,      _getscopeattr,      _getscopeattr_drill,      _hasscopeattr,      _is_in_notebook,      _LocalsContext,      _MapDict,      _setscopeattr,      _setscopeattr_drill,      _TaipyBase,      _TaipyContent,      _TaipyContentHtml,      _TaipyContentImage,      _TaipyData,      _TaipyLov,      _TaipyLovValue,      _to_camel_case,      _variable_decode,      is_debugging,  )  from .utils._adapter import _Adapter  from .utils._bindings import _Bindings  from .utils._evaluator import _Evaluator  from .utils._variable_directory import _MODULE_ID, _VariableDirectory  from .utils.chart_config_builder import _build_chart_config  from .utils.table_col_builder import _enhance_columns      class _DoNotUpdate:      def __repr__(self):          return \"Taipy: Do not update\"      class Gui:      \"\"\"Entry point for the Graphical User Interface generation.        Attributes:          on_action (Callable): The function that is called when a control              triggers an action, as the result of an interaction with the end-user.<br/>              It defaults to the `on_action()` global function defined in the Python              application. If there is no such function, actions will not trigger anything.<br/>              The signature of the *on_action* callback function must be:                - *state*: the `State^` instance of the caller.              - *id* (optional): a string representing the identifier of the caller.              - *payload* (optional): an optional payload from the caller.          on_change (Callable): The function that is called when a control              modifies variables it is bound to, as the result of an interaction with the              end-user.<br/>              It defaults to the `on_change()` global function defined in the Python              application. If there is no such function, user interactions will not trigger              anything.<br/>              The signature of the *on_change* callback function must be:                - *state*: the `State^` instance of the caller.              - *var_name* (str): The name of the variable that triggered this callback.              - *var_value* (any): The new value for this variable.          on_init (Callable): The function that is called on the first connection of a new client.<br/>              It defaults to the `on_init()` global function defined in the Python              application. If there is no such function, the first connection will not trigger              anything.<br/>                The signature of the *on_init* callback function must be:                - *state*: the `State^` instance of the caller.          on_navigate (Callable): The function that is called when a page is requested.<br/>              It defaults to the `on_navigate()` global function defined in the Python              application. If there is no such function, page requests will not trigger              anything.<br/>              The signature of the *on_navigate* callback function must be:                - *state*: the `State^` instance of the caller.              - *page_name*: the name of the page the user is navigating to.              - *params* (Optional): the query parameters provided in the URL.                The *on_navigate* callback function must return the name of the page the user should be              directed to.          on_exception (Callable): The function that is called an exception occurs on user code.<br/>              It defaults to the `on_exception()` global function defined in the Python              application. If there is no such function, exceptions will not trigger              anything.<br/>              The signature of the *on_exception* callback function must be:                - *state*: the `State^` instance of the caller.              - *function_name*: the name of the function that raised the exception.              - *exception*: the exception object that was raised.          on_status (Callable): The function that is called when the status page is shown.<br/>              It defaults to the `on_status()` global function defined in the Python              application. If there is no such function, status page content shows only the status of the              server.<br/>              The signature of the *on_status* callback function must be:                - *state*: the `State^` instance of the caller.                It must return raw and valid HTML content as a string.          on_user_content (Callable): The function that is called when a specific URL (generated by              `get_user_content_url()^`) is requested.<br/>              This callback function must return the raw HTML content of the page to be displayed on              the browser.                This attribute defaults to the `on_user_content()` global function defined in the Python              application. If there is no such function, those specific URLs will not trigger              anything.<br/>              The signature of the *on_user_content* callback function must be:                - *state*: the `State^` instance of the caller.              - *path*: the path provided to the `get_user_content_url()^` to build the URL.              - *parameters*: An optional dictionary as defined in the `get_user_content_url()^` call.                The returned HTML content can therefore use both the variables stored in the *state*              and the parameters provided in the call to `get_user_content_url()^`.          state (State^): **Only defined when running in an IPython notebook context.**<br/>              The unique instance of `State^` that you can use to change bound variables              directly, potentially impacting the user interface in real-time.        !!! note          This class belongs to and is documented in the `taipy.gui` package but it is          accessible from the top `taipy` package to simplify its access, allowing to          use:          ```py          from taipy import Gui          ```      \"\"\"        __root_page_name = \"TaiPy_root_page\"      __env_filename = \"taipy.gui.env\"      __UI_BLOCK_NAME = \"TaipyUiBlockVar\"      __MESSAGE_GROUPING_NAME = \"TaipyMessageGrouping\"      __ON_INIT_NAME = \"TaipyOnInit\"      __ARG_CLIENT_ID = \"client_id\"      __INIT_URL = \"taipy-init\"      __JSX_URL = \"taipy-jsx\"      __CONTENT_ROOT = \"taipy-content\"      __UPLOAD_URL = \"taipy-uploads\"      _EXTENSION_ROOT = \"taipy-extension\"      __USER_CONTENT_URL = \"taipy-user-content\"      __BROADCAST_G_ID = \"taipy_broadcasting\"      __BRDCST_CALLBACK_G_ID = \"taipy_brdcst_callback\"      __SELF_VAR = \"__gui\"      __DO_NOT_UPDATE_VALUE = _DoNotUpdate()      _HTML_CONTENT_KEY = \"__taipy_html_content\"      __USER_CONTENT_CB = \"custom_user_content_cb\"        __RE_HTML = re.compile(r\"(.*?)\\.html$\")      __RE_MD = re.compile(r\"(.*?)\\.md$\")      __RE_PY = re.compile(r\"(.*?)\\.py$\")      __RE_PAGE_NAME = re.compile(r\"^[\\w\\-\\/]+$\")        __reserved_routes: t.List[str] = [          __INIT_URL,          __JSX_URL,          __CONTENT_ROOT,          __UPLOAD_URL,          _EXTENSION_ROOT,          __USER_CONTENT_URL,      ]        __LOCAL_TZ = str(tzlocal.get_localzone())        __extensions: t.Dict[str, t.List[ElementLibrary]] = {}        __shared_variables: t.List[str] = []        __content_providers: t.Dict[type, t.Callable[..., str]] = {}        def __init__(          self,          page: t.Optional[t.Union[str, Page]] = None,          pages: t.Optional[dict] = None,          css_file: t.Optional[str] = None,          path_mapping: t.Optional[dict] = {},          env_filename: t.Optional[str] = None,          libraries: t.Optional[t.List[ElementLibrary]] = None,          flask: t.Optional[Flask] = None,      ):          \"\"\"Initialize a new Gui instance.            Arguments:              page (Optional[Union[str, Page^]]): An optional `Page^` instance that is used                  when there is a single page in this interface, referenced as the *root*                  page (located at `/`).<br/>                  If *page* is a raw string and if it holds a path to a readable file then                  a `Markdown^` page is built from the content of that file.<br/>                  If *page* is a string that does not indicate a path to readable file then                  a `Markdown^` page is built from that string.<br/>                  Note that if *pages* is provided, those pages are added as well.              pages (Optional[dict]): Used if you want to initialize this instance with a set                  of pages.<br/>                  The method `(Gui.)add_pages(pages)^` is called if *pages* is not None.                  You can find details on the possible values of this argument in the                  documentation for this method.              css_file (Optional[str]): A pathname to a CSS file that gets used as a style sheet in                  all the pages.<br/>                  The default value is a file that has the same base name as the Python                  file defining the `main` function, sitting next to this Python file,                  with the `.css` extension.              path_mapping (Optional[dict]): A dictionary that associates a URL prefix to                  a path in the server file system.<br/>                  If the assets of your application are located in */home/me/app_assets* and                  you want to access them using only '*assets*' in your application, you can                  set *path_mapping={\"assets\": \"/home/me/app_assets\"}*. If your application                  then requests the file *\"/assets/images/logo.png\"*, the server searches                  for the file  *\"/home/me/app_assets/images/logo.png\"*.<br/>                  If empty or not defined, access through the browser to all resources under the directory                  of the main Python file is allowed.              env_filename (Optional[str]): An optional file from which to load application                  configuration variables (see the                  [Configuration](../gui/configuration.md#configuring-the-gui-instance) section                  of the User Manual for details.)<br/>                  The default value is \"taipy.gui.env\"              libraries (Optional[List[ElementLibrary]]): An optional list of extension library                  instances that pages can reference.<br/>                  Using this argument is equivalent to calling `(Gui.)add_library()^` for each                  list's elements.              flask (Optional[Flask]): An optional instance of a Flask application object.<br/>                  If this argument is set, this `Gui` instance will use the value of this argument                  as the underlying server. If omitted or set to None, this `Gui` will create its                  own Flask application instance and use it to serve the pages.          \"\"\"          # store suspected local containing frame          self.__frame = t.cast(FrameType, t.cast(FrameType, inspect.currentframe()).f_back)          self.__default_module_name = _get_module_name_from_frame(self.__frame)          self._set_css_file(css_file)            # Preserve server config for server initialization          self._path_mapping = path_mapping          self._flask = flask            self._config = _Config()          self.__content_accessor = None          self._accessors = _DataAccessors()          self.__state: t.Optional[State] = None          self.__bindings = _Bindings(self)          self.__locals_context = _LocalsContext()          self.__var_dir = _VariableDirectory(self.__locals_context)            self.__evaluator: _Evaluator = None  # type: ignore          self.__adapter = _Adapter()          self.__directory_name_of_pages: t.List[str] = []            # default actions          self.on_action: t.Optional[t.Callable] = None          self.on_change: t.Optional[t.Callable] = None          self.on_init: t.Optional[t.Callable] = None          self.on_navigate: t.Optional[t.Callable] = None          self.on_exception: t.Optional[t.Callable] = None          self.on_status: t.Optional[t.Callable] = None          self.on_user_content: t.Optional[t.Callable] = None            # sid from client_id          self.__client_id_2_sid: t.Dict[str, t.Set[str]] = {}            # Load default config          self._flask_blueprint: t.List[Blueprint] = []          self._config._load(default_config)            # get taipy version          try:              gui_file = pathlib.Path(__file__ or \".\").resolve()              with open(gui_file.parent / \"version.json\") as version_file:                  self.__version = json.load(version_file)          except Exception as e:  # pragma: no cover              _warn(\"Cannot retrieve version.json file\", e)              self.__version = {}            # Load Markdown extension          # NOTE: Make sure, if you change this extension list, that the User Manual gets updated.          # There's a section that explicitly lists these extensions in          #      docs/gui/pages.md#markdown-specifics          self._markdown = md_lib.Markdown(              extensions=[                  \"fenced_code\",                  \"meta\",                  \"admonition\",                  \"sane_lists\",                  \"tables\",                  \"attr_list\",                  \"md_in_html\",                  _TaipyMarkdownExtension(gui=self),              ]          )            if page:              self.add_page(name=Gui.__root_page_name, page=page)          if pages is not None:              self.add_pages(pages)          if env_filename is not None:              self.__env_filename = env_filename          if libraries is not None:              for library in libraries:                  Gui.add_library(library)        @staticmethod      def add_library(library: ElementLibrary) -> None:          \"\"\"Add a custom visual element library.            This application will be able to use custom visual elements defined in this library.            Arguments:              library: The custom visual element library to add to this application.            Multiple libraries with the same name can be added. This allows to split multiple custom visual          elements in several `ElementLibrary^` instances, but still refer to these elements with the same          prefix in the page definitions.          \"\"\"          if isinstance(library, ElementLibrary):              _Factory.set_library(library)              library_name = library.get_name()              if library_name.isidentifier():                  libs = Gui.__extensions.get(library_name)                  if libs is None:                      Gui.__extensions[library_name] = [library]                  else:                      libs.append(library)                  _ElementApiGenerator().add_library(library)              else:                  raise NameError(f\"ElementLibrary passed to add_library() has an invalid name: '{library_name}'\")          else:  # pragma: no cover              raise RuntimeError(                  f\"add_library() argument should be a subclass of ElementLibrary instead of '{type(library)}'\"              )        @staticmethod      def register_content_provider(content_type: type, content_provider: t.Callable[..., str]) -> None:          \"\"\"Add a custom content provider.            The application can use custom content for the `part` block when its *content* property is set to an object with type *type*.            Arguments:              content_type: The type of the content that triggers the content provider.              content_provider: The function that converts content of type *type* into an HTML string.            \"\"\"          if Gui.__content_providers.get(content_type):              _warn(f\"The type {content_type} is already associated with a provider.\")              return          if not callable(content_provider):              _warn(f\"The provider for {content_type} must be a function.\")              return          Gui.__content_providers[content_type] = content_provider        def __process_content_provider(self, state: State, path: str, query: t.Dict[str, str]):          variable_name = query.get(\"variable_name\")          content = None          if variable_name:              content = _getscopeattr(self, variable_name)              if isinstance(content, _TaipyContentHtml):                  content = content.get()              provider_fn = Gui.__content_providers.get(type(content))              if provider_fn is None:                  # try plotly                  if find_spec(\"plotly\") and find_spec(\"plotly.graph_objs\"):                      from plotly.graph_objs import Figure as PlotlyFigure                        if isinstance(content, PlotlyFigure):                            def get_plotly_content(figure: PlotlyFigure):                              return figure.to_html()                            Gui.register_content_provider(PlotlyFigure, get_plotly_content)                          provider_fn = get_plotly_content              if provider_fn is None:                  # try matplotlib                  if find_spec(\"matplotlib\") and find_spec(\"matplotlib.figure\"):                      from matplotlib.figure import Figure as MatplotlibFigure                        if isinstance(content, MatplotlibFigure):                            def get_matplotlib_content(figure: MatplotlibFigure):                              import base64                              from io import BytesIO                                buf = BytesIO()                              figure.savefig(buf, format=\"png\")                              data = base64.b64encode(buf.getbuffer()).decode(\"ascii\")                              return f'<img src=\"data:image/png;base64,{data}\"/>'                            Gui.register_content_provider(MatplotlibFigure, get_matplotlib_content)                          provider_fn = get_matplotlib_content                if callable(provider_fn):                  try:                      return provider_fn(content)                  except Exception as e:                      _warn(f\"Error in content provider for type {str(type(content))}\", e)          return (              '<div style=\"background:white;color:red;\">'              + (f\"No valid provider for type {type(content).__name__}\" if content else \"Wrong context.\")              + \"</div>\"          )        @staticmethod      def add_shared_variable(*names: str) -> None:          \"\"\"Add shared variables.            The variables will be synchronized between all clients when updated.          Note that only variables from the main module will be registered.            This is a synonym for `(Gui.)add_shared_variables()^`.            Arguments:              names: The names of the variables that become shared, as a list argument.          \"\"\"          for name in names:              if name not in Gui.__shared_variables:                  Gui.__shared_variables.append(name)        @staticmethod      def add_shared_variables(*names: str) -> None:          \"\"\"Add shared variables.            The variables will be synchronized between all clients when updated.          Note that only variables from the main module will be registered.            This is a synonym for `(Gui.)add_shared_variable()^`.            Arguments:              names: The names of the variables that become shared, as a list argument.          \"\"\"          Gui.add_shared_variable(*names)        def _get_shared_variables(self) -> t.List[str]:          return self.__evaluator.get_shared_variables()        def __get_content_accessor(self):          if self.__content_accessor is None:              self.__content_accessor = _ContentAccessor(self._get_config(\"data_url_max_size\", 50 * 1024))          return self.__content_accessor        def _bindings(self):          return self.__bindings        def _get_data_scope(self) -> SimpleNamespace:          return self.__bindings._get_data_scope()        def _get_all_data_scopes(self) -> t.Dict[str, SimpleNamespace]:          return self.__bindings._get_all_scopes()        def _get_config(self, name: ConfigParameter, default_value: t.Any) -> t.Any:          return self._config._get_config(name, default_value)        def _get_themes(self) -> t.Optional[t.Dict[str, t.Any]]:          theme = self._get_config(\"theme\", None)          dark_theme = self._get_config(\"dark_theme\", None)          light_theme = self._get_config(\"light_theme\", None)          res = {}          if theme:              res[\"base\"] = theme          if dark_theme:              res[\"dark\"] = dark_theme          if light_theme:              res[\"light\"] = light_theme          return res if theme or dark_theme or light_theme else None        def _bind(self, name: str, value: t.Any) -> None:          self._bindings()._bind(name, value)        def __get_state(self):          return self.__state        def _get_client_id(self) -> str:          return (              _DataScopes._GLOBAL_ID              if self._bindings()._is_single_client()              else getattr(g, Gui.__ARG_CLIENT_ID, \"unknown id\")          )        def __set_client_id_in_context(self, client_id: t.Optional[str] = None, force=False):          if not client_id and request:              client_id = request.args.get(Gui.__ARG_CLIENT_ID, \"\")          if not client_id and force:              res = self._bindings()._get_or_create_scope(\"\")              client_id = res[0] if res[1] else None          if client_id and request:              if sid := getattr(request, \"sid\", None):                  sids = self.__client_id_2_sid.get(client_id, None)                  if sids is None:                      sids = set()                      self.__client_id_2_sid[client_id] = sids                  sids.add(sid)          g.client_id = client_id        def __is_var_modified_in_context(self, var_name: str, derived_vars: t.Set[str]) -> bool:          modified_vars: t.Optional[t.Set[str]] = getattr(g, \"modified_vars\", None)          der_vars: t.Optional[t.Set[str]] = getattr(g, \"derived_vars\", None)          setattr(g, \"update_count\", getattr(g, \"update_count\", 0) + 1)          if modified_vars is None:              modified_vars = set()              g.modified_vars = modified_vars          if der_vars is None:              g.derived_vars = derived_vars          else:              der_vars.update(derived_vars)          if var_name in modified_vars:              return True          modified_vars.add(var_name)          return False        def __clean_vars_on_exit(self) -> t.Optional[t.Set[str]]:          update_count = getattr(g, \"update_count\", 0) - 1          if update_count < 1:              derived_vars: t.Set[str] = getattr(g, \"derived_vars\", set())              delattr(g, \"update_count\")              delattr(g, \"modified_vars\")              delattr(g, \"derived_vars\")              return derived_vars          else:              setattr(g, \"update_count\", update_count)              return None        def _manage_message(self, msg_type: _WsType, message: dict) -> None:          try:              client_id = None              if msg_type == _WsType.CLIENT_ID.value:                  res = self._bindings()._get_or_create_scope(message.get(\"payload\", \"\"))                  client_id = res[0] if res[1] else None              self.__set_client_id_in_context(client_id or message.get(Gui.__ARG_CLIENT_ID))              with self._set_locals_context(message.get(\"module_context\") or None):                  if msg_type == _WsType.UPDATE.value:                      payload = message.get(\"payload\", {})                      self.__front_end_update(                          str(message.get(\"name\")),                          payload.get(\"value\"),                          message.get(\"propagate\", True),                          payload.get(\"relvar\"),                          payload.get(\"on_change\"),                      )                  elif msg_type == _WsType.ACTION.value:                      self.__on_action(message.get(\"name\"), message.get(\"payload\"))                  elif msg_type == _WsType.DATA_UPDATE.value:                      self.__request_data_update(str(message.get(\"name\")), message.get(\"payload\"))                  elif msg_type == _WsType.REQUEST_UPDATE.value:                      self.__request_var_update(message.get(\"payload\"))              self.__send_ack(message.get(\"ack_id\"))          except Exception as e:  # pragma: no cover              _warn(f\"Decoding Message has failed: {message}\", e)        def __front_end_update(          self,          var_name: str,          value: t.Any,          propagate=True,          rel_var: t.Optional[str] = None,          on_change: t.Optional[str] = None,      ) -> None:          if not var_name:              return          # Check if Variable is a managed type          current_value = _getscopeattr_drill(self, self.__evaluator.get_hash_from_expr(var_name))          if isinstance(current_value, _TaipyData):              return          elif rel_var and isinstance(current_value, _TaipyLovValue):  # pragma: no cover              lov_holder = _getscopeattr_drill(self, self.__evaluator.get_hash_from_expr(rel_var))              if isinstance(lov_holder, _TaipyLov):                  val = value if isinstance(value, list) else [value]                  elt_4_ids = self.__adapter._get_elt_per_ids(lov_holder.get_name(), lov_holder.get())                  ret_val = [elt_4_ids.get(x, x) for x in val]                  if isinstance(value, list):                      value = ret_val                  elif ret_val:                      value = ret_val[0]          elif isinstance(current_value, _TaipyBase):              value = current_value.cast_value(value)          self._update_var(              var_name, value, propagate, current_value if isinstance(current_value, _TaipyBase) else None, on_change          )        def _update_var(          self,          var_name: str,          value: t.Any,          propagate=True,          holder: t.Optional[_TaipyBase] = None,          on_change: t.Optional[str] = None,      ) -> None:          if holder:              var_name = holder.get_name()          hash_expr = self.__evaluator.get_hash_from_expr(var_name)          derived_vars = {hash_expr}          # set to broadcast mode if hash_expr is in shared_variable          if hash_expr in self._get_shared_variables():              self._set_broadcast()          # Use custom attrsetter function to allow value binding for _MapDict          if propagate:              _setscopeattr_drill(self, hash_expr, value)              # In case expression == hash (which is when there is only a single variable in expression)              if var_name == hash_expr or hash_expr.startswith(\"tpec_\"):                  derived_vars.update(self._re_evaluate_expr(var_name))          elif holder:              derived_vars.update(self._evaluate_holders(hash_expr))          # if the variable has been evaluated then skip updating to prevent infinite loop          var_modified = self.__is_var_modified_in_context(hash_expr, derived_vars)          if not var_modified:              self._call_on_change(                  var_name,                  value.get() if isinstance(value, _TaipyBase) else value._dict if isinstance(value, _MapDict) else value,                  on_change,              )          derived_modified = self.__clean_vars_on_exit()          if derived_modified is not None:              self.__send_var_list_update(list(derived_modified), var_name)        def _get_real_var_name(self, var_name: str) -> t.Tuple[str, str]:          if not var_name:              return (var_name, var_name)          # Handle holder prefix if needed          if var_name.startswith(_TaipyBase._HOLDER_PREFIX):              for hp in _TaipyBase._get_holder_prefixes():                  if var_name.startswith(hp):                      var_name = var_name[len(hp) :]                      break          suffix_var_name = \"\"          if \".\" in var_name:              first_dot_index = var_name.index(\".\")              suffix_var_name = var_name[first_dot_index + 1 :]              var_name = var_name[:first_dot_index]          var_name_decode, module_name = _variable_decode(self._get_expr_from_hash(var_name))          current_context = self._get_locals_context()          # #583: allow module resolution for var_name in current_context root_page context          if (              module_name              and self._config.root_page              and self._config.root_page._renderer              and self._config.root_page._renderer._get_module_name() == module_name          ):              return f\"{var_name_decode}.{suffix_var_name}\" if suffix_var_name else var_name_decode, module_name          if module_name == current_context:              var_name = var_name_decode          else:              if var_name not in self.__var_dir._var_head:                  raise NameError(f\"Can't find matching variable for {var_name} on context: {current_context}\")              _found = False              for k, v in self.__var_dir._var_head[var_name]:                  if v == current_context:                      var_name = k                      _found = True                      break              if not _found:  # pragma: no cover                  raise NameError(f\"Can't find matching variable for {var_name} on context: {current_context}\")          return f\"{var_name}.{suffix_var_name}\" if suffix_var_name else var_name, current_context        def _call_on_change(self, var_name: str, value: t.Any, on_change: t.Optional[str] = None):          try:              var_name, current_context = self._get_real_var_name(var_name)          except Exception as e:  # pragma: no cover              _warn(\"\", e)              return          on_change_fn = self._get_user_function(on_change) if on_change else None          if not callable(on_change_fn):              on_change_fn = self._get_user_function(\"on_change\")          if callable(on_change_fn):              try:                  argcount = on_change_fn.__code__.co_argcount                  if argcount > 0 and inspect.ismethod(on_change_fn):                      argcount -= 1                  args: t.List[t.Any] = [None for _ in range(argcount)]                  if argcount > 0:                      args[0] = self.__get_state()                  if argcount > 1:                      args[1] = var_name                  if argcount > 2:                      args[2] = value                  if argcount > 3:                      args[3] = current_context                  on_change_fn(*args)              except Exception as e:  # pragma: no cover                  if not self._call_on_exception(on_change or \"on_change\", e):                      _warn(f\"{on_change or 'on_change'}(): callback function raised an exception\", e)        def _get_content(self, var_name: str, value: t.Any, image: bool) -> t.Any:          ret_value = self.__get_content_accessor().get_info(var_name, value, image)          return f\"/{Gui.__CONTENT_ROOT}/{ret_value[0]}\" if isinstance(ret_value, tuple) else ret_value        def __serve_content(self, path: str) -> t.Any:          self.__set_client_id_in_context()          parts = path.split(\"/\")          if len(parts) > 1:              file_name = parts[-1]              (dir_path, as_attachment) = self.__get_content_accessor().get_content_path(                  path[: -len(file_name) - 1], file_name, request.args.get(\"bypass\")              )              if dir_path:                  return send_from_directory(str(dir_path), file_name, as_attachment=as_attachment)          return (\"\", 404)        def _get_user_content_url(          self, path: t.Optional[str] = None, query_args: t.Optional[t.Dict[str, str]] = None      ) -> t.Optional[str]:          qargs = query_args or {}          qargs.update({Gui.__ARG_CLIENT_ID: self._get_client_id()})          return f\"/{Gui.__USER_CONTENT_URL}/{path or 'TaIpY'}?{urlencode(qargs)}\"        def __serve_user_content(self, path: str) -> t.Any:          self.__set_client_id_in_context()          qargs: t.Dict[str, str] = {}          qargs.update(request.args)          qargs.pop(Gui.__ARG_CLIENT_ID, None)          cb_function: t.Optional[t.Union[t.Callable, str]] = None          cb_function_name = None          if qargs.get(Gui._HTML_CONTENT_KEY):              cb_function = self.__process_content_provider              cb_function_name = cb_function.__name__          else:              cb_function_name = qargs.get(Gui.__USER_CONTENT_CB)              if cb_function_name:                  cb_function = self._get_user_function(cb_function_name)                  if not callable(cb_function):                      parts = cb_function_name.split(\".\", 1)                      if len(parts) > 1:                          base = _getscopeattr(self, parts[0], None)                          if base and (meth := getattr(base, parts[1], None)):                              cb_function = meth                          else:                              base = self.__evaluator._get_instance_in_context(parts[0])                              if base and (meth := getattr(base, parts[1], None)):                                  cb_function = meth                  if not callable(cb_function):                      _warn(f\"{cb_function_name}() callback function has not been defined.\")                      cb_function = None          if cb_function is None:              cb_function_name = \"on_user_content\"              if hasattr(self, cb_function_name) and callable(self.on_user_content):                  cb_function = self.on_user_content              else:                  _warn(\"on_user_content() callback function has not been defined.\")          if callable(cb_function):              try:                  args: t.List[t.Any] = []                  if path:                      args.append(path)                  if len(qargs):                      args.append(qargs)                  ret = self._call_function_with_state(cb_function, args)                  if ret is None:                      _warn(f\"{cb_function_name}() callback function must return a value.\")                  else:                      return (ret, 200)              except Exception as e:  # pragma: no cover                  if not self._call_on_exception(str(cb_function_name), e):                      _warn(f\"{cb_function_name}() callback function raised an exception\", e)          return (\"\", 404)        def __serve_extension(self, path: str) -> t.Any:          parts = path.split(\"/\")          last_error = \"\"          resource_name = None          if len(parts) > 1:              libs = Gui.__extensions.get(parts[0], [])              for library in libs:                  try:                      resource_name = library.get_resource(\"/\".join(parts[1:]))                      if resource_name:                          return send_file(resource_name)                  except Exception as e:                      last_error = f\"\\n{e}\"  # Check if the resource is served by another library with the same name          _warn(f\"Resource '{resource_name or path}' not accessible for library '{parts[0]}'{last_error}\")          return (\"\", 404)        def __get_version(self) -> str:          return f'{self.__version.get(\"major\", 0)}.{self.__version.get(\"minor\", 0)}.{self.__version.get(\"patch\", 0)}'        def __append_libraries_to_status(self, status: t.Dict[str, t.Any]):          libraries: t.Dict[str, t.Any] = {}          for libs_list in self.__extensions.values():              for lib in libs_list:                  if not isinstance(lib, ElementLibrary):                      continue                  libs = libraries.get(lib.get_name())                  if libs is None:                      libs = []                      libraries[lib.get_name()] = libs                  elts: t.List[t.Dict[str, str]] = []                  libs.append({\"js module\": lib.get_js_module_name(), \"elements\": elts})                  for element_name, elt in lib.get_elements().items():                      if not isinstance(elt, Element):                          continue                      elt_dict = {\"name\": element_name}                      if hasattr(elt, \"_render_xhtml\"):                          elt_dict[\"render function\"] = elt._render_xhtml.__code__.co_name                      else:                          elt_dict[\"react name\"] = elt._get_js_name(element_name)                      elts.append(elt_dict)          status.update({\"libraries\": libraries})        def _serve_status(self, template: pathlib.Path) -> t.Dict[str, t.Dict[str, str]]:          base_json: t.Dict[str, t.Any] = {\"user_status\": str(self.__call_on_status() or \"\")}          if self._get_config(\"extended_status\", False):              base_json.update(                  {                      \"flask_version\": str(metadata.version(\"flask\") or \"\"),                      \"backend_version\": self.__get_version(),                      \"host\": f'{self._get_config(\"host\", \"localhost\")}:{self._get_config(\"port\", \"default\")}',                      \"python_version\": sys.version,                  }              )              self.__append_libraries_to_status(base_json)              try:                  base_json.update(json.loads(template.read_text()))              except Exception as e:  # pragma: no cover                  _warn(f\"Exception raised reading JSON in '{template}'\", e)          return {\"gui\": base_json}        def __upload_files(self):          self.__set_client_id_in_context()          if \"var_name\" not in request.form:              _warn(\"No var name\")              return (\"No var name\", 400)          var_name = request.form[\"var_name\"]          multiple = \"multiple\" in request.form and request.form[\"multiple\"] == \"True\"          if \"blob\" not in request.files:              _warn(\"No file part\")              return (\"No file part\", 400)          file = request.files[\"blob\"]          # If the user does not select a file, the browser submits an          # empty file without a filename.          if file.filename == \"\":              _warn(\"No selected file\")              return (\"No selected file\", 400)          suffix = \"\"          complete = True          part = 0          if \"total\" in request.form:              total = int(request.form[\"total\"])              if total > 1 and \"part\" in request.form:                  part = int(request.form[\"part\"])                  suffix = f\".part.{part}\"                  complete = part == total - 1          if file:  # and allowed_file(file.filename)              upload_path = pathlib.Path(self._get_config(\"upload_folder\", tempfile.gettempdir())).resolve()              file_path = _get_non_existent_file_path(upload_path, secure_filename(file.filename))              file.save(str(upload_path / (file_path.name + suffix)))              if complete:                  if part > 0:                      try:                          with open(file_path, \"wb\") as grouped_file:                              for nb in range(part + 1):                                  with open(upload_path / f\"{file_path.name}.part.{nb}\", \"rb\") as part_file:                                      grouped_file.write(part_file.read())                      except EnvironmentError as ee:  # pragma: no cover                          _warn(\"Cannot group file after chunk upload\", ee)                          return                  # notify the file is uploaded                  newvalue = str(file_path)                  if multiple:                      value = _getscopeattr(self, var_name)                      if not isinstance(value, t.List):                          value = [] if value is None else [value]                      value.append(newvalue)                      newvalue = value                  setattr(self._bindings(), var_name, newvalue)          return (\"\", 200)        _data_request_counter = 1        def __send_var_list_update(  # noqa C901          self,          modified_vars: t.List[str],          front_var: t.Optional[str] = None,      ):          ws_dict = {}          values = {v: _getscopeattr_drill(self, v) for v in modified_vars}          for k, v in values.items():              if isinstance(v, (_TaipyData, _TaipyContentHtml)) and v.get_name() in modified_vars:                  modified_vars.remove(v.get_name())              elif isinstance(v, _DoNotUpdate):                  modified_vars.remove(k)          for _var in modified_vars:              newvalue = values.get(_var)              if isinstance(newvalue, _TaipyData):                  # A changing integer that triggers a data request                  newvalue = Gui._data_request_counter                  Gui._data_request_counter = (Gui._data_request_counter % 100) + 1              else:                  if isinstance(newvalue, (_TaipyContent, _TaipyContentImage)):                      ret_value = self.__get_content_accessor().get_info(                          front_var, newvalue.get(), isinstance(newvalue, _TaipyContentImage)                      )                      if isinstance(ret_value, tuple):                          newvalue = f\"/{Gui.__CONTENT_ROOT}/{ret_value[0]}\"                      else:                          newvalue = ret_value                  elif isinstance(newvalue, _TaipyContentHtml):                      newvalue = self._get_user_content_url(                          None, {\"variable_name\": str(_var), Gui._HTML_CONTENT_KEY: str(time.time())}                      )                  elif isinstance(newvalue, _TaipyLov):                      newvalue = [self.__adapter._run_for_var(newvalue.get_name(), elt) for elt in newvalue.get()]                  elif isinstance(newvalue, _TaipyLovValue):                      if isinstance(newvalue.get(), list):                          newvalue = [                              self.__adapter._run_for_var(newvalue.get_name(), elt, id_only=True)                              for elt in newvalue.get()                          ]                      else:                          newvalue = self.__adapter._run_for_var(newvalue.get_name(), newvalue.get(), id_only=True)                  if isinstance(newvalue, (dict, _MapDict)):                      continue  # this var has no transformer                  debug_warnings: t.List[warnings.WarningMessage] = []                  with warnings.catch_warnings(record=True) as warns:                      warnings.resetwarnings()                      json.dumps(newvalue, cls=_TaipyJsonEncoder)                      if len(warns):                          keep_value = True                          for w in list(warns):                              if is_debugging():                                  debug_warnings.append(w)                              if w.category is not DeprecationWarning and w.category is not PendingDeprecationWarning:                                  keep_value = False                                  break                          if not keep_value:                              # do not send data that is not serializable                              continue                  for w in debug_warnings:                      warnings.warn(w.message, w.category)              ws_dict[_var] = newvalue          # TODO: What if value == newvalue?          self.__send_ws_update_with_dict(ws_dict)        def __request_data_update(self, var_name: str, payload: t.Any) -> None:          # Use custom attrgetter function to allow value binding for _MapDict          newvalue = _getscopeattr_drill(self, var_name)          if isinstance(newvalue, _TaipyData):              ret_payload = None              if isinstance(payload, dict):                  lib_name = payload.get(\"library\")                  if isinstance(lib_name, str):                      libs = self.__extensions.get(lib_name, [])                      for lib in libs:                          user_var_name = var_name                          try:                              with contextlib.suppress(NameError):                                  # ignore name error and keep var_name                                  user_var_name = self._get_real_var_name(var_name)[0]                              ret_payload = lib.get_data(lib_name, payload, user_var_name, newvalue)                              if ret_payload:                                  break                          except Exception as e:  # pragma: no cover                              _warn(                                  f\"Exception raised in '{lib_name}.get_data({lib_name}, payload, {user_var_name}, value)'\",                                  e,                              )              if not isinstance(ret_payload, dict):                  ret_payload = self._accessors._get_data(self, var_name, newvalue, payload)              self.__send_ws_update_with_dict({var_name: ret_payload})        def __request_var_update(self, payload: t.Any):          if isinstance(payload, dict) and isinstance(payload.get(\"names\"), list):              if payload.get(\"refresh\", False):                  # refresh vars                  for _var in t.cast(list, payload.get(\"names\")):                      val = _getscopeattr_drill(self, _var)                      self._refresh_expr(                          val.get_name() if isinstance(val, _TaipyBase) else _var,                          val if isinstance(val, _TaipyBase) else None,                      )              self.__send_var_list_update(payload[\"names\"])        def __send_ws(self, payload: dict, allow_grouping=True) -> None:          grouping_message = self.__get_message_grouping() if allow_grouping else None          if grouping_message is None:              try:                  self._server._ws.emit(                      \"message\",                      payload,                      to=self.__get_ws_receiver(),                  )                  time.sleep(0.001)              except Exception as e:  # pragma: no cover                  _warn(f\"Exception raised in WebSocket communication in '{self.__frame.f_code.co_name}'\", e)          else:              grouping_message.append(payload)        def __broadcast_ws(self, payload: dict):          try:              self._server._ws.emit(                  \"message\",                  payload,              )              time.sleep(0.001)          except Exception as e:  # pragma: no cover              _warn(f\"Exception raised in WebSocket communication in '{self.__frame.f_code.co_name}'\", e)        def __send_ack(self, ack_id: t.Optional[str]) -> None:          if ack_id:              try:                  self._server._ws.emit(\"message\", {\"type\": _WsType.ACKNOWLEDGEMENT.value, \"id\": ack_id})                  time.sleep(0.001)              except Exception as e:  # pragma: no cover                  _warn(f\"Exception raised in WebSocket communication (send ack) in '{self.__frame.f_code.co_name}'\", e)        def _send_ws_id(self, id: str) -> None:          self.__send_ws(              {                  \"type\": _WsType.CLIENT_ID.value,                  \"id\": id,              },              allow_grouping=False,          )        def __send_ws_download(self, content: str, name: str, on_action: str) -> None:          self.__send_ws({\"type\": _WsType.DOWNLOAD_FILE.value, \"content\": content, \"name\": name, \"onAction\": on_action})        def __send_ws_alert(self, type: str, message: str, system_notification: bool, duration: int) -> None:          self.__send_ws(              {                  \"type\": _WsType.ALERT.value,                  \"atype\": type,                  \"message\": message,                  \"system\": system_notification,                  \"duration\": duration,              }          )        def __send_ws_partial(self, partial: str):          self.__send_ws(              {                  \"type\": _WsType.PARTIAL.value,                  \"name\": partial,              }          )        def __send_ws_block(          self,          action: t.Optional[str] = None,          message: t.Optional[str] = None,          close: t.Optional[bool] = False,          cancel: t.Optional[bool] = False,      ):          self.__send_ws(              {                  \"type\": _WsType.BLOCK.value,                  \"action\": action,                  \"close\": close,                  \"message\": message,                  \"noCancel\": not cancel,              }          )        def __send_ws_navigate(          self,          to: str,          params: t.Optional[t.Dict[str, str]],          tab: t.Optional[str],          force: bool,      ):          self.__send_ws({\"type\": _WsType.NAVIGATE.value, \"to\": to, \"params\": params, \"tab\": tab, \"force\": force})        def __send_ws_update_with_dict(self, modified_values: dict) -> None:          payload = [              {\"name\": _get_client_var_name(k), \"payload\": (v if isinstance(v, dict) and \"value\" in v else {\"value\": v})}              for k, v in modified_values.items()          ]          if self._is_broadcasting():              self.__broadcast_ws({\"type\": _WsType.MULTIPLE_UPDATE.value, \"payload\": payload})              self._set_broadcast(False)          else:              self.__send_ws({\"type\": _WsType.MULTIPLE_UPDATE.value, \"payload\": payload})        def __send_ws_broadcast(self, var_name: str, var_value: t.Any):          self.__broadcast_ws(              {\"type\": _WsType.UPDATE.value, \"name\": _get_broadcast_var_name(var_name), \"payload\": {\"value\": var_value}}          )        def __get_ws_receiver(self) -> t.Union[t.List[str], t.Any, None]:          if self._bindings()._is_single_client():              return None          sid = getattr(request, \"sid\", None) if request else None          sids = self.__client_id_2_sid.get(self._get_client_id(), set())          if sid:              sids.add(sid)          return list(sids)        def __get_message_grouping(self):          return (              _getscopeattr(self, Gui.__MESSAGE_GROUPING_NAME)              if _hasscopeattr(self, Gui.__MESSAGE_GROUPING_NAME)              else None          )        def __enter__(self):          self.__hold_messages()          return self        def __exit__(self, exc_type, exc_value, traceback):          try:              self.__send_messages()          except Exception as e:  # pragma: no cover              _warn(\"Exception raised while sending messages\", e)          if exc_value:  # pragma: no cover              _warn(f\"An {exc_type or 'Exception'} was raised\", exc_value)          return True        def __hold_messages(self):          grouping_message = self.__get_message_grouping()          if grouping_message is None:              self._bind_var_val(Gui.__MESSAGE_GROUPING_NAME, [])        def __send_messages(self):          grouping_message = self.__get_message_grouping()          if grouping_message is not None:              _delscopeattr(self, Gui.__MESSAGE_GROUPING_NAME)              if len(grouping_message):                  self.__send_ws({\"type\": _WsType.MULTIPLE_MESSAGE.value, \"payload\": grouping_message})        def _get_user_function(self, func_name: str) -> t.Union[t.Callable, str]:          func = _getscopeattr(self, func_name, None)          if not callable(func):              func = self._get_locals_bind().get(func_name)          if not callable(func):              func = self.__locals_context.get_default().get(func_name)          return func if callable(func) else func_name        def _get_user_instance(self, class_name: str, class_type: type) -> t.Union[object, str]:          cls = _getscopeattr(self, class_name, None)          if not isinstance(cls, class_type):              cls = self._get_locals_bind().get(class_name)          if not isinstance(cls, class_type):              cls = self.__locals_context.get_default().get(class_name)          return cls if isinstance(cls, class_type) else class_name        def __on_action(self, id: t.Optional[str], payload: t.Any) -> None:          if isinstance(payload, dict):              action = payload.get(\"action\")          else:              action = str(payload)              payload = {\"action\": action}          if action:              if self.__call_function_with_args(action_function=self._get_user_function(action), id=id, payload=payload):                  return              else:  # pragma: no cover                  _warn(f\"on_action(): '{action}' is not a valid function.\")          if hasattr(self, \"on_action\"):              self.__call_function_with_args(action_function=self.on_action, id=id, payload=payload)        def __call_function_with_args(self, **kwargs):          action_function = kwargs.get(\"action_function\")          id = kwargs.get(\"id\")          payload = kwargs.get(\"payload\")            if callable(action_function):              try:                  argcount = action_function.__code__.co_argcount                  if argcount > 0 and inspect.ismethod(action_function):                      argcount -= 1                  args = [None for _ in range(argcount)]                  if argcount > 0:                      args[0] = self.__get_state()                  if argcount > 1:                      try:                          args[1] = self._get_real_var_name(id)[0]                      except Exception:                          args[1] = id                  if argcount > 2:                      args[2] = payload                  action_function(*args)                  return True              except Exception as e:  # pragma: no cover                  if not self._call_on_exception(action_function.__name__, e):                      _warn(f\"on_action(): Exception raised in '{action_function.__name__}()'\", e)          return False        def _call_function_with_state(self, user_function: t.Callable, args: t.List[t.Any]) -> t.Any:          args.insert(0, self.__get_state())          argcount = user_function.__code__.co_argcount          if argcount > 0 and inspect.ismethod(user_function):              argcount -= 1          if argcount > len(args):              args += (argcount - len(args)) * [None]          else:              args = args[:argcount]          return user_function(*args)        def _set_module_context(self, module_context: t.Optional[str]) -> t.ContextManager[None]:          return self._set_locals_context(module_context) if module_context is not None else contextlib.nullcontext()        def _call_user_callback(          self, state_id: t.Optional[str], user_callback: t.Callable, args: t.List[t.Any], module_context: t.Optional[str]      ) -> t.Any:          try:              with self.get_flask_app().app_context():                  self.__set_client_id_in_context(state_id)                  with self._set_module_context(module_context):                      return self._call_function_with_state(user_callback, args)          except Exception as e:  # pragma: no cover              if not self._call_on_exception(user_callback.__name__, e):                  _warn(f\"invoke_callback(): Exception raised in '{user_callback.__name__}()'\", e)          return None        def _call_broadcast_callback(          self, user_callback: t.Callable, args: t.List[t.Any], module_context: t.Optional[str]      ) -> t.Any:          @contextlib.contextmanager          def _broadcast_callback() -> t.Iterator[None]:              try:                  setattr(g, Gui.__BRDCST_CALLBACK_G_ID, True)                  yield              finally:                  setattr(g, Gui.__BRDCST_CALLBACK_G_ID, False)            with _broadcast_callback():              # Use global scopes for broadcast callbacks              return self._call_user_callback(_DataScopes._GLOBAL_ID, user_callback, args, module_context)        def _is_in_brdcst_callback(self):          try:              return getattr(g, Gui.__BRDCST_CALLBACK_G_ID, False)          except RuntimeError:              return False        # Proxy methods for Evaluator      def _evaluate_expr(self, expr: str) -> t.Any:          return self.__evaluator.evaluate_expr(self, expr)        def _re_evaluate_expr(self, var_name: str) -> t.Set[str]:          return self.__evaluator.re_evaluate_expr(self, var_name)        def _refresh_expr(self, var_name: str, holder: t.Optional[_TaipyBase]):          return self.__evaluator.refresh_expr(self, var_name, holder)        def _get_expr_from_hash(self, hash_val: str) -> str:          return self.__evaluator.get_expr_from_hash(hash_val)        def _evaluate_bind_holder(self, holder: t.Type[_TaipyBase], expr: str) -> str:          return self.__evaluator.evaluate_bind_holder(self, holder, expr)        def _evaluate_holders(self, expr: str) -> t.List[str]:          return self.__evaluator.evaluate_holders(self, expr)        def _is_expression(self, expr: str) -> bool:          if self.__evaluator is None:              return False          return self.__evaluator._is_expression(expr)        # make components resettable      def _set_building(self, building: bool):          self._building = building        def __is_building(self):          return hasattr(self, \"_building\") and self._building        def _get_rebuild_fn_name(self, name: str):          return f\"{Gui.__SELF_VAR}.{name}\"        def __get_attributes(self, attr_json: str, hash_json: str, args_dict: t.Dict[str, t.Any]):          attributes: t.Dict[str, t.Any] = json.loads(unquote(attr_json))          hashes: t.Dict[str, str] = json.loads(unquote(hash_json))          attributes.update({k: args_dict.get(v) for k, v in hashes.items()})          return attributes, hashes        def _tbl_cols(          self, rebuild: bool, rebuild_val: t.Optional[bool], attr_json: str, hash_json: str, **kwargs      ) -> t.Union[str, _DoNotUpdate]:          if not self.__is_building():              try:                  rebuild = rebuild_val if rebuild_val is not None else rebuild                  if rebuild:                      attributes, hashes = self.__get_attributes(attr_json, hash_json, kwargs)                      data_hash = hashes.get(\"data\", \"\")                      data = kwargs.get(data_hash)                      col_dict = _get_columns_dict(                          data,                          attributes.get(\"columns\", {}),                          self._accessors._get_col_types(data_hash, _TaipyData(data, data_hash)),                          attributes.get(\"date_format\"),                          attributes.get(\"number_format\"),                      )                      _enhance_columns(attributes, hashes, col_dict, \"table(cols)\")                        return json.dumps(col_dict, cls=_TaipyJsonEncoder)              except Exception as e:  # pragma: no cover                  _warn(\"Exception while rebuilding table columns\", e)          return Gui.__DO_NOT_UPDATE_VALUE        def _chart_conf(          self, rebuild: bool, rebuild_val: t.Optional[bool], attr_json: str, hash_json: str, **kwargs      ) -> t.Union[str, _DoNotUpdate]:          if not self.__is_building():              try:                  rebuild = rebuild_val if rebuild_val is not None else rebuild                  if rebuild:                      attributes, hashes = self.__get_attributes(attr_json, hash_json, kwargs)                      data_hash = hashes.get(\"data\", \"\")                      config = _build_chart_config(                          self,                          attributes,                          self._accessors._get_col_types(data_hash, _TaipyData(kwargs.get(data_hash), data_hash)),                      )                        return json.dumps(config, cls=_TaipyJsonEncoder)              except Exception as e:  # pragma: no cover                  _warn(\"Exception while rebuilding chart config\", e)          return Gui.__DO_NOT_UPDATE_VALUE        # Proxy methods for Adapter        def _add_adapter_for_type(self, type_name: str, adapter: t.Callable) -> None:          self.__adapter._add_for_type(type_name, adapter)        def _add_type_for_var(self, var_name: str, type_name: str) -> None:          self.__adapter._add_type_for_var(var_name, type_name)        def _get_adapter_for_type(self, type_name: str) -> t.Optional[t.Callable]:          return self.__adapter._get_for_type(type_name)        def _get_unique_type_adapter(self, type_name: str) -> str:          return self.__adapter._get_unique_type(type_name)        def _run_adapter(          self, adapter: t.Optional[t.Callable], value: t.Any, var_name: str, id_only=False      ) -> t.Union[t.Tuple[str, ...], str, None]:          return self.__adapter._run(adapter, value, var_name, id_only)        def _get_valid_adapter_result(self, value: t.Any, id_only=False) -> t.Union[t.Tuple[str, ...], str, None]:          return self.__adapter._get_valid_result(value, id_only)        def _is_ui_blocked(self):          return _getscopeattr(self, Gui.__UI_BLOCK_NAME, False)        def __get_on_cancel_block_ui(self, callback: t.Optional[str]):          def _taipy_on_cancel_block_ui(guiApp, id: t.Optional[str], payload: t.Any):              if _hasscopeattr(guiApp, Gui.__UI_BLOCK_NAME):                  _setscopeattr(guiApp, Gui.__UI_BLOCK_NAME, False)              guiApp.__on_action(id, {\"action\": callback})            return _taipy_on_cancel_block_ui        def __add_pages_in_folder(self, folder_name: str, folder_path: str):          from ._renderers import Html, Markdown            list_of_files = os.listdir(folder_path)          for file_name in list_of_files:              if file_name.startswith(\"__\"):                  continue              if (re_match := Gui.__RE_HTML.match(file_name)) and f\"{re_match.group(1)}.py\" not in list_of_files:                  _renderers = Html(os.path.join(folder_path, file_name), frame=None)                  _renderers.modify_taipy_base_url(folder_name)                  self.add_page(name=f\"{folder_name}/{re_match.group(1)}\", page=_renderers)              elif (re_match := Gui.__RE_MD.match(file_name)) and f\"{re_match.group(1)}.py\" not in list_of_files:                  _renderers_md = Markdown(os.path.join(folder_path, file_name), frame=None)                  self.add_page(name=f\"{folder_name}/{re_match.group(1)}\", page=_renderers_md)              elif re_match := Gui.__RE_PY.match(file_name):                  module_name = re_match.group(1)                  module_path = os.path.join(folder_name, module_name).replace(os.path.sep, \".\")                  try:                      module = importlib.import_module(module_path)                      page_instance = _get_page_from_module(module)                      if page_instance is not None:                          self.add_page(name=f\"{folder_name}/{module_name}\", page=page_instance)                  except Exception as e:                      _warn(f\"Error while importing module '{module_path}'\", e)              elif os.path.isdir(child_dir_path := os.path.join(folder_path, file_name)):                  child_dir_name = f\"{folder_name}/{file_name}\"                  self.__add_pages_in_folder(child_dir_name, child_dir_path)        # Proxy methods for LocalsContext      def _get_locals_bind(self) -> t.Dict[str, t.Any]:          return self.__locals_context.get_locals()        def _get_default_locals_bind(self) -> t.Dict[str, t.Any]:          return self.__locals_context.get_default()        def _get_locals_bind_from_context(self, context: t.Optional[str]) -> t.Dict[str, t.Any]:          return self.__locals_context._get_locals_bind_from_context(context)        def _get_locals_context(self) -> str:          current_context = self.__locals_context.get_context()          return current_context if current_context is not None else self.__default_module_name        def _set_locals_context(self, context: t.Optional[str]) -> t.ContextManager[None]:          return self.__locals_context.set_locals_context(context)        def _get_page_context(self, page_name: str) -> str | None:          if page_name not in self._config.routes:              return None          page = None          for p in self._config.pages:              if p._route == page_name:                  page = p          if page is None:              return None          return (              (page._renderer._get_module_name() or self.__default_module_name)              if page._renderer is not None              else self.__default_module_name          )        @staticmethod      def _get_root_page_name():          return Gui.__root_page_name        def _set_flask(self, flask: Flask):          self._flask = flask        def _get_default_module_name(self):          return self.__default_module_name        @staticmethod      def _get_timezone() -> str:          return Gui.__LOCAL_TZ        @staticmethod      def _set_timezone(tz: str):          Gui.__LOCAL_TZ = tz        # Public methods      def add_page(          self,          name: str,          page: t.Union[str, Page],          style: t.Optional[str] = \"\",      ) -> None:          \"\"\"Add a page to the Graphical User Interface.            Arguments:              name: The name of the page.              page (Union[str, Page^]): The content of the page.<br/>                  It can be an instance of `Markdown^` or `Html^`.<br/>                  If *page* is a string, then:                    - If *page* is set to the pathname of a readable file, the page                    content is read as Markdown input text.                  - If it is not, the page content is read from this string as                    Markdown text.              style (Optional[str]): Additional CSS style to apply to this page.                    - if there is style associated with a page, it is used at a global level                  - if there is no style associated with the page, the style is cleared at a global level                  - if the page is embedded in a block control, the style is ignored            Note that page names cannot start with the slash ('/') character and that each          page must have a unique name.          \"\"\"          # Validate name          if name is None:  # pragma: no cover              raise Exception(\"name is required for add_page() function.\")          if not Gui.__RE_PAGE_NAME.match(name):  # pragma: no cover              raise SyntaxError(                  f'Page name \"{name}\" is invalid. It must only contain letters, digits, dash (-), underscore (_), and forward slash (/) characters.'              )          if name.startswith(\"/\"):  # pragma: no cover              raise SyntaxError(f'Page name \"{name}\" cannot start with forward slash (/) character.')          if name in self._config.routes:  # pragma: no cover              raise Exception(f'Page name \"{name if name != Gui.__root_page_name else \"/\"}\" is already defined.')          if isinstance(page, str):              from ._renderers import Markdown                page = Markdown(page, frame=None)          elif not isinstance(page, Page):  # pragma: no cover              raise Exception(                  f'Parameter \"page\" is invalid for page name \"{name if name != Gui.__root_page_name else \"/\"}.'              )          # Init a new page          new_page = _Page()          new_page._route = name          new_page._renderer = page          new_page._style = style          # Append page to _config          self._config.pages.append(new_page)          self._config.routes.append(name)          # set root page          if name == Gui.__root_page_name:              self._config.root_page = new_page          # Update locals context          self.__locals_context.add(page._get_module_name(), page._get_locals())          # Update variable directory          if not page._is_class_module():              self.__var_dir.add_frame(page._frame)        def add_pages(self, pages: t.Optional[t.Union[t.Mapping[str, t.Union[str, Page]], str]] = None) -> None:          \"\"\"Add several pages to the Graphical User Interface.            Arguments:              pages (Union[dict[str, Union[str, Page^]], str]): The pages to add.<br/>                  If *pages* is a dictionary, a page is added to this `Gui` instance                  for each of the entries in *pages*:                    - The entry key is used as the page name.                  - The entry value is used as the page content:                      - The value can can be an instance of `Markdown^` or `Html^`, then                        it is used as the page definition.                      - If entry value is a string, then:                          - If it is set to the pathname of a readable file, the page                            content is read as Markdown input text.                          - If it is not, the page content is read from this string as                            Markdown text.            !!! note \"Reading pages from a directory\"              If *pages* is a string that holds the path to a readable directory, then              this directory is traversed, recursively, to find files that Taipy can build              pages from.                For every new directory that is traversed, a new hierarchical level              for pages is created.                For every file that is found:                - If the filename extension is *.md*, it is read as Markdown content and                a new page is created with the base name of this filename.              - If the filename extension is *.html*, it is read as HTML content and                a new page is created with the base name of this filename.                For example, say you have the following directory structure:              ```              reports              \u251c\u2500\u2500 home.html              \u251c\u2500\u2500 budget/              \u2502   \u251c\u2500\u2500 expenses/              \u2502   \u2502   \u251c\u2500\u2500 marketing.md              \u2502   \u2502   \u2514\u2500\u2500 production.md              \u2502   \u2514\u2500\u2500 revenue/              \u2502       \u251c\u2500\u2500 EMAE.md              \u2502       \u251c\u2500\u2500 USA.md              \u2502       \u2514\u2500\u2500 ASIA.md              \u2514\u2500\u2500 cashflow/                  \u251c\u2500\u2500 weekly.md                  \u251c\u2500\u2500 monthly.md                  \u2514\u2500\u2500 yearly.md              ```                Calling `gui.add_pages('reports')` is equivalent to calling:              ```py              gui.add_pages({                              \"reports/home\", Html(\"reports/home.html\"),                              \"reports/budget/expenses/marketing\", Markdown(\"reports/budget/expenses/marketing.md\"),                              \"reports/budget/expenses/production\", Markdown(\"reports/budget/expenses/production.md\"),                              \"reports/budget/revenue/EMAE\", Markdown(\"reports/budget/revenue/EMAE.md\"),                              \"reports/budget/revenue/USA\", Markdown(\"reports/budget/revenue/USA.md\"),                              \"reports/budget/revenue/ASIA\", Markdown(\"reports/budget/revenue/ASIA.md\"),                              \"reports/cashflow/weekly\", Markdown(\"reports/cashflow/weekly.md\"),                              \"reports/cashflow/monthly\", Markdown(\"reports/cashflow/monthly.md\"),                              \"reports/cashflow/yearly\", Markdown(\"reports/cashflow/yearly.md\")              })              ```          \"\"\"          if isinstance(pages, dict):              for k, v in pages.items():                  if k == \"/\":                      k = Gui.__root_page_name                  self.add_page(name=k, page=v)          elif isinstance(folder_name := pages, str):              if not hasattr(self, \"_root_dir\"):                  self._root_dir = os.path.dirname(inspect.getabsfile(self.__frame))              folder_path = folder_name if os.path.isabs(folder_name) else os.path.join(self._root_dir, folder_name)              folder_name = os.path.basename(folder_path)              if not os.path.isdir(folder_path):  # pragma: no cover                  raise RuntimeError(f\"Path {folder_path} is not a valid directory\")              if folder_name in self.__directory_name_of_pages:  # pragma: no cover                  raise Exception(f\"Base directory name {folder_name} of path {folder_path} is not unique\")              if folder_name in Gui.__reserved_routes:  # pragma: no cover                  raise Exception(f\"Invalid directory. Directory {folder_name} is a reserved route\")              self.__directory_name_of_pages.append(folder_name)              self.__add_pages_in_folder(folder_name, folder_path)        # partials        def add_partial(          self,          page: t.Union[str, Page],      ) -> Partial:          \"\"\"Create a new `Partial^`.            The [User Manual section on Partials](../gui/pages/index.md#partials) gives details on          when and how to use this class.            Arguments:              page (Union[str, Page^]): The page to create a new Partial from.<br/>                  It can be an instance of `Markdown^` or `Html^`.<br/>                  If *page* is a string, then:                    - If *page* is set to the pathname of a readable file, the content of                    the new `Partial` is read as Markdown input text.                  - If it is not, the content of the new `Partial` is read from this string                    as Markdown text.            Returns:              The new `Partial` object defined by *page*.          \"\"\"          new_partial = Partial()          # Validate name          if (              new_partial._route in self._config.partial_routes or new_partial._route in self._config.routes          ):  # pragma: no cover              _warn(f'Partial name \"{new_partial._route}\" is already defined.')          if isinstance(page, str):              from ._renderers import Markdown                page = Markdown(page, frame=None)          elif not isinstance(page, Page):  # pragma: no cover              raise Exception(f'Partial name \"{new_partial._route}\" has an invalid Page.')          new_partial._renderer = page          # Append partial to _config          self._config.partials.append(new_partial)          self._config.partial_routes.append(str(new_partial._route))          # Update locals context          self.__locals_context.add(page._get_module_name(), page._get_locals())          # Update variable directory          self.__var_dir.add_frame(page._frame)          return new_partial        def _update_partial(self, partial: Partial):          partials = _getscopeattr(self, Partial._PARTIALS, {})          partials[partial._route] = partial          _setscopeattr(self, Partial._PARTIALS, partials)          self.__send_ws_partial(str(partial._route))        def _get_partial(self, route: str) -> t.Optional[Partial]:          partials = _getscopeattr(self, Partial._PARTIALS, {})          partial = partials.get(route)          if partial is None:              partial = next((p for p in self._config.partials if p._route == route), None)          return partial        # Main binding method (bind in markdown declaration)      def _bind_var(self, var_name: str) -> str:          bind_context = None          if var_name in self._get_locals_bind().keys():              bind_context = self._get_locals_context()          if bind_context is None:              encoded_var_name = self.__var_dir.add_var(var_name, self._get_locals_context(), var_name)          else:              encoded_var_name = self.__var_dir.add_var(var_name, bind_context)          if not hasattr(self._bindings(), encoded_var_name):              bind_locals = self._get_locals_bind_from_context(bind_context)              if var_name in bind_locals.keys():                  self._bind(encoded_var_name, bind_locals[var_name])              else:                  _warn(                      f\"Variable '{var_name}' is not available in either the '{self._get_locals_context()}' or '__main__' modules.\"                  )          return encoded_var_name        def _bind_var_val(self, var_name: str, value: t.Any) -> bool:          if _MODULE_ID not in var_name:              var_name = self.__var_dir.add_var(var_name, self._get_locals_context())          if not hasattr(self._bindings(), var_name):              self._bind(var_name, value)              return True          return False        def __bind_local_func(self, name: str):          func = getattr(self, name, None)          if func is not None and not callable(func):  # pragma: no cover              _warn(f\"{self.__class__.__name__}.{name}: {func} should be a function; looking for {name} in the script.\")              func = None          if func is None:              func = self._get_locals_bind().get(name)          if func is not None:              if callable(func):                  setattr(self, name, func)              else:  # pragma: no cover                  _warn(f\"{name}: {func} should be a function.\")        def load_config(self, config: Config) -> None:          self._config._load(config)        def _broadcast(self, name: str, value: t.Any):          \"\"\"NOT UNDOCUMENTED          Send the new value of a variable to all connected clients.            Arguments:              name: The name of the variable to update or create.              value: The value (must be serializable to the JSON format).          \"\"\"          self.__send_ws_broadcast(name, value)        def _broadcast_all_clients(self, name: str, value: t.Any):          try:              self._set_broadcast()              self._update_var(name, value)          finally:              self._set_broadcast(False)        def _set_broadcast(self, broadcast: bool = True):          with contextlib.suppress(RuntimeError):              setattr(g, Gui.__BROADCAST_G_ID, broadcast)        def _is_broadcasting(self) -> bool:          try:              return getattr(g, Gui.__BROADCAST_G_ID, False)          except RuntimeError:              return False        def _download(          self, content: t.Any, name: t.Optional[str] = \"\", on_action: t.Optional[t.Union[str, t.Callable]] = \"\"      ):          if callable(on_action) and on_action.__name__:              on_action_name = (                  _get_expr_var_name(str(on_action.__code__))                  if on_action.__name__ == \"<lambda>\"                  else _get_expr_var_name(on_action.__name__)              )              if on_action_name:                  self._bind_var_val(on_action_name, on_action)                  on_action = on_action_name              else:                  _warn(\"download() on_action is invalid.\")          content_str = self._get_content(\"Gui.download\", content, False)          self.__send_ws_download(content_str, str(name), str(on_action))        def _notify(          self,          notification_type: str = \"I\",          message: str = \"\",          system_notification: t.Optional[bool] = None,          duration: t.Optional[int] = None,      ):          self.__send_ws_alert(              notification_type,              message,              self._get_config(\"system_notification\", False) if system_notification is None else system_notification,              self._get_config(\"notification_duration\", 3000) if duration is None else duration,          )        def _hold_actions(          self,          callback: t.Optional[t.Union[str, t.Callable]] = None,          message: t.Optional[str] = \"Work in Progress...\",      ):  # pragma: no cover          action_name = callback.__name__ if callable(callback) else callback          # TODO: what if lambda? (it does work)          func = self.__get_on_cancel_block_ui(action_name)          def_action_name = func.__name__          _setscopeattr(self, def_action_name, func)            if _hasscopeattr(self, Gui.__UI_BLOCK_NAME):              _setscopeattr(self, Gui.__UI_BLOCK_NAME, True)          else:              self._bind(Gui.__UI_BLOCK_NAME, True)          self.__send_ws_block(action=def_action_name, message=message, cancel=bool(action_name))        def _resume_actions(self):  # pragma: no cover          if _hasscopeattr(self, Gui.__UI_BLOCK_NAME):              _setscopeattr(self, Gui.__UI_BLOCK_NAME, False)          self.__send_ws_block(close=True)        def _navigate(          self,          to: t.Optional[str] = \"\",          params: t.Optional[t.Dict[str, str]] = None,          tab: t.Optional[str] = None,          force: t.Optional[bool] = False,      ):          to = to or Gui.__root_page_name          if not to.startswith(\"/\") and to not in self._config.routes and not urlparse(to).netloc:              _warn(f'Cannot navigate to \"{to if to != Gui.__root_page_name else \"/\"}\": unknown page.')              return False          self.__send_ws_navigate(to if to != Gui.__root_page_name else \"/\", params, tab, force or False)          return True        def __init_libs(self):          for name, libs in self.__extensions.items():              for lib in libs:                  if not isinstance(lib, ElementLibrary):                      continue                  try:                      self._call_function_with_state(lib.on_user_init, [])                  except Exception as e:  # pragma: no cover                      if not self._call_on_exception(f\"{name}.on_user_init\", e):                          _warn(f\"Exception raised in {name}.on_user_init()\", e)        def __init_route(self):          self.__set_client_id_in_context(force=True)          if not _hasscopeattr(self, Gui.__ON_INIT_NAME):              _setscopeattr(self, Gui.__ON_INIT_NAME, True)              self.__pre_render_pages()              self.__init_libs()              if hasattr(self, \"on_init\") and callable(self.on_init):                  try:                      self._call_function_with_state(self.on_init, [])                  except Exception as e:  # pragma: no cover                      if not self._call_on_exception(\"on_init\", e):                          _warn(\"Exception raised in on_init()\", e)          return self._render_route()        def _call_on_exception(self, function_name: str, exception: Exception) -> bool:          if hasattr(self, \"on_exception\") and callable(self.on_exception):              try:                  self.on_exception(self.__get_state(), str(function_name), exception)              except Exception as e:  # pragma: no cover                  _warn(\"Exception raised in on_exception()\", e)              return True          return False        def __call_on_status(self) -> t.Optional[str]:          if hasattr(self, \"on_status\") and callable(self.on_status):              try:                  return self.on_status(self.__get_state())              except Exception as e:  # pragma: no cover                  if not self._call_on_exception(\"on_status\", e):                      _warn(\"Exception raised in on_status\", e)          return None        def __pre_render_pages(self) -> None:          \"\"\"Pre-render all pages to have a proper initialization of all variables\"\"\"          self.__set_client_id_in_context()          for page in self._config.pages:              if page is not None:                  with contextlib.suppress(Exception):                      page.render(self)        def __render_page(self, page_name: str) -> t.Any:          self.__set_client_id_in_context()          nav_page = page_name          if hasattr(self, \"on_navigate\") and callable(self.on_navigate):              try:                  if self.on_navigate.__code__.co_argcount == 2:                      nav_page = self.on_navigate(self.__get_state(), page_name)                  else:                      params = request.args.to_dict() if hasattr(request, \"args\") else {}                      params.pop(\"client_id\", None)                      params.pop(\"v\", None)                      nav_page = self.on_navigate(self.__get_state(), page_name, params)                  if nav_page != page_name:                      if isinstance(nav_page, str):                          if self._navigate(nav_page):                              return (\"Root page cannot be re-routed by on_navigate().\", 302)                      else:                          _warn(f\"on_navigate() returned an invalid page name '{nav_page}'.\")                      nav_page = page_name              except Exception as e:  # pragma: no cover                  if not self._call_on_exception(\"on_navigate\", e):                      _warn(\"Exception raised in on_navigate()\", e)          page = next((page_i for page_i in self._config.pages if page_i._route == nav_page), None)            # Try partials          if page is None:              page = self._get_partial(nav_page)          # Make sure that there is a page instance found          if page is None:              return (                  jsonify({\"error\": f\"Page '{nav_page}' doesn't exist.\"}),                  400,                  {\"Content-Type\": \"application/json; charset=utf-8\"},              )          context = page.render(self)          if (              nav_page == Gui.__root_page_name              and page._rendered_jsx is not None              and \"<PageContent\" not in page._rendered_jsx          ):              page._rendered_jsx += \"<PageContent />\"          # Return jsx page          if page._rendered_jsx is not None:              return self._server._render(                  page._rendered_jsx, page._style if page._style is not None else \"\", page._head, context              )          else:              return (\"No page template\", 404)        def _render_route(self) -> t.Any:          return self._server._direct_render_json(              {                  \"locations\": {                      \"/\" if route == Gui.__root_page_name else f\"/{route}\": f\"/{route}\" for route in self._config.routes                  },                  \"blockUI\": self._is_ui_blocked(),              }          )        def _register_data_accessor(self, data_accessor_class: t.Type[_DataAccessor]) -> None:          self._accessors._register(data_accessor_class)        def get_flask_app(self) -> Flask:          \"\"\"Get the internal Flask application.            This method must be called **after** `(Gui.)run()^` was invoked.            Returns:              The Flask instance used.          \"\"\"          if hasattr(self, \"_server\"):              return self._server.get_flask()          raise RuntimeError(\"get_flask_app() cannot be invoked before run() has been called.\")        def _set_frame(self, frame: FrameType):          if not isinstance(frame, FrameType):  # pragma: no cover              raise RuntimeError(\"frame must be a FrameType where Gui can collect the local variables.\")          self.__frame = frame          self.__default_module_name = _get_module_name_from_frame(self.__frame)        def _set_css_file(self, css_file: t.Optional[str] = None):          if css_file is None:              script_file = pathlib.Path(self.__frame.f_code.co_filename or \".\").resolve()              if script_file.with_suffix(\".css\").exists():                  css_file = f\"{script_file.stem}.css\"              elif script_file.is_dir() and (script_file / \"taipy.css\").exists():                  css_file = \"taipy.css\"          self.__css_file = css_file        def _set_state(self, state: State):          if isinstance(state, State):              self.__state = state        def __get_client_config(self) -> t.Dict[str, t.Any]:          config = {              \"timeZone\": self._config.get_time_zone(),              \"darkMode\": self._get_config(\"dark_mode\", True),              \"baseURL\": self._config._get_config(\"base_url\", \"/\"),          }          if themes := self._get_themes():              config[\"themes\"] = themes          if len(self.__extensions):              config[\"extensions\"] = {}              for libs in self.__extensions.values():                  for lib in libs:                      config[\"extensions\"][f\"./{Gui._EXTENSION_ROOT}/{lib.get_js_module_name()}\"] = [  # type: ignore                          e._get_js_name(n)                          for n, e in lib.get_elements().items()                          if isinstance(e, Element) and not e._is_server_only()                      ]          if stylekit := self._get_config(\"stylekit\", _default_stylekit):              config[\"stylekit\"] = {_to_camel_case(k): v for k, v in stylekit.items()}          return config        def __get_css_vars(self) -> str:          css_vars = []          if stylekit := self._get_config(\"stylekit\", _default_stylekit):              for k, v in stylekit.items():                  css_vars.append(f'--{k.replace(\"_\", \"-\")}:{_get_css_var_value(v)};')          return \" \".join(css_vars)        def __init_server(self):          app_config = self._config.config          # Init server if there is no server          if not hasattr(self, \"_server\"):              self._server = _Server(                  self,                  path_mapping=self._path_mapping,                  flask=self._flask,                  async_mode=app_config[\"async_mode\"],                  allow_upgrades=not app_config[\"notebook_proxy\"],                  server_config=app_config.get(\"server_config\"),              )            # Stop and reinitialize the server if it is still running as a thread          if (_is_in_notebook() or app_config[\"run_in_thread\"]) and hasattr(self._server, \"_thread\"):              self.stop()              self._flask_blueprint = []              self._server = _Server(                  self,                  path_mapping=self._path_mapping,                  flask=self._flask,                  async_mode=app_config[\"async_mode\"],                  allow_upgrades=not app_config[\"notebook_proxy\"],                  server_config=app_config.get(\"server_config\"),              )              self._bindings()._new_scopes()        def __init_ngrok(self):          app_config = self._config.config          if app_config[\"run_server\"] and app_config[\"ngrok_token\"]:  # pragma: no cover              if not util.find_spec(\"pyngrok\"):                  raise RuntimeError(\"Cannot use ngrok as pyngrok package is not installed.\")              ngrok.set_auth_token(app_config[\"ngrok_token\"])              http_tunnel = ngrok.connect(app_config[\"port\"], \"http\")              _TaipyLogger._get_logger().info(f\" * NGROK Public Url: {http_tunnel.public_url}\")        def __bind_default_function(self):          with self.get_flask_app().app_context():              self.__var_dir.process_imported_var()              # bind on_* function if available              self.__bind_local_func(\"on_init\")              self.__bind_local_func(\"on_change\")              self.__bind_local_func(\"on_action\")              self.__bind_local_func(\"on_navigate\")              self.__bind_local_func(\"on_exception\")              self.__bind_local_func(\"on_status\")              self.__bind_local_func(\"on_user_content\")        def __register_blueprint(self):          # add en empty main page if it is not defined          if Gui.__root_page_name not in self._config.routes:              new_page = _Page()              new_page._route = Gui.__root_page_name              new_page._renderer = _EmptyPage()              self._config.pages.append(new_page)              self._config.routes.append(Gui.__root_page_name)            pages_bp = Blueprint(\"taipy_pages\", __name__)          self._flask_blueprint.append(pages_bp)            # server URL Rule for taipy images          images_bp = Blueprint(\"taipy_images\", __name__)          images_bp.add_url_rule(f\"/{Gui.__CONTENT_ROOT}/<path:path>\", view_func=self.__serve_content)          self._flask_blueprint.append(images_bp)            # server URL for uploaded files          upload_bp = Blueprint(\"taipy_upload\", __name__)          upload_bp.add_url_rule(f\"/{Gui.__UPLOAD_URL}\", view_func=self.__upload_files, methods=[\"POST\"])          self._flask_blueprint.append(upload_bp)            # server URL for user content          user_content_bp = Blueprint(\"taipy_user_content\", __name__)          user_content_bp.add_url_rule(f\"/{Gui.__USER_CONTENT_URL}/<path:path>\", view_func=self.__serve_user_content)          self._flask_blueprint.append(user_content_bp)            # server URL for extension resources          extension_bp = Blueprint(\"taipy_extensions\", __name__)          extension_bp.add_url_rule(f\"/{Gui._EXTENSION_ROOT}/<path:path>\", view_func=self.__serve_extension)          scripts = [              s if bool(urlparse(s).netloc) else f\"/{Gui._EXTENSION_ROOT}/{name}/{s}{lib.get_query(s)}\"              for name, libs in Gui.__extensions.items()              for lib in libs              for s in (lib.get_scripts() or [])          ]          styles = [              s if bool(urlparse(s).netloc) else f\"/{Gui._EXTENSION_ROOT}/{name}/{s}{lib.get_query(s)}\"              for name, libs in Gui.__extensions.items()              for lib in libs              for s in (lib.get_styles() or [])          ]          if self._get_config(\"stylekit\", True):              styles.append(\"stylekit/stylekit.css\")          else:              styles.append(\"https://fonts.googleapis.com/css?family=Roboto:300,400,500,700&display=swap\")          if self.__css_file:              styles.append(f\"/{self.__css_file}\")            self._flask_blueprint.append(extension_bp)            _conf_webapp_path = (              pathlib.Path(self._get_config(\"webapp_path\", None)) if self._get_config(\"webapp_path\", None) else None          )          _webapp_path = str((pathlib.Path(__file__).parent / \"webapp\").resolve())          if _conf_webapp_path:              if _conf_webapp_path.is_dir():                  _webapp_path = str(_conf_webapp_path.resolve())                  _warn(f\"Using webapp_path: '{_conf_webapp_path}'.\")              else:  # pragma: no cover                  _warn(                      f\"webapp_path: '{_conf_webapp_path}' is not a valid directory path. Falling back to '{_webapp_path}'.\"                  )            self._flask_blueprint.append(              self._server._get_default_blueprint(                  static_folder=_webapp_path,                  template_folder=_webapp_path,                  title=self._get_config(\"title\", \"Taipy App\"),                  favicon=self._get_config(\"favicon\", \"favicon.png\"),                  root_margin=self._get_config(\"margin\", None),                  scripts=scripts,                  styles=styles,                  version=self.__get_version(),                  client_config=self.__get_client_config(),                  watermark=self._get_config(\"watermark\", None),                  css_vars=self.__get_css_vars(),                  base_url=self._get_config(\"base_url\", \"/\"),              )          )            # Run parse markdown to force variables binding at runtime          pages_bp.add_url_rule(f\"/{Gui.__JSX_URL}/<path:page_name>\", view_func=self.__render_page)            # server URL Rule for flask rendered react-router          pages_bp.add_url_rule(f\"/{Gui.__INIT_URL}\", view_func=self.__init_route)            # Register Flask Blueprint if available          for bp in self._flask_blueprint:              self._server.get_flask().register_blueprint(bp)        def run(          self,          run_server: bool = True,          run_in_thread: bool = False,          async_mode: str = \"gevent\",          **kwargs,      ) -> t.Optional[Flask]:          \"\"\"          Start the server that delivers pages to web clients.            Once you enter `run()`, users can run web browsers and point to the web server          URL that `Gui` serves. The default is to listen to the *localhost* address          (127.0.0.1) on the port number 5000. However, the configuration of this `Gui`          object may impact that (see the          [Configuration](../gui/configuration.md#configuring-the-gui-instance)          section of the User Manual for details).            Arguments:              run_server (bool): Whether or not to run a web server locally.                  If set to *False*, a web server is *not* created and started.              run_in_thread (bool): Whether or not to run a web server in a separated thread.                  If set to *True*, the web server runs is a separated thread.<br/>                  Note that if you are running in an IPython notebook context, the web                  server always runs in a separate thread.              async_mode (str): The asynchronous model to use for the Flask-SocketIO.                  Valid values are:<br/>                    - \"gevent\": Use a [gevent](https://www.gevent.org/servers.html) server.                  - \"threading\": Use the Flask Development Server. This allows the application to use                    the Flask reloader (the *use_reloader* option) and Debug mode (the *debug* option).                  - \"eventlet\": Use an [*eventlet*](https://flask.palletsprojects.com/en/2.2.x/deploying/eventlet/)                    event-driven WSGI server.                    The default value is \"gevent\"<br/>                  Note that only the \"threading\" value provides support for the development reloader                  functionality (*use_reloader* option). Any other value makes the *use_reloader* configuration parameter                  ignored.<br/>                  Also note that setting the *debug* argument to True forces *async_mode* to \"threading\".              **kwargs (dict[str, any]): Additional keyword arguments that configure how this `Gui` is run.                  Please refer to the                  [Configuration section](../gui/configuration.md#configuring-the-gui-instance)                  of the User Manual for more information.            Returns:              The Flask instance if *run_server* is False else None.          \"\"\"          # --------------------------------------------------------------------------------          # The ssl_context argument was removed just after 1.1. It was defined as:          # t.Optional[t.Union[ssl.SSLContext, t.Tuple[str, t.Optional[str]], t.Literal[\"adhoc\"]]] = None          #          # With the doc:          #     ssl_context (Optional[Union[ssl.SSLContext, Tuple[str, Optional[str]], te.Literal['adhoc']]]):          #         Configures TLS to serve over HTTPS. This value can be:          #          #         - An `ssl.SSLContext` object          #         - A `(cert_file, key_file)` tuple to create a typical context          #         - The string \"adhoc\" to generate a temporary self-signed certificate.          #          #         The default value is None.          # --------------------------------------------------------------------------------          app_config = self._config.config            run_root_dir = os.path.dirname(inspect.getabsfile(self.__frame))            # Register _root_dir for abs path          if not hasattr(self, \"_root_dir\"):              self._root_dir = run_root_dir            is_reloading = kwargs.pop(\"_reload\", False)            if not is_reloading:              self.__run_kwargs = kwargs = {                  **kwargs,                  \"run_server\": run_server,                  \"run_in_thread\": run_in_thread,                  \"async_mode\": async_mode,              }            # Load application config from multiple sources (env files, kwargs, command line)          self._config._build_config(run_root_dir, self.__env_filename, kwargs)            self._config.resolve()          TaipyGuiWarning.set_debug_mode(self._get_config(\"debug\", False))            self.__init_server()            self.__init_ngrok()            locals_bind = _filter_locals(self.__frame.f_locals)            self.__locals_context.set_default(locals_bind, self.__default_module_name)            self.__var_dir.set_default(self.__frame)            if self.__state is None or is_reloading:              self.__state = State(self, self.__locals_context.get_all_keys(), self.__locals_context.get_all_context())            if _is_in_notebook():              # Allow gui.state.x in notebook mode              self.state = self.__state            self.__bind_default_function()            # Base global ctx is TaipyHolder classes + script modules and callables          glob_ctx: t.Dict[str, t.Any] = {t.__name__: t for t in _TaipyBase.__subclasses__()}          glob_ctx.update({k: v for k, v in locals_bind.items() if inspect.ismodule(v) or callable(v)})          glob_ctx[Gui.__SELF_VAR] = self            # Call on_init on each library          for name, libs in self.__extensions.items():              for lib in libs:                  if not isinstance(lib, ElementLibrary):                      continue                  try:                      lib_context = lib.on_init(self)                      if (                          isinstance(lib_context, tuple)                          and len(lib_context) > 1                          and isinstance(lib_context[0], str)                          and lib_context[0].isidentifier()                      ):                          if lib_context[0] in glob_ctx:                              _warn(f\"Method {name}.on_init() returned a name already defined '{lib_context[0]}'.\")                          else:                              glob_ctx[lib_context[0]] = lib_context[1]                      elif lib_context:                          _warn(                              f\"Method {name}.on_init() should return a Tuple[str, Any] where the first element must be a valid Python identifier.\"                          )                  except Exception as e:  # pragma: no cover                      if not self._call_on_exception(f\"{name}.on_init\", e):                          _warn(f\"Method {name}.on_init() raised an exception\", e)            # Initiate the Evaluator with the right context          self.__evaluator = _Evaluator(glob_ctx, self.__shared_variables)            self.__register_blueprint()            # Register data accessor communication data format (JSON, Apache Arrow)          self._accessors._set_data_format(_DataFormat.APACHE_ARROW if app_config[\"use_arrow\"] else _DataFormat.JSON)            # Use multi user or not          self._bindings()._set_single_client(bool(app_config[\"single_client\"]))            # Start Flask Server          if not run_server:              return self.get_flask_app()            return self._server.run(              host=app_config[\"host\"],              port=app_config[\"port\"],              debug=app_config[\"debug\"],              use_reloader=app_config[\"use_reloader\"],              flask_log=app_config[\"flask_log\"],              run_in_thread=app_config[\"run_in_thread\"],              allow_unsafe_werkzeug=app_config[\"allow_unsafe_werkzeug\"],              notebook_proxy=app_config[\"notebook_proxy\"],          )        def reload(self):  # pragma: no cover          \"\"\"          Reload the web server.            This function reloads the underlying web server only in the situation where          it was run in a separated thread: the *run_in_thread* parameter to the          `(Gui.)run^` method was set to True, or you are running in an IPython notebook          context.          \"\"\"          if hasattr(self, \"_server\") and hasattr(self._server, \"_thread\") and self._server._is_running:              self._server.stop_thread()              self.run(**self.__run_kwargs, _reload=True)              _TaipyLogger._get_logger().info(\"Gui server has been reloaded.\")        def stop(self):          \"\"\"          Stop the web server.            This function stops the underlying web server only in the situation where          it was run in a separated thread: the *run_in_thread* parameter to the          `(Gui.)run()^` method was set to True, or you are running in an IPython notebook          context.          \"\"\"          if hasattr(self, \"_server\") and hasattr(self._server, \"_thread\") and self._server._is_running:              self._server.stop_thread()              _TaipyLogger._get_logger().info(\"Gui server has been stopped.\") "}
{"text": "import inspect  import typing as t  from contextlib import nullcontext  from operator import attrgetter  from types import FrameType    from flask import has_app_context  from flask.ctx import AppContext    from .utils import _get_module_name_from_frame, _is_in_notebook  from .utils._attributes import _attrsetter    if t.TYPE_CHECKING:      from .gui import Gui      class State:      \"\"\"Accessor to the bound variables from callbacks.        `State` is used when you need to access the value of variables      bound to visual elements (see [Binding](../gui/binding.md)).<br/>      Because each browser connected to the application server may represent and      modify any variable at any moment as the result of user interaction, each      connection holds its own set of variables along with their values. We call      the set of these the application variables the application _state_, as seen      by a given client.        Each callback (see [Callbacks](../gui/callbacks.md)) receives a specific      instance of the `State` class, where you can find all the variables bound to      visual elements in your application.        Note that `State` also is a Python Context Manager: In situations where you      have several variables to update, it is more clear and more efficient to assign      the variable values in a `with` construct:      ```py      def my_callback(state, ...):        ...        with state as s:          s.var1 = value1          s.var2 = value2        ...      ```        You cannot set a variable in the context of a lambda function because Python      prevents any use of the assignment operator.<br/>      You can, however, use the `assign()` method on the state that the lambda function      receives, so you can work around this limitation:        Here is how you could define a button that changes the value of a variable      directly in a page expressed using Markdown:      ```         <|Set variable|button|on_action={lambda s: s.assign(\"var_name\", new_value)}|>      ```      This would be strictly similar to the Markdown line:      ```         <|Set variable|button|on_action=change_variable|>      ```      with the Python code:      ```py      def change_variable(state):          state.var_name = new_value      ```      \"\"\"        __gui_attr = \"_gui\"      __attrs = (          __gui_attr,          \"_user_var_list\",          \"_context_list\",      )      __methods = (          \"assign\",          \"broadcast\",          \"get_gui\",          \"refresh\",          \"_set_context\",          \"_notebook_context\",          \"_get_placeholder\",          \"_set_placeholder\",          \"_get_gui_attr\",          \"_get_placeholder_attrs\",          \"_add_attribute\",      )      __placeholder_attrs = (          \"_taipy_p1\",          \"_current_context\",      )      __excluded_attrs = __attrs + __methods + __placeholder_attrs        def __init__(self, gui: \"Gui\", var_list: t.Iterable[str], context_list: t.Iterable[str]) -> None:          super().__setattr__(State.__attrs[1], list(State.__filter_var_list(var_list, State.__excluded_attrs)))          super().__setattr__(State.__attrs[2], list(context_list))          super().__setattr__(State.__attrs[0], gui)        def get_gui(self) -> \"Gui\":          \"\"\"Return the Gui instance for this state object.            Returns:              Gui: The Gui instance for this state object.          \"\"\"          return super().__getattribute__(State.__gui_attr)        @staticmethod      def __filter_var_list(var_list: t.Iterable[str], excluded_attrs: t.Iterable[str]) -> t.Iterable[str]:          return filter(lambda n: n not in excluded_attrs, var_list)        def __getattribute__(self, name: str) -> t.Any:          if name in State.__methods:              return super().__getattribute__(name)          gui: \"Gui\" = self.get_gui()          if name == State.__gui_attr:              return gui          if name in State.__excluded_attrs:              raise AttributeError(f\"Variable '{name}' is protected and is not accessible.\")          if gui._is_in_brdcst_callback() and (              name not in gui._get_shared_variables() and not gui._bindings()._is_single_client()          ):              raise AttributeError(f\"Variable '{name}' is not available to be accessed in shared callback.\")          if name not in super().__getattribute__(State.__attrs[1]):              raise AttributeError(f\"Variable '{name}' is not defined.\")          with self._notebook_context(gui), self._set_context(gui):              encoded_name = gui._bind_var(name)              return getattr(gui._bindings(), encoded_name)        def __setattr__(self, name: str, value: t.Any) -> None:          gui: \"Gui\" = super().__getattribute__(State.__gui_attr)          if gui._is_in_brdcst_callback() and (              name not in gui._get_shared_variables() and not gui._bindings()._is_single_client()          ):              raise AttributeError(f\"Variable '{name}' is not available to be accessed in shared callback.\")          if name not in super().__getattribute__(State.__attrs[1]):              raise AttributeError(f\"Variable '{name}' is not accessible.\")          with self._notebook_context(gui), self._set_context(gui):              encoded_name = gui._bind_var(name)              setattr(gui._bindings(), encoded_name, value)        def __getitem__(self, key: str):          context = key if key in super().__getattribute__(State.__attrs[2]) else None          if context is None:              gui: \"Gui\" = super().__getattribute__(State.__gui_attr)              page_ctx = gui._get_page_context(key)              context = page_ctx if page_ctx is not None else None          if context is None:              raise RuntimeError(f\"Can't resolve context '{key}' from state object\")          self._set_placeholder(State.__placeholder_attrs[1], context)          return self        def _set_context(self, gui: \"Gui\") -> t.ContextManager[None]:          if (pl_ctx := self._get_placeholder(State.__placeholder_attrs[1])) is not None:              self._set_placeholder(State.__placeholder_attrs[1], None)              if pl_ctx != gui._get_locals_context():                  return gui._set_locals_context(pl_ctx)          if len(inspect.stack()) > 1:              ctx = _get_module_name_from_frame(t.cast(FrameType, t.cast(FrameType, inspect.stack()[2].frame)))              current_context = gui._get_locals_context()              # ignore context if the current one starts with the new one (to resolve for class modules)              if ctx != current_context and not current_context.startswith(str(ctx)):                  return gui._set_locals_context(ctx)          return nullcontext()        def _notebook_context(self, gui: \"Gui\"):          return gui.get_flask_app().app_context() if not has_app_context() and _is_in_notebook() else nullcontext()        def _get_placeholder(self, name: str):          if name in State.__placeholder_attrs:              try:                  return super().__getattribute__(name)              except AttributeError:                  return None          return None        def _set_placeholder(self, name: str, value: t.Any):          if name in State.__placeholder_attrs:              super().__setattr__(name, value)        def _get_placeholder_attrs(self):          return State.__placeholder_attrs        def _add_attribute(self, name: str, default_value: t.Optional[t.Any] = None) -> bool:          attrs: t.List[str] = super().__getattribute__(State.__attrs[1])          if name not in attrs:              attrs.append(name)              gui = super().__getattribute__(State.__gui_attr)              return gui._bind_var_val(name, default_value)          return False        def assign(self, name: str, value: t.Any) -> t.Any:          \"\"\"Assign a value to a state variable.            This should be used only from within a lambda function used          as a callback in a visual element.            Arguments:              name (str): The variable name to assign to.              value (Any): The new variable value.            Returns:              Any: The previous value of the variable.          \"\"\"          val = attrgetter(name)(self)          _attrsetter(self, name, value)          return val        def refresh(self, name: str):          \"\"\"Refresh a state variable.            This allows to re-sync the user interface with a variable value.            Arguments:              name (str): The variable name to refresh.          \"\"\"          val = attrgetter(name)(self)          _attrsetter(self, name, val)        def broadcast(self, name: str, value: t.Any):          \"\"\"Update a variable on all clients.            All connected clients will receive an update of the variable called *name* with the          provided value, even if it is not shared.            Arguments:              name (str): The variable name to update.              value (Any): The new variable value.          \"\"\"          gui: \"Gui\" = super().__getattribute__(State.__gui_attr)          with self._set_context(gui):              encoded_name = gui._bind_var(name)              gui._broadcast_all_clients(encoded_name, value)        def __enter__(self):          super().__getattribute__(State.__attrs[0]).__enter__()          return self        def __exit__(self, exc_type, exc_value, traceback):          return super().__getattribute__(State.__attrs[0]).__exit__(exc_type, exc_value, traceback) "}
{"text": "import re  import sys  import typing as t  import xml.etree.ElementTree as etree  from abc import ABC, abstractmethod  from inspect import isclass  from pathlib import Path  from urllib.parse import urlencode    from .._renderers.builder import _Builder  from .._warnings import _warn  from ..types import PropertyType  from ..utils import _get_broadcast_var_name, _TaipyBase, _to_camel_case    if t.TYPE_CHECKING:      from ..gui import Gui      from ..state import State      class ElementProperty:      \"\"\"      The declaration of a property of a visual element.        Each visual element property is described by an instance of `ElementProperty`.      This class holds the information on the name, type and default value for the      element property.      \"\"\"        def __init__(          self,          property_type: PropertyType,          default_value: t.Optional[t.Any] = None,          js_name: t.Optional[str] = None,      ) -> None:          \"\"\"Initializes a new custom property declaration for an `Element^`.            Arguments:              property_type (PropertyType): The type of this property.              default_value (Optional[Any]): The default value for this property. Default is None.              js_name (Optional[str]): The name of this property, in the front-end JavaScript code.<br/>                  If unspecified, a camel case version of `name` is generated: for example, if `name` is                  \"my_property_name\", then this property is referred to as \"myPropertyName\" in the                  JavaScript code.          \"\"\"          self.default_value = default_value          if property_type == PropertyType.broadcast:              if isinstance(default_value, str):                  self.default_value = _get_broadcast_var_name(default_value)              else:                  _warn(\"Element property with type 'broadcast' must define a string default value.\")              self.property_type = PropertyType.react          else:              self.property_type = property_type          self._js_name = js_name          super().__init__()        def check(self, element_name: str, prop_name: str):          if not isinstance(prop_name, str) or not prop_name or not prop_name.isidentifier():              _warn(f\"Property name '{prop_name}' is invalid for element '{element_name}'.\")          if not isinstance(self.property_type, PropertyType) and not (              isclass(self.property_type) and issubclass(self.property_type, _TaipyBase)          ):              _warn(f\"Property type '{self.property_type}' is invalid for element property '{element_name}.{prop_name}'.\")        def _get_tuple(self, name: str) -> tuple:          return (name, self.property_type, self.default_value)        def get_js_name(self, name: str) -> str:          return self._js_name or _to_camel_case(name)      class Element:      \"\"\"      The definition of a custom visual element.        An element is defined by its properties (name, type and default value) and      what the default property name is.      \"\"\"        __RE_PROP_VAR = re.compile(r\"<tp:prop:(\\w+)>\")        def __init__(          self,          default_property: str,          properties: t.Dict[str, ElementProperty],          react_component: t.Optional[str] = None,          render_xhtml: t.Optional[t.Callable[[t.Dict[str, t.Any]], str]] = None,          inner_properties: t.Optional[t.Dict[str, ElementProperty]] = None,      ) -> None:          \"\"\"Initializes a new custom element declaration.            If *render_xhtml* is specified, then this is a static element, and          *react_component* is ignored.            Arguments:              default_property (str): the name of the default property for this element.              properties (List[ElementProperty]): The list of properties for this element.              inner_properties (Optional[List[ElementProperty]]): The optional list of inner properties for this element.<br/>                  Default values are set/binded automatically.              react_component (Optional[str]): The name of the component to be created on the front-end.<br/>                  If not specified, it is set to a camel case version of the element's name                  (\"one_name\" is transformed to \"OneName\").              render_xhtml (Optional[callable[[dict[str, Any]], str]]): A function that receives a                  dictionary containing the element's properties and their values                  and that must return a valid XHTML string.          \"\"\"          self.default_attribute = default_property          self.attributes = properties          self.inner_properties = inner_properties          self.js_name = react_component          if callable(render_xhtml):              self._render_xhtml = render_xhtml          super().__init__()        def _get_js_name(self, name: str) -> str:          return self.js_name or _to_camel_case(name, True)        def check(self, name: str):          if not isinstance(name, str) or not name or not name.isidentifier():              _warn(f\"Invalid element name: '{name}'.\")          default_found = False          if self.attributes:              for prop_name, property in self.attributes.items():                  if isinstance(property, ElementProperty):                      property.check(name, prop_name)                      if not default_found:                          default_found = self.default_attribute == prop_name                  else:                      _warn(f\"Property must inherit from 'ElementProperty' '{name}.{prop_name}'.\")          if not default_found:              _warn(f\"Element {name} has no default property.\")        def _is_server_only(self):          return hasattr(self, \"_render_xhtml\") and callable(self._render_xhtml)        def _call_builder(          self,          name,          gui: \"Gui\",          properties: t.Optional[t.Dict[str, t.Any]],          lib: \"ElementLibrary\",          is_html: t.Optional[bool] = False,      ) -> t.Union[t.Any, t.Tuple[str, str]]:          attributes = properties if isinstance(properties, dict) else {}          if self.inner_properties:              self.attributes.update(self.inner_properties)              for prop, attr in self.inner_properties.items():                  val = attr.default_value                  if val:                      # handling property replacement in inner properties <tp:prop:...>                      while m := Element.__RE_PROP_VAR.search(val):                          var = attributes.get(m.group(1))                          hash_value = \"None\" if var is None else gui._evaluate_expr(var)                          val = val[: m.start()] + hash_value + val[m.end() :]                  attributes[prop] = val          # this modifies attributes          hash_names = _Builder._get_variable_hash_names(gui, attributes)  # variable replacement          # call user render if any          if self._is_server_only():              xhtml = self._render_xhtml(attributes)              try:                  xml_root = etree.fromstring(xhtml)                  if is_html:                      return xhtml, name                  else:                      return xml_root                except Exception as e:                  _warn(f\"{name}.render_xhtml() did not return a valid XHTML string\", e)                  return f\"{name}.render_xhtml() did not return a valid XHTML string. {e}\"          else:              default_attr: t.Optional[ElementProperty] = None              default_value = None              default_name = None              attrs = []              if self.attributes:                  for prop_name, property in self.attributes.items():                      if isinstance(property, ElementProperty):                          if self.default_attribute == prop_name:                              default_name = prop_name                              default_attr = property                              default_value = property.default_value                          else:                              attrs.append(property._get_tuple(prop_name))              elt_built = _Builder(                  gui=gui,                  control_type=name,                  element_name=f\"{lib.get_js_module_name()}_{self._get_js_name(name)}\",                  attributes=properties,                  hash_names=hash_names,                  lib_name=lib.get_name(),                  default_value=default_value,              )              if default_attr is not None:                  elt_built.set_value_and_default(                      var_name=default_name,                      var_type=default_attr.property_type,                      default_val=default_attr.default_value,                      with_default=default_attr.property_type != PropertyType.data,                  )              elt_built.set_attributes(attrs)              return elt_built._build_to_string() if is_html else elt_built.el      class ElementLibrary(ABC):      \"\"\"      A library of user-defined visual elements.        An element library can declare any number of custom visual elements.        In order to use those elements you must register the element library      using the function `Gui.add_library()^`.        An element library can mix *static* and *dynamic* elements.      \"\"\"        @abstractmethod      def get_elements(self) -> t.Dict[str, Element]:          \"\"\"          Return the dictionary holding all visual element declarations.            The key for each of this dictionary's entry is the name of the element,          and the value is an instance of `Element^`.            The default implementation returns an empty dictionary, indicating that this library          contains no custom visual elements.          \"\"\"          return {}        @abstractmethod      def get_name(self) -> str:          \"\"\"          Return the library name.            This string is used for different purposes:            - It allows for finding the definition of visual elements when parsing the            page content.<br/>            Custom elements are defined with the fragment `<|<library_name>.<element_name>|>` in            Markdown pages, and with the tag `<<library_name>:<element_name>>` in HTML pages.            - In element libraries that hold elements with dynamic properties (where JavaScript)            is involved, the name of the JavaScript module that has the front-end code is            derived from this name, as described in `(ElementLibrary.)get_js_module_name()^`.            Returns:              The name of this element library. This must be a valid Python identifier.            !!! note \"Element libraries with the same name\"              You can add different libraries that have the same name.<br/>              This is useful in large projects where you want to split a potentially large number              of custom visual elements into different groups but still access them from your pages              using the same library name prefix.<br/>              In this situation, you will have to implement `(ElementLibrary.)get_js_module_name()^`              because each JavaScript module will have to have a unique name.            \"\"\"          return NotImplementedError  # type: ignore        def get_js_module_name(self) -> str:          \"\"\"          Return the name of the JavaScript module.            The JavaScript module is the JavaScript file that contains all the front-end          code for this element library. Typically, the name of JavaScript modules uses camel case.<br/>          This module name must be unique on the browser window scope: if your application uses          several custom element libraries, they must define a unique name for their JavaScript module.            The default implementation transforms the return value of `(ElementLibrary.)get_name()^` in          the following manner:            - The JavaScript module name is a camel case version of the element library name            (see `(ElementLibrary.)get_name()^`):              - If the library name is \"library\", the JavaScript module name defaults to \"Library\".              - If the library name is \"myLibrary\", the JavaScript module name defaults to \"Mylibrary\".          - If the element library name has underscore characters, each underscore-separated fragment is            considered as a distinct word:              - If the library name is \"my_library\", the JavaScript module name defaults to \"MyLibrary\".            Returns:              The name of the JavaScript module for this element library.<br/>              The default implementation returns a camel case version of `self.get_name()`,              as described above.          \"\"\"          return _to_camel_case(self.get_name(), True)        def get_scripts(self) -> t.List[str]:          \"\"\"          Return the list of the mandatory script file pathnames.            If a script file pathname is an absolute URL it will be used as is.<br/>          If it's not it will be passed to `(ElementLibrary.)get_resource()^` to retrieve a local          path to the resource.            The default implementation returns an empty list, indicating that this library contains          no custom visual elements with dynamic properties.            Returns:              A list of paths (relative to the element library Python implementation file or              absolute) to all JavaScript module files to be loaded on the front-end.<br/>              The default implementation returns an empty list.          \"\"\"          return []        def get_styles(self) -> t.List[str]:          \"\"\"          TODO          Returns the list of resources names for the css stylesheets.          Defaults to []            \"\"\"          return []        def get_resource(self, name: str) -> Path:          \"\"\"          TODO          Defaults to return None?          Returns a path for a resource name.          Resource URL should be formed as /taipy-extension/<library_name>/<resource virtual path> with(see get_resource_url)          - <resource virtual path> being the `name` parameter          - <library_name> the value returned by `get_name()`            Arguments:              name (str): The name of the resource for which a local Path should be returned.          \"\"\"          module_obj = sys.modules.get(self.__class__.__module__)          base = (Path(\".\") if module_obj is None else Path(module_obj.__file__).parent).resolve()  # type: ignore          base = base if base.exists() else Path(\".\").resolve()          file = (base / name).resolve()          if str(file).startswith(str(base)) and file.exists():              return file          else:              raise FileNotFoundError(f\"Cannot access resource {file}.\")        def get_resource_url(self, resource: str) -> str:          \"\"\"TODO\"\"\"          from ..gui import Gui            return f\"/{Gui._EXTENSION_ROOT}/{self.get_name()}/{resource}{self.get_query(resource)}\"        def get_data(self, library_name: str, payload: t.Dict, var_name: str, value: t.Any) -> t.Optional[t.Dict]:          \"\"\"          TODO          Called if implemented (i.e returns a dict).            Arguments:              library_name (str): The name of this library.              payload (dict): The payload send by the `createRequestDataUpdateAction()` front-end function.              var_name (str): The name of the variable holding the data.              value (any): The current value of the variable identified by *var_name*.          \"\"\"          return None        def on_init(self, gui: \"Gui\") -> t.Optional[t.Tuple[str, t.Any]]:          \"\"\"          Initialize this element library.            This method is invoked by `Gui.run()^`.            It allows to define variables that are accessible from elements          defined in this element library.            Arguments              gui: The `Gui^` instance.            Returns:              An optional tuple composed of a variable name (that *must* be a valid Python              identifier), associated with its value.<br/>              This name can be used as the name of a variable accessible by the elements defined              in this library.<br/>              This name must be unique across the entire application, which is a problem since              different element libraries might use the same symbol. A good development practice              is to make this variable name unique by prefixing it with the name of the element              library itself.          \"\"\"          return None        def on_user_init(self, state: \"State\"):          \"\"\"          Initialize user state on first access.            Arguments              state: The `State^` instance.          \"\"\"          pass        def get_query(self, name: str) -> str:          \"\"\"          Return an URL query depending on the resource name.<br/>          Default implementation returns the version if defined.            Arguments:              name (str): The name of the resource for which a query should be returned.            Returns:              A string that holds the query part of an URL (starting with ?).          \"\"\"          if version := self.get_version():              return f\"?{urlencode({'v': version})}\"          return \"\"        def get_version(self) -> t.Optional[str]:          \"\"\"          The optional library version            Returns:              An optional string representing the library version.<br/>              This version will be appended to the resource URL as a query arg (?v=<version>)          \"\"\"          return None "}
{"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  from enum import Enum    from .._renderers.utils import _get_columns_dict  from .._warnings import _warn  from ..types import PropertyType  from ..utils import _MapDict    if t.TYPE_CHECKING:      from ..gui import Gui      class _Chart_iprops(Enum):      x = 0      y = 1      z = 2      label = 3      text = 4      mode = 5      type = 6      color = 7      xaxis = 8      yaxis = 9      selected_color = 10      marker = 11      selected_marker = 12      orientation = 13      _name = 14      line = 15      text_anchor = 16      options = 17      lon = 18      lat = 19      base = 20      r = 21      theta = 22      close = 23      open = 24      high = 25      low = 26      locations = 27      values = 28      labels = 29      decimator = 30      measure = 31      parents = 32      __CHART_AXIS: t.Dict[str, t.Tuple[_Chart_iprops, ...]] = {      \"bar\": (_Chart_iprops.x, _Chart_iprops.y, _Chart_iprops.base),      \"candlestick\": (          _Chart_iprops.x,          _Chart_iprops.close,          _Chart_iprops.open,          _Chart_iprops.high,          _Chart_iprops.low,      ),      \"choropleth\": (_Chart_iprops.locations, _Chart_iprops.z),      \"densitymapbox\": (_Chart_iprops.lon, _Chart_iprops.lat, _Chart_iprops.z),      \"funnelarea\": (_Chart_iprops.values,),      \"pie\": (_Chart_iprops.values, _Chart_iprops.labels),      \"scattergeo\": (_Chart_iprops.lon, _Chart_iprops.lat),      \"scattermapbox\": (_Chart_iprops.lon, _Chart_iprops.lat),      \"scatterpolar\": (_Chart_iprops.r, _Chart_iprops.theta),      \"scatterpolargl\": (_Chart_iprops.r, _Chart_iprops.theta),      \"treemap\": (_Chart_iprops.labels, _Chart_iprops.parents, _Chart_iprops.values),      \"waterfall\": (_Chart_iprops.x, _Chart_iprops.y, _Chart_iprops.measure),  }  __CHART_DEFAULT_AXIS: t.Tuple[_Chart_iprops, ...] = (_Chart_iprops.x, _Chart_iprops.y, _Chart_iprops.z)  __CHART_MARKER_TO_COLS: t.Tuple[str, ...] = (\"color\", \"size\", \"symbol\", \"opacity\")  __CHART_NO_INDEX: t.Tuple[str, ...] = (\"pie\", \"histogram\", \"heatmap\", \"funnelarea\")  _CHART_NAMES: t.Tuple[str, ...] = tuple(e.name[1:] if e.name[0] == \"_\" else e.name for e in _Chart_iprops)      def __check_dict(values: t.List[t.Any], properties: t.Iterable[_Chart_iprops]) -> None:      for prop in properties:          if values[prop.value] is not None and not isinstance(values[prop.value], (dict, _MapDict)):              _warn(f\"Property {prop.name} of chart control should be a dict.\")              values[prop.value] = None      def __get_multiple_indexed_attributes(      attributes: t.Dict[str, t.Any], names: t.Iterable[str], index: t.Optional[int] = None  ) -> t.List[t.Optional[str]]:      names = names if index is None else [f\"{n}[{index}]\" for n in names]  # type: ignore      return [attributes.get(name) for name in names]      __RE_INDEXED_DATA = re.compile(r\"^(\\d+)\\/(.*)\")      def __get_col_from_indexed(col_name: str, idx: int) -> t.Optional[str]:      if re_res := __RE_INDEXED_DATA.search(col_name):          return col_name if str(idx) == re_res.group(1) else None      return col_name      def _build_chart_config(gui: \"Gui\", attributes: t.Dict[str, t.Any], col_types: t.Dict[str, str]):  # noqa: C901      default_type = attributes.get(\"_default_type\", \"scatter\")      default_mode = attributes.get(\"_default_mode\", \"lines+markers\")      trace = __get_multiple_indexed_attributes(attributes, _CHART_NAMES)      if not trace[_Chart_iprops.mode.value]:          trace[_Chart_iprops.mode.value] = default_mode      # type      if not trace[_Chart_iprops.type.value]:          trace[_Chart_iprops.type.value] = default_type      if not trace[_Chart_iprops.xaxis.value]:          trace[_Chart_iprops.xaxis.value] = \"x\"      if not trace[_Chart_iprops.yaxis.value]:          trace[_Chart_iprops.yaxis.value] = \"y\"      # Indexed properties: Check for arrays      for prop in _Chart_iprops:          values = trace[prop.value]          if isinstance(values, (list, tuple)) and len(values):              prop_name = prop.name[1:] if prop.name[0] == \"_\" else prop.name              for idx, val in enumerate(values):                  if idx == 0:                      trace[prop.value] = val                  if val is not None:                      indexed_prop = f\"{prop_name}[{idx + 1}]\"                      if attributes.get(indexed_prop) is None:                          attributes[indexed_prop] = val      # marker selected_marker options      __check_dict(trace, (_Chart_iprops.marker, _Chart_iprops.selected_marker, _Chart_iprops.options))      axis = []      traces: t.List[t.List[t.Optional[str]]] = []      idx = 1      indexed_trace = __get_multiple_indexed_attributes(attributes, _CHART_NAMES, idx)      if len([x for x in indexed_trace if x]):          while len([x for x in indexed_trace if x]):              axis.append(                  __CHART_AXIS.get(                      indexed_trace[_Chart_iprops.type.value] or trace[_Chart_iprops.type.value] or \"\",                      __CHART_DEFAULT_AXIS,                  )              )              # marker selected_marker options              __check_dict(indexed_trace, (_Chart_iprops.marker, _Chart_iprops.selected_marker, _Chart_iprops.options))              if trace[_Chart_iprops.decimator.value] and not indexed_trace[_Chart_iprops.decimator.value]:                  # copy the decimator only once                  indexed_trace[_Chart_iprops.decimator.value] = trace[_Chart_iprops.decimator.value]                  trace[_Chart_iprops.decimator.value] = None              traces.append([x or trace[i] for i, x in enumerate(indexed_trace)])              idx += 1              indexed_trace = __get_multiple_indexed_attributes(attributes, _CHART_NAMES, idx)      else:          traces.append(trace)          # axis names          axis.append(__CHART_AXIS.get(trace[_Chart_iprops.type.value] or \"\", __CHART_DEFAULT_AXIS))        # list of data columns name indexes with label text      dt_idx = tuple(e.value for e in (axis[0] + (_Chart_iprops.label, _Chart_iprops.text)))        # configure columns      columns: t.Set[str] = set()      for j, trace in enumerate(traces):          dt_idx = tuple(              e.value for e in (axis[j] if j < len(axis) else axis[0]) + (_Chart_iprops.label, _Chart_iprops.text)          )          columns.update([trace[i] or \"\" for i in dt_idx if trace[i]])      # add optionnal column if any      markers = [          t[_Chart_iprops.marker.value]          or ({\"color\": t[_Chart_iprops.color.value]} if t[_Chart_iprops.color.value] else None)          for t in traces      ]      opt_cols = set()      for m in markers:          if isinstance(m, (dict, _MapDict)):              for prop1 in __CHART_MARKER_TO_COLS:                  val = m.get(prop1)                  if isinstance(val, str) and val not in columns:                      opt_cols.add(val)        # Validate the column names      col_dict = _get_columns_dict(attributes.get(\"data\"), list(columns), col_types, opt_columns=opt_cols)        # Manage Decimator      decimators: t.List[t.Optional[str]] = []      for tr in traces:          if tr[_Chart_iprops.decimator.value]:              cls = gui._get_user_instance(                  class_name=str(tr[_Chart_iprops.decimator.value]), class_type=PropertyType.decimator.value              )              if isinstance(cls, PropertyType.decimator.value):                  decimators.append(str(tr[_Chart_iprops.decimator.value]))                  continue          decimators.append(None)        # set default columns if not defined      icols = [[c2 for c2 in [__get_col_from_indexed(c1, i) for c1 in col_dict.keys()] if c2] for i in range(len(traces))]        for i, tr in enumerate(traces):          if i < len(axis):              used_cols = {tr[ax.value] for ax in axis[i] if tr[ax.value]}              unused_cols = [c for c in icols[i] if c not in used_cols]              if unused_cols and not any(tr[ax.value] for ax in axis[i]):                  traces[i] = list(                      v or (unused_cols.pop(0) if unused_cols and _Chart_iprops(j) in axis[i] else v)                      for j, v in enumerate(tr)                  )        if col_dict is not None:          reverse_cols = {str(cd.get(\"dfid\")): c for c, cd in col_dict.items()}            # List used axis          used_axis = [[e for e in (axis[j] if j < len(axis) else axis[0]) if tr[e.value]] for j, tr in enumerate(traces)]            ret_dict = {              \"columns\": col_dict,              \"labels\": [                  reverse_cols.get(tr[_Chart_iprops.label.value] or \"\", (tr[_Chart_iprops.label.value] or \"\"))                  for tr in traces              ],              \"texts\": [                  reverse_cols.get(tr[_Chart_iprops.text.value] or \"\", (tr[_Chart_iprops.text.value] or None))                  for tr in traces              ],              \"modes\": [tr[_Chart_iprops.mode.value] for tr in traces],              \"types\": [tr[_Chart_iprops.type.value] for tr in traces],              \"xaxis\": [tr[_Chart_iprops.xaxis.value] for tr in traces],              \"yaxis\": [tr[_Chart_iprops.yaxis.value] for tr in traces],              \"markers\": markers,              \"selectedMarkers\": [                  tr[_Chart_iprops.selected_marker.value]                  or (                      {\"color\": tr[_Chart_iprops.selected_color.value]}                      if tr[_Chart_iprops.selected_color.value]                      else None                  )                  for tr in traces              ],              \"traces\": [                  [reverse_cols.get(c or \"\", c) for c in [tr[e.value] for e in used_axis[j]]]                  for j, tr in enumerate(traces)              ],              \"orientations\": [tr[_Chart_iprops.orientation.value] for tr in traces],              \"names\": [tr[_Chart_iprops._name.value] for tr in traces],              \"lines\": [                  tr[_Chart_iprops.line.value]                  if isinstance(tr[_Chart_iprops.line.value], (dict, _MapDict))                  else {\"dash\": tr[_Chart_iprops.line.value]}                  if tr[_Chart_iprops.line.value]                  else None                  for tr in traces              ],              \"textAnchors\": [tr[_Chart_iprops.text_anchor.value] for tr in traces],              \"options\": [tr[_Chart_iprops.options.value] for tr in traces],              \"axisNames\": [[e.name for e in ax] for ax in used_axis],              \"addIndex\": [tr[_Chart_iprops.type.value] not in __CHART_NO_INDEX for tr in traces],          }          if len([d for d in decimators if d]):              ret_dict.update(decimators=decimators)          return ret_dict      return {} "}
{"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": "from __future__ import annotations    import typing as t    from .._warnings import _warn  from ..icon import Icon  from . import _MapDict      class _Adapter:      def __init__(self):          self.__adapter_for_type: t.Dict[str, t.Callable] = {}          self.__type_for_variable: t.Dict[str, str] = {}          self.__warning_by_type: t.Set[str] = set()        def _add_for_type(self, type_name: str, adapter: t.Callable) -> None:          self.__adapter_for_type[type_name] = adapter        def _add_type_for_var(self, var_name: str, type_name: str) -> None:          self.__type_for_variable[var_name] = type_name        def _get_for_type(self, type_name: str) -> t.Optional[t.Callable]:          return self.__adapter_for_type.get(type_name)        def _get_unique_type(self, type_name: str) -> str:          index = 0          while type_name in self.__adapter_for_type:              type_name = f\"{type_name}{index}\"              index += 1          return type_name        def _run_for_var(self, var_name: str, value: t.Any, id_only=False) -> t.Any:          ret = self._run(self.__get_for_var(var_name, value), value, var_name, id_only)          return ret if ret is not None else value        def __get_for_var(self, var_name: str, value: t.Any) -> t.Optional[t.Callable]:          adapter = None          type_name = self.__type_for_variable.get(var_name)          if not isinstance(type_name, str):              adapter = self.__adapter_for_type.get(var_name)              type_name = var_name if callable(adapter) else type(value).__name__          if adapter is None:              adapter = self.__adapter_for_type.get(type_name)          return adapter if callable(adapter) else None        def _get_elt_per_ids(self, var_name: str, lov: t.List[t.Any]) -> t.Dict[str, t.Any]:          dict_res = {}          adapter = self.__get_for_var(var_name, lov[0] if lov else None)          for value in lov:              try:                  result = adapter(value._dict if isinstance(value, _MapDict) else value) if adapter else value                  if result is not None:                      dict_res[self.__get_id(result)] = value                      children = self.__get_children(result)                      if children is not None:                          dict_res.update(self._get_elt_per_ids(var_name, children))              except Exception as e:                  _warn(f\"Cannot run adapter for {var_name}\", e)          return dict_res        def _run(          self, adapter: t.Optional[t.Callable], value: t.Any, var_name: str, id_only=False      ) -> t.Union[t.Tuple[str, ...], str, None]:          if value is None:              return None          try:              result = value._dict if isinstance(value, _MapDict) else value              if adapter:                  result = adapter(result)                  if result is None:                      return result              elif isinstance(result, str):                  return result              tpl_res = self._get_valid_result(result, id_only)              if tpl_res is None:                  _warn(                      f\"Adapter for {var_name} did not return a valid result. Please check the documentation on List of Values Adapters.\"                  )              else:                  if not id_only and len(tpl_res) > 2 and isinstance(tpl_res[2], list) and len(tpl_res[2]) > 0:                      tpl_res = (tpl_res[0], tpl_res[1], self.__on_tree(adapter, tpl_res[2]))                  return (                      (tpl_res + result[len(tpl_res) :])                      if isinstance(result, tuple) and isinstance(tpl_res, tuple)                      else tpl_res                  )          except Exception as e:              _warn(f\"Cannot run adapter for {var_name}\", e)          return None        def __on_tree(self, adapter: t.Optional[t.Callable], tree: t.List[t.Any]):          ret_list = []          for elt in tree:              ret = self._run(adapter, elt, adapter.__name__ if adapter else \"adapter\")              if ret is not None:                  ret_list.append(ret)          return ret_list        def _get_valid_result(self, value: t.Any, id_only=False) -> t.Union[t.Tuple[str, ...], str, None]:          id = self.__get_id(value)          if id_only:              return id          label = self.__get_label(value)          if label is None:              return None          children = self.__get_children(value)          return (id, label) if children is None else (id, label, children)  # type: ignore        def __get_id(self, value: t.Any, dig=True) -> str:          if isinstance(value, str):              return value          elif dig:              if isinstance(value, (list, tuple)) and len(value):                  return self.__get_id(value[0], False)              elif hasattr(value, \"id\"):                  return self.__get_id(value.id, False)              elif hasattr(value, \"__getitem__\") and \"id\" in value:                  return self.__get_id(value.get(\"id\"), False)          if value is not None and type(value).__name__ not in self.__warning_by_type:              _warn(f\"LoV id must be a string, using a string representation of {type(value)}.\")              self.__warning_by_type.add(type(value).__name__)          return \"\" if value is None else str(value)        def __get_label(self, value: t.Any, dig=True) -> t.Union[str, t.Dict, None]:          if isinstance(value, (str, Icon)):              return Icon.get_dict_or(value)          elif dig:              if isinstance(value, (list, tuple)) and len(value) > 1:                  return self.__get_label(value[1], False)              elif hasattr(value, \"label\"):                  return self.__get_label(value.label, False)              elif hasattr(value, \"__getitem__\") and \"label\" in value:                  return self.__get_label(value[\"label\"], False)          return None        def __get_children(self, value: t.Any) -> t.Optional[t.List[t.Any]]:          if isinstance(value, (tuple, list)) and len(value) > 2:              return value[2] if isinstance(value[2], list) else [value[2]]          elif hasattr(value, \"children\"):              return value.children if isinstance(value.children, list) else [value.children]          elif hasattr(value, \"__getitem__\") and \"children\" in value:              return value[\"children\"] if isinstance(value[\"children\"], list) else [value[\"children\"]]          return None "}
{"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": "from __future__ import annotations    import ast  import builtins  import re  import typing as t    from .._warnings import _warn    if t.TYPE_CHECKING:      from ..gui import Gui    from . import (      _get_client_var_name,      _get_expr_var_name,      _getscopeattr,      _getscopeattr_drill,      _hasscopeattr,      _MapDict,      _setscopeattr,      _setscopeattr_drill,      _TaipyBase,      _variable_decode,      _variable_encode,  )      class _Evaluator:      # Regex to separate content from inside curly braces when evaluating f string expressions      __EXPR_RE = re.compile(r\"\\{(([^\\}]*)([^\\{]*))\\}\")      __EXPR_IS_EXPR = re.compile(r\"[^\\\\][{}]\")      __EXPR_IS_EDGE_CASE = re.compile(r\"^\\s*{([^}]*)}\\s*$\")      __EXPR_VALID_VAR_EDGE_CASE = re.compile(r\"^([a-zA-Z\\.\\_0-9\\[\\]]*)$\")      __EXPR_EDGE_CASE_F_STRING = re.compile(r\"[\\{]*[a-zA-Z_][a-zA-Z0-9_]*:.+\")      __IS_TAIPYEXPR_RE = re.compile(r\"TpExPr_(.*)\")        def __init__(self, default_bindings: t.Dict[str, t.Any], shared_variable: t.List[str]) -> None:          # key = expression, value = hashed value of the expression          self.__expr_to_hash: t.Dict[str, str] = {}          # key = hashed value of the expression, value = expression          self.__hash_to_expr: t.Dict[str, str] = {}          # key = variable name of the expression, key = list of related expressions          # ex: {x + y}          # \"x_TPMDL_0\": [\"{x + y}\"],          # \"y_TPMDL_0\": [\"{x + y}\"],          self.__var_to_expr_list: t.Dict[str, t.List[str]] = {}          # key = expression, value = list of related variables          # \"{x + y}\": {\"x\": \"x_TPMDL_\", \"y\": \"y_TPMDL_0\"}          self.__expr_to_var_map: t.Dict[str, t.Dict[str, str]] = {}          # instead of binding everywhere the types          self.__global_ctx = default_bindings          # expr to holders          self.__expr_to_holders: t.Dict[str, t.Set[t.Type[_TaipyBase]]] = {}          # shared variables between multiple clients          self.__shared_variable = shared_variable        @staticmethod      def _expr_decode(s: str):          return str(result[1]) if (result := _Evaluator.__IS_TAIPYEXPR_RE.match(s)) else s        def get_hash_from_expr(self, expr: str) -> str:          return self.__expr_to_hash.get(expr, expr)        def get_expr_from_hash(self, hash_val: str) -> str:          return self.__hash_to_expr.get(hash_val, hash_val)        def get_shared_variables(self) -> t.List[str]:          return self.__shared_variable        def _is_expression(self, expr: str) -> bool:          return len(_Evaluator.__EXPR_IS_EXPR.findall(expr)) != 0        def _fetch_expression_list(self, expr: str) -> t.List:          return [v[0] for v in _Evaluator.__EXPR_RE.findall(expr)]        def _analyze_expression(self, gui: Gui, expr: str) -> t.Tuple[t.Dict[str, t.Any], t.Dict[str, str]]:          var_val: t.Dict[str, t.Any] = {}          var_map: t.Dict[str, str] = {}          non_vars = list(self.__global_ctx.keys())          non_vars.extend(dir(builtins))          # Get a list of expressions (value that has been wrapped in curly braces {}) and find variables to bind          for e in self._fetch_expression_list(expr):              var_name = e.split(sep=\".\")[0]              st = ast.parse('f\"{' + e + '}\"' if _Evaluator.__EXPR_EDGE_CASE_F_STRING.match(e) else e)              args = [arg.arg for node in ast.walk(st) if isinstance(node, ast.arguments) for arg in node.args]              targets = [                  compr.target.id for node in ast.walk(st) if isinstance(node, ast.ListComp) for compr in node.generators  # type: ignore              ]              for node in ast.walk(st):                  if isinstance(node, ast.Name):                      var_name = node.id.split(sep=\".\")[0]                      if var_name not in args and var_name not in targets and var_name not in non_vars:                          try:                              encoded_var_name = gui._bind_var(var_name)                              var_val[var_name] = _getscopeattr_drill(gui, encoded_var_name)                              var_map[var_name] = encoded_var_name                          except AttributeError as e:                              _warn(f\"Variable '{var_name}' is not defined (in expression '{expr}')\", e)          return var_val, var_map        def __save_expression(          self,          gui: Gui,          expr: str,          expr_hash: t.Optional[str],          expr_evaluated: t.Optional[t.Any],          var_map: t.Dict[str, str],      ):          if expr in self.__expr_to_hash:              expr_hash = self.__expr_to_hash[expr]              gui._bind_var_val(expr_hash, expr_evaluated)              return expr_hash          if expr_hash is None:              expr_hash = _get_expr_var_name(expr)          else:              # edge case, only a single variable              expr_hash = f\"tpec_{_get_client_var_name(expr)}\"          self.__expr_to_hash[expr] = expr_hash          gui._bind_var_val(expr_hash, expr_evaluated)          self.__hash_to_expr[expr_hash] = expr          for var in var_map.values():              if var not in self.__global_ctx.keys():                  lst = self.__var_to_expr_list.get(var)                  if lst is None:                      self.__var_to_expr_list[var] = [expr]                  else:                      lst.append(expr)          if expr not in self.__expr_to_var_map:              self.__expr_to_var_map[expr] = var_map          # save expr_hash to shared variable if valid          for encoded_var_name in var_map.values():              var_name, module_name = _variable_decode(encoded_var_name)              # only variables in the main module with be taken into account              if module_name is not None and module_name != gui._get_default_module_name():                  continue              if var_name in self.__shared_variable:                  self.__shared_variable.append(expr_hash)          return expr_hash        def evaluate_bind_holder(self, gui: Gui, holder: t.Type[_TaipyBase], expr: str) -> str:          expr_hash = self.__expr_to_hash.get(expr, \"unknownExpr\")          hash_name = self.__get_holder_hash(holder, expr_hash)          expr_lit = expr.replace(\"'\", \"\\\\'\")          holder_expr = f\"{holder.__name__}({expr},'{expr_lit}')\"          self.__evaluate_holder(gui, holder, expr)          if a_set := self.__expr_to_holders.get(expr):              a_set.add(holder)          else:              self.__expr_to_holders[expr] = {holder}          self.__expr_to_hash[holder_expr] = hash_name          # expression is only the first part ...          expr = expr.split(\".\")[0]          self.__expr_to_var_map[holder_expr] = {expr: expr}          if a_list := self.__var_to_expr_list.get(expr):              if holder_expr not in a_list:                  a_list.append(holder_expr)          else:              self.__var_to_expr_list[expr] = [holder_expr]          return hash_name        def evaluate_holders(self, gui: Gui, expr: str) -> t.List[str]:          lst = []          for hld in self.__expr_to_holders.get(expr, []):              hash_val = self.__get_holder_hash(hld, self.__expr_to_hash.get(expr, \"\"))              self.__evaluate_holder(gui, hld, expr)              lst.append(hash_val)          return lst        @staticmethod      def __get_holder_hash(holder: t.Type[_TaipyBase], expr_hash: str) -> str:          return f\"{holder.get_hash()}_{_get_client_var_name(expr_hash)}\"        def __evaluate_holder(self, gui: Gui, holder: t.Type[_TaipyBase], expr: str) -> t.Optional[_TaipyBase]:          try:              expr_hash = self.__expr_to_hash.get(expr, \"unknownExpr\")              holder_hash = self.__get_holder_hash(holder, expr_hash)              expr_value = _getscopeattr_drill(gui, expr_hash)              holder_value = _getscopeattr(gui, holder_hash, None)              if not isinstance(holder_value, _TaipyBase):                  holder_value = holder(expr_value, expr_hash)                  _setscopeattr(gui, holder_hash, holder_value)              else:                  holder_value.set(expr_value)              return holder_value          except Exception as e:              _warn(f\"Cannot evaluate expression {holder.__name__}({expr_hash},'{expr_hash}') for {expr}\", e)          return None        def evaluate_expr(self, gui: Gui, expr: str) -> t.Any:          if not self._is_expression(expr):              return expr          var_val, var_map = self._analyze_expression(gui, expr)          expr_hash = None          is_edge_case = False            # The expr_string is placed here in case expr get replaced by edge case          expr_string = 'f\"' + expr.replace('\"', '\\\\\"') + '\"'          # simplify expression if it only contains var_name          m = _Evaluator.__EXPR_IS_EDGE_CASE.match(expr)          if m and not _Evaluator.__EXPR_EDGE_CASE_F_STRING.match(expr):              expr = m.group(1)              expr_hash = expr if _Evaluator.__EXPR_VALID_VAR_EDGE_CASE.match(expr) else None              is_edge_case = True          # validate whether expression has already been evaluated          module_name = gui._get_locals_context()          not_encoded_expr = expr          expr = f\"TpExPr_{_variable_encode(expr, module_name)}\"          if expr in self.__expr_to_hash and _hasscopeattr(gui, self.__expr_to_hash[expr]):              return self.__expr_to_hash[expr]          try:              # evaluate expressions              ctx: t.Dict[str, t.Any] = {}              ctx.update(self.__global_ctx)              # entries in var_val are not always seen (NameError) when passed as locals              ctx.update(var_val)              expr_evaluated = eval(not_encoded_expr if is_edge_case else expr_string, ctx)          except Exception as e:              _warn(f\"Cannot evaluate expression '{not_encoded_expr if is_edge_case else expr_string}'\", e)              expr_evaluated = None          # save the expression if it needs to be re-evaluated          return self.__save_expression(gui, expr, expr_hash, expr_evaluated, var_map)        def refresh_expr(self, gui: Gui, var_name: str, holder: t.Optional[_TaipyBase]):          \"\"\"          This function will execute when the __request_var_update function receive a refresh order          \"\"\"          expr = self.__hash_to_expr.get(var_name)          if expr:              expr_decoded, _ = _variable_decode(expr)              var_map = self.__expr_to_var_map.get(expr, {})              eval_dict = {k: _getscopeattr_drill(gui, gui._bind_var(v)) for k, v in var_map.items()}              if self._is_expression(expr_decoded):                  expr_string = 'f\"' + _variable_decode(expr)[0].replace('\"', '\\\\\"') + '\"'              else:                  expr_string = expr_decoded              try:                  ctx: t.Dict[str, t.Any] = {}                  ctx.update(self.__global_ctx)                  ctx.update(eval_dict)                  expr_evaluated = eval(expr_string, ctx)                  _setscopeattr(gui, var_name, expr_evaluated)                  if holder is not None:                      holder.set(expr_evaluated)              except Exception as e:                  _warn(f\"Exception raised evaluating {expr_string}\", e)        def re_evaluate_expr(self, gui: Gui, var_name: str) -> t.Set[str]:          \"\"\"          This function will execute when the _update_var function is handling          an expression with only a single variable          \"\"\"          modified_vars: t.Set[str] = set()          # Verify that the current hash is an edge case one (only a single variable inside the original expression)          if var_name.startswith(\"tp_\"):              return modified_vars          expr_original = None          # if var_name starts with tpec_ --> it is an edge case with modified var          if var_name.startswith(\"tpec_\"):              # backup for later reference              var_name_original = var_name              expr_original = self.__hash_to_expr[var_name]              temp_expr_var_map = self.__expr_to_var_map[expr_original]              if len(temp_expr_var_map) <= 1:                  # since this is an edge case --> only 1 item in the dict and that item is the original var                  for v in temp_expr_var_map.values():                      var_name = v                  # construct correct var_path to reassign values                  var_name_full, _ = _variable_decode(expr_original)                  var_name_full = var_name_full.split(\".\")                  var_name_full[0] = var_name                  var_name_full = \".\".join(var_name_full)                  _setscopeattr_drill(gui, var_name_full, _getscopeattr(gui, var_name_original))              else:                  # multiple key-value pair in expr_var_map --> expr is special case a[\"b\"]                  key = \"\"                  for v in temp_expr_var_map.values():                      if isinstance(_getscopeattr(gui, v), _MapDict):                          var_name = v                      else:                          key = v                  if key == \"\":                      return modified_vars                  _setscopeattr_drill(gui, f\"{var_name}.{_getscopeattr(gui, key)}\", _getscopeattr(gui, var_name_original))          # A middle check to see if var_name is from _MapDict          if \".\" in var_name:              var_name = var_name[: var_name.index(\".\")]          # otherwise, thar var_name is correct and doesn't require any resolution          if var_name not in self.__var_to_expr_list:              # _warn(\"{var_name} not found.\")              return modified_vars          # refresh expressions and holders          for expr in self.__var_to_expr_list[var_name]:              expr_decoded, _ = _variable_decode(expr)              hash_expr = self.__expr_to_hash.get(expr, \"UnknownExpr\")              if expr != var_name and not expr.startswith(_TaipyBase._HOLDER_PREFIX):                  expr_var_map = self.__expr_to_var_map.get(expr)  # [\"x\", \"y\"]                  if expr_var_map is None:                      _warn(f\"Something is amiss with expression list for {expr}.\")                  else:                      eval_dict = {k: _getscopeattr_drill(gui, gui._bind_var(v)) for k, v in expr_var_map.items()}                      if self._is_expression(expr_decoded):                          expr_string = 'f\"' + _variable_decode(expr)[0].replace('\"', '\\\\\"') + '\"'                      else:                          expr_string = expr_decoded                      try:                          ctx: t.Dict[str, t.Any] = {}                          ctx.update(self.__global_ctx)                          ctx.update(eval_dict)                          expr_evaluated = eval(expr_string, ctx)                          _setscopeattr(gui, hash_expr, expr_evaluated)                      except Exception as e:                          _warn(f\"Exception raised evaluating {expr_string}\", e)              # refresh holders if any              for h in self.__expr_to_holders.get(expr, []):                  holder_hash = self.__get_holder_hash(h, self.get_hash_from_expr(expr))                  if holder_hash not in modified_vars:                      _setscopeattr(gui, holder_hash, self.__evaluate_holder(gui, h, expr))                      modified_vars.add(holder_hash)              modified_vars.add(hash_expr)          return modified_vars        def _get_instance_in_context(self, name: str):          return self.__global_ctx.get(name) "}
{"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  from datetime import datetime  from importlib import util    import numpy as np  import pandas as pd    from .._warnings import _warn  from ..gui import Gui  from ..types import PropertyType  from ..utils import _RE_PD_TYPE, _get_date_col_str_name  from .data_accessor import _DataAccessor  from .data_format import _DataFormat  from .utils import _df_data_filter, _df_relayout    _has_arrow_module = False  if util.find_spec(\"pyarrow\"):      _has_arrow_module = True      import pyarrow as pa      class _PandasDataAccessor(_DataAccessor):      __types = (pd.DataFrame,)        __INDEX_COL = \"_tp_index\"        __AGGREGATE_FUNCTIONS: t.List[str] = [\"count\", \"sum\", \"mean\", \"median\", \"min\", \"max\", \"std\", \"first\", \"last\"]        @staticmethod      def get_supported_classes() -> t.List[str]:          return [t.__name__ for t in _PandasDataAccessor.__types]  # type: ignore        @staticmethod      def __user_function(          row: pd.Series, gui: Gui, column_name: t.Optional[str], user_function: t.Callable, function_name: str      ) -> str:  # pragma: no cover          args = []          if column_name:              args.append(row[column_name])          args.extend((row.name, row))          if column_name:              args.append(column_name)          try:              return str(gui._call_function_with_state(user_function, args))          except Exception as e:              _warn(f\"Exception raised when calling user function {function_name}()\", e)          return \"\"        def __is_date_column(self, data: pd.DataFrame, col_name: str) -> bool:          col_types = data.dtypes[data.dtypes.index.astype(str) == col_name]          return len(col_types[col_types.astype(str).str.startswith(\"datetime\")]) > 0  # type: ignore        def __build_transferred_cols(          self,          gui: Gui,          payload_cols: t.Any,          dataframe: pd.DataFrame,          styles: t.Optional[t.Dict[str, str]] = None,          tooltips: t.Optional[t.Dict[str, str]] = None,          is_copied: t.Optional[bool] = False,          new_indexes: t.Optional[np.ndarray] = None,          handle_nan: t.Optional[bool] = False,      ) -> pd.DataFrame:          if isinstance(payload_cols, list) and len(payload_cols):              col_types = dataframe.dtypes[dataframe.dtypes.index.astype(str).isin(payload_cols)]          else:              col_types = dataframe.dtypes          cols = col_types.index.astype(str).tolist()          if styles:              if not is_copied:                  # copy the df so that we don't \"mess\" with the user's data                  dataframe = dataframe.copy()                  is_copied = True              for k, v in styles.items():                  col_applied = False                  func = gui._get_user_function(v)                  if callable(func):                      col_applied = self.__apply_user_function(gui, func, k if k in cols else None, v, dataframe, \"tps__\")                  if not col_applied:                      dataframe[v] = v                  cols.append(col_applied or v)          if tooltips:              if not is_copied:                  # copy the df so that we don't \"mess\" with the user's data                  dataframe = dataframe.copy()                  is_copied = True              for k, v in tooltips.items():                  col_applied = False                  func = gui._get_user_function(v)                  if callable(func):                      col_applied = self.__apply_user_function(gui, func, k if k in cols else None, v, dataframe, \"tpt__\")                  cols.append(col_applied or v)          # deal with dates          datecols = col_types[col_types.astype(str).str.startswith(\"datetime\")].index.tolist()  # type: ignore          if len(datecols) != 0:              if not is_copied:                  # copy the df so that we don't \"mess\" with the user's data                  dataframe = dataframe.copy()              tz = Gui._get_timezone()              for col in datecols:                  newcol = _get_date_col_str_name(cols, col)                  cols.append(newcol)                  re_type = _RE_PD_TYPE.match(str(col_types[col]))                  grps = re_type.groups() if re_type else ()                  if len(grps) > 4 and grps[4]:                      dataframe[newcol] = (                          dataframe[col]                          .dt.tz_convert(\"UTC\")                          .dt.strftime(_DataAccessor._WS_DATE_FORMAT)                          .astype(str)                          .replace(\"nan\", \"NaT\" if handle_nan else None)                      )                  else:                      dataframe[newcol] = (                          dataframe[col]                          .dt.tz_localize(tz)                          .dt.tz_convert(\"UTC\")                          .dt.strftime(_DataAccessor._WS_DATE_FORMAT)                          .astype(str)                          .replace(\"nan\", \"NaT\" if handle_nan else None)                      )                # remove the date columns from the list of columns              cols = list(set(cols) - set(datecols))          dataframe = dataframe.iloc[new_indexes] if new_indexes is not None else dataframe          dataframe = dataframe.loc[:, dataframe.dtypes[dataframe.dtypes.index.astype(str).isin(cols)].index]  # type: ignore          return dataframe        def __apply_user_function(          self,          gui: Gui,          user_function: t.Callable,          column_name: t.Optional[str],          function_name: str,          data: pd.DataFrame,          prefix: t.Optional[str],      ):          try:              new_col_name = f\"{prefix}{column_name}__{function_name}\" if column_name else function_name              data[new_col_name] = data.apply(                  _PandasDataAccessor.__user_function,                  axis=1,                  args=(gui, column_name, user_function, function_name),              )              return new_col_name          except Exception as e:              _warn(f\"Exception raised when invoking user function {function_name}()\", e)          return False        def __format_data(          self,          data: pd.DataFrame,          data_format: _DataFormat,          orient: str,          start: t.Optional[int] = None,          rowcount: t.Optional[int] = None,          data_extraction: t.Optional[bool] = None,          handle_nan: t.Optional[bool] = False,      ) -> t.Dict[str, t.Any]:          ret: t.Dict[str, t.Any] = {              \"format\": str(data_format.value),          }          if rowcount is not None:              ret[\"rowcount\"] = rowcount          if start is not None:              ret[\"start\"] = start          if data_extraction is not None:              ret[\"dataExtraction\"] = data_extraction  # Extract data out of dictionary on front-end          if data_format == _DataFormat.APACHE_ARROW:              if not _has_arrow_module:                  raise RuntimeError(\"Cannot use Arrow as pyarrow package is not installed\")              # Convert from pandas to Arrow              table = pa.Table.from_pandas(data)              # Create sink buffer stream              sink = pa.BufferOutputStream()              # Create Stream writer              writer = pa.ipc.new_stream(sink, table.schema)              # Write data to table              writer.write_table(table)              writer.close()              # End buffer stream              buf = sink.getvalue()              # Convert buffer to Python bytes and return              ret[\"data\"] = buf.to_pybytes()              ret[\"orient\"] = orient          else:              # Workaround for Python built in JSON encoder that does not yet support ignore_nan              ret[\"data\"] = data.replace([np.nan, pd.NA], [None, None]).to_dict(orient=orient)  # type: ignore          return ret        def get_col_types(self, var_name: str, value: t.Any) -> t.Union[None, t.Dict[str, str]]:  # type: ignore          if isinstance(value, _PandasDataAccessor.__types):  # type: ignore              return {str(k): v for k, v in value.dtypes.apply(lambda x: x.name.lower()).items()}          elif isinstance(value, list):              ret_dict: t.Dict[str, str] = {}              for i, v in enumerate(value):                  ret_dict.update({f\"{i}/{k}\": v for k, v in v.dtypes.apply(lambda x: x.name.lower()).items()})              return ret_dict          return None        def __get_data(  # noqa: C901          self,          gui: Gui,          var_name: str,          value: pd.DataFrame,          payload: t.Dict[str, t.Any],          data_format: _DataFormat,          col_prefix: t.Optional[str] = \"\",      ) -> t.Dict[str, t.Any]:          columns = payload.get(\"columns\", [])          if col_prefix:              columns = [c[len(col_prefix) :] if c.startswith(col_prefix) else c for c in columns]          ret_payload = {\"pagekey\": payload.get(\"pagekey\", \"unknown page\")}          paged = not payload.get(\"alldata\", False)          is_copied = False            # add index if not chart          if paged:              if _PandasDataAccessor.__INDEX_COL not in value.columns:                  value = value.copy()                  is_copied = True                  value[_PandasDataAccessor.__INDEX_COL] = value.index              if columns and _PandasDataAccessor.__INDEX_COL not in columns:                  columns.append(_PandasDataAccessor.__INDEX_COL)            # filtering          filters = payload.get(\"filters\")          if isinstance(filters, list) and len(filters) > 0:              query = \"\"              vars = []              for fd in filters:                  col = fd.get(\"col\")                  val = fd.get(\"value\")                  action = fd.get(\"action\")                  if isinstance(val, str):                      if self.__is_date_column(value, col):                          val = datetime.fromisoformat(val[:-1])                      vars.append(val)                  val = f\"@vars[{len(vars) - 1}]\" if isinstance(val, (str, datetime)) else val                  right = f\".str.contains({val})\" if action == \"contains\" else f\" {action} {val}\"                  if query:                      query += \" and \"                  query += f\"`{col}`{right}\"              try:                  value = value.query(query)                  is_copied = True              except Exception as e:                  _warn(f\"Dataframe filtering: invalid query '{query}' on {value.head()}\", e)            if paged:              aggregates = payload.get(\"aggregates\")              applies = payload.get(\"applies\")              if isinstance(aggregates, list) and len(aggregates) and isinstance(applies, dict):                  applies_with_fn = {                      k: v if v in _PandasDataAccessor.__AGGREGATE_FUNCTIONS else gui._get_user_function(v)                      for k, v in applies.items()                  }                    for col in columns:                      if col not in applies_with_fn.keys():                          applies_with_fn[col] = \"first\"                  try:                      value = value.groupby(aggregates).agg(applies_with_fn)                  except Exception:                      _warn(f\"Cannot aggregate {var_name} with groupby {aggregates} and aggregates {applies}.\")              inf = payload.get(\"infinite\")              if inf is not None:                  ret_payload[\"infinite\"] = inf              # real number of rows is needed to calculate the number of pages              rowcount = len(value)              # here we'll deal with start and end values from payload if present              if isinstance(payload[\"start\"], int):                  start = int(payload[\"start\"])              else:                  try:                      start = int(str(payload[\"start\"]), base=10)                  except Exception:                      _warn(f'start should be an int value {payload[\"start\"]}.')                      start = 0              if isinstance(payload[\"end\"], int):                  end = int(payload[\"end\"])              else:                  try:                      end = int(str(payload[\"end\"]), base=10)                  except Exception:                      end = -1              if start < 0 or start >= rowcount:                  start = 0              if end < 0 or end >= rowcount:                  end = rowcount - 1              # deal with sort              order_by = payload.get(\"orderby\")              if isinstance(order_by, str) and len(order_by):                  try:                      if value.columns.dtype.name == \"int64\":                          order_by = int(order_by)                      new_indexes = value[order_by].values.argsort(axis=0)                      if payload.get(\"sort\") == \"desc\":                          # reverse order                          new_indexes = new_indexes[::-1]                      new_indexes = new_indexes[slice(start, end + 1)]                  except Exception:                      _warn(f\"Cannot sort {var_name} on columns {order_by}.\")                      new_indexes = slice(start, end + 1)  # type: ignore              else:                  new_indexes = slice(start, end + 1)  # type: ignore              value = self.__build_transferred_cols(                  gui,                  columns,                  value,                  styles=payload.get(\"styles\"),                  tooltips=payload.get(\"tooltips\"),                  is_copied=is_copied,                  new_indexes=new_indexes,                  handle_nan=payload.get(\"handlenan\", False),              )              dictret = self.__format_data(                  value, data_format, \"records\", start, rowcount, handle_nan=payload.get(\"handlenan\", False)              )          else:              ret_payload[\"alldata\"] = True              decimator_payload: t.Dict[str, t.Any] = payload.get(\"decimatorPayload\", {})              decimators = decimator_payload.get(\"decimators\", [])              nb_rows_max = decimator_payload.get(\"width\")              for decimator_pl in decimators:                  decimator = decimator_pl.get(\"decimator\")                  decimator_instance = (                      gui._get_user_instance(decimator, PropertyType.decimator.value) if decimator is not None else None                  )                  if isinstance(decimator_instance, PropertyType.decimator.value):                      x_column, y_column, z_column = (                          decimator_pl.get(\"xAxis\", \"\"),                          decimator_pl.get(\"yAxis\", \"\"),                          decimator_pl.get(\"zAxis\", \"\"),                      )                      chart_mode = decimator_pl.get(\"chartMode\", \"\")                      if decimator_instance._zoom and \"relayoutData\" in decimator_payload and not z_column:                          relayoutData = decimator_payload.get(\"relayoutData\", {})                          x0 = relayoutData.get(\"xaxis.range[0]\")                          x1 = relayoutData.get(\"xaxis.range[1]\")                          y0 = relayoutData.get(\"yaxis.range[0]\")                          y1 = relayoutData.get(\"yaxis.range[1]\")                            value, is_copied = _df_relayout(                              value, x_column, y_column, chart_mode, x0, x1, y0, y1, is_copied                          )                        if nb_rows_max and decimator_instance._is_applicable(value, nb_rows_max, chart_mode):                          try:                              value, is_copied = _df_data_filter(                                  value,                                  x_column,                                  y_column,                                  z_column,                                  decimator=decimator_instance,                                  payload=decimator_payload,                                  is_copied=is_copied,                              )                              gui._call_on_change(f\"{var_name}.{decimator}.nb_rows\", len(value))                          except Exception as e:                              _warn(f\"Limit rows error with {decimator} for Dataframe\", e)              value = self.__build_transferred_cols(gui, columns, value, is_copied=is_copied)              dictret = self.__format_data(value, data_format, \"list\", data_extraction=True)          ret_payload[\"value\"] = dictret          return ret_payload        def get_data(          self, gui: Gui, var_name: str, value: t.Any, payload: t.Dict[str, t.Any], data_format: _DataFormat      ) -> t.Dict[str, t.Any]:          if isinstance(value, list):              # If is_chart data              if payload.get(\"alldata\", False):                  ret_payload = {                      \"alldata\": True,                      \"value\": {\"multi\": True},                      \"pagekey\": payload.get(\"pagekey\", \"unknown page\"),                  }                  data = []                  for i, v in enumerate(value):                      ret = (                          self.__get_data(gui, var_name, v, payload, data_format, f\"{i}/\")                          if isinstance(v, pd.DataFrame)                          else {}                      )                      ret_val = ret.get(\"value\", {})                      data.append(ret_val.pop(\"data\", None))                      ret_payload.get(\"value\", {}).update(ret_val)                  ret_payload[\"value\"][\"data\"] = data                  return ret_payload              else:                  value = value[0]          if isinstance(value, _PandasDataAccessor.__types):  # type: ignore              return self.__get_data(gui, var_name, value, payload, data_format)          return {} "}
{"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 re  import typing as t  from datetime import datetime    from ..types import PropertyType  from .builder import _Builder    if t.TYPE_CHECKING:      from ..extension.library import ElementLibrary      from ..gui import Gui      class _Factory:      DEFAULT_CONTROL = \"text\"        _START_SUFFIX = \".start\"      _END_SUFFIX = \".end\"        __TAIPY_NAME_SPACE = \"taipy.\"        __CONTROL_DEFAULT_PROP_NAME = {          \"button\": \"label\",          \"chart\": \"data\",          \"content\": \"value\",          \"date\": \"date\",          \"date_range\": \"dates\",          \"dialog\": \"open\",          \"expandable\": \"title\",          \"file_download\": \"content\",          \"file_selector\": \"content\",          \"image\": \"content\",          \"indicator\": \"display\",          \"input\": \"value\",          \"layout\": \"columns\",          \"menu\": \"lov\",          \"navbar\": \"value\",          \"number\": \"value\",          \"pane\": \"open\",          \"part\": \"class_name\",          \"selector\": \"value\",          \"slider\": \"value\",          \"status\": \"value\",          \"table\": \"data\",          \"text\": \"value\",          \"toggle\": \"value\",          \"tree\": \"value\",      }        _TEXT_ATTRIBUTES = [\"format\", \"id\", \"hover_text\", \"raw\"]        __TEXT_ANCHORS = [\"bottom\", \"top\", \"left\", \"right\"]      __TEXT_ANCHOR_NONE = \"none\"        __LIBRARIES: t.Dict[str, t.List[\"ElementLibrary\"]] = {}        __CONTROL_BUILDERS = {          \"button\": lambda gui, control_type, attrs: _Builder(              gui=gui,              control_type=control_type,              element_name=\"Button\",              attributes=attrs,          )          .set_value_and_default(with_update=False)          .set_attributes(              [                  (\"id\",),                  (\"on_action\", PropertyType.function),                  (\"active\", PropertyType.dynamic_boolean, True),                  (\"hover_text\", PropertyType.dynamic_string),              ]          ),          \"chart\": lambda gui, control_type, attrs: _Builder(              gui=gui,              control_type=control_type,              element_name=\"Chart\",              attributes=attrs,          )          .set_value_and_default(with_default=False, var_type=PropertyType.data)          .set_attributes(              [                  (\"id\",),                  (\"title\",),                  (\"width\", PropertyType.string_or_number),                  (\"height\", PropertyType.string_or_number),                  (\"layout\", PropertyType.dynamic_dict),                  (\"plot_config\", PropertyType.dict),                  (\"on_range_change\", PropertyType.function),                  (\"active\", PropertyType.dynamic_boolean, True),                  (\"render\", PropertyType.dynamic_boolean, True),                  (\"hover_text\", PropertyType.dynamic_string),                  (\"on_change\", PropertyType.function),                  (\"template\", PropertyType.dict),                  (\"template[dark]\", PropertyType.dict, gui._get_config(\"chart_dark_template\", None)),                  (\"template[light]\", PropertyType.dict),              ]          )          ._get_chart_config(\"scatter\", \"lines+markers\")          ._set_propagate(),          \"content\": lambda gui, control_type, attrs: _Builder(              gui=gui, control_type=control_type, element_name=\"PageContent\", attributes=attrs          ),          \"date\": lambda gui, control_type, attrs: _Builder(              gui=gui,              control_type=control_type,              element_name=\"DateSelector\",              attributes=attrs,              default_value=datetime.fromtimestamp(0),          )          .set_value_and_default(var_type=PropertyType.date)          .set_attributes(              [                  (\"with_time\", PropertyType.boolean),                  (\"id\",),                  (\"active\", PropertyType.dynamic_boolean, True),                  (\"editable\", PropertyType.dynamic_boolean, True),                  (\"hover_text\", PropertyType.dynamic_string),                  (\"label\",),                  (\"on_change\", PropertyType.function),                  (\"format\",),              ]          )          ._set_propagate(),          \"date_range\": lambda gui, control_type, attrs: _Builder(              gui=gui,              control_type=control_type,              element_name=\"DateRange\",              attributes=attrs,          )          .set_value_and_default(var_type=PropertyType.date_range)          .set_attributes(              [                  (\"with_time\", PropertyType.boolean),                  (\"id\",),                  (\"active\", PropertyType.dynamic_boolean, True),                  (\"editable\", PropertyType.dynamic_boolean, True),                  (\"hover_text\", PropertyType.dynamic_string),                  (\"label_start\",),                  (\"label_end\",),                  (\"on_change\", PropertyType.function),                  (\"format\",),              ]          )          ._set_propagate(),          \"dialog\": lambda gui, control_type, attrs: _Builder(              gui=gui,              control_type=control_type,              element_name=\"Dialog\",              attributes=attrs,          )          .set_value_and_default(var_type=PropertyType.dynamic_boolean)          ._set_partial()  # partial should be set before page          .set_attributes(              [                  (\"id\",),                  (\"page\",),                  (\"title\",),                  (\"on_action\", PropertyType.function),                  (\"close_label\", PropertyType.string),                  (\"labels\", PropertyType.string_list),                  (\"active\", PropertyType.dynamic_boolean, True),                  (\"width\", PropertyType.string_or_number),                  (\"height\", PropertyType.string_or_number),                  (\"hover_text\", PropertyType.dynamic_string),              ]          )          ._set_propagate(),          \"expandable\": lambda gui, control_type, attrs: _Builder(              gui=gui, control_type=control_type, element_name=\"Expandable\", attributes=attrs, default_value=None          )          .set_value_and_default()          ._set_partial()  # partial should be set before page          .set_attributes(              [                  (\"id\",),                  (\"page\",),                  (\"expanded\", PropertyType.dynamic_boolean, True, True, False),                  (\"hover_text\", PropertyType.dynamic_string),                  (\"on_change\", PropertyType.function),              ]          ),          \"file_download\": lambda gui, control_type, attrs: _Builder(              gui=gui,              control_type=control_type,              element_name=\"FileDownload\",              attributes=attrs,          )          .set_value_and_default(var_name=\"label\", with_update=False)          ._set_content(\"content\", image=False)          .set_attributes(              [                  (\"id\",),                  (\"on_action\", PropertyType.function),                  (\"active\", PropertyType.dynamic_boolean, True),                  (\"render\", PropertyType.dynamic_boolean, True),                  (\"auto\", PropertyType.boolean, False),                  (\"bypass_preview\", PropertyType.boolean, True),                  (\"name\",),                  (\"hover_text\", PropertyType.dynamic_string),              ]          ),          \"file_selector\": lambda gui, control_type, attrs: _Builder(              gui=gui,              control_type=control_type,              element_name=\"FileSelector\",              attributes=attrs,          )          .set_value_and_default(var_name=\"label\", with_update=False)          ._set_file_content()          .set_attributes(              [                  (\"id\",),                  (\"on_action\", PropertyType.function),                  (\"active\", PropertyType.dynamic_boolean, True),                  (\"multiple\", PropertyType.boolean, False),                  (\"extensions\",),                  (\"drop_message\",),                  (\"hover_text\", PropertyType.dynamic_string),              ]          ),          \"image\": lambda gui, control_type, attrs: _Builder(              gui=gui,              control_type=control_type,              element_name=\"Image\",              attributes=attrs,          )          .set_value_and_default(var_name=\"label\", with_update=False)          ._set_content(\"content\")          .set_attributes(              [                  (\"id\",),                  (\"on_action\", PropertyType.function),                  (\"active\", PropertyType.dynamic_boolean, True),                  (\"width\",),                  (\"height\",),                  (\"hover_text\", PropertyType.dynamic_string),              ]          ),          \"indicator\": lambda gui, control_type, attrs: _Builder(              gui=gui,              control_type=control_type,              element_name=\"Indicator\",              attributes=attrs,          )          .set_value_and_default(with_update=False, native_type=True)          .set_attributes(              [                  (\"id\",),                  (\"min\", PropertyType.number),                  (\"max\", PropertyType.number),                  (\"value\", PropertyType.dynamic_number),                  (\"format\",),                  (\"orientation\"),                  (\"hover_text\", PropertyType.dynamic_string),                  (\"width\",),                  (\"height\",),              ]          ),          \"input\": lambda gui, control_type, attrs: _Builder(              gui=gui,              control_type=control_type,              element_name=\"Input\",              attributes=attrs,          )          ._set_input_type(\"text\", True)          .set_value_and_default()          ._set_propagate()          .set_attributes(              [                  (\"id\",),                  (\"active\", PropertyType.dynamic_boolean, True),                  (\"hover_text\", PropertyType.dynamic_string),                  (\"on_change\", PropertyType.function),                  (\"on_action\", PropertyType.function),                  (\"action_keys\",),                  (\"label\",),                  (\"change_delay\", PropertyType.number, gui._get_config(\"change_delay\", None)),                  (\"multiline\", PropertyType.boolean, False),                  (\"lines_shown\", PropertyType.number, 5),              ]          ),          \"layout\": lambda gui, control_type, attrs: _Builder(              gui=gui, control_type=control_type, element_name=\"Layout\", attributes=attrs, default_value=None          )          .set_value_and_default(with_default=False)          .set_attributes(              [                  (\"id\",),                  (\"columns[mobile]\",),                  (\"gap\",),              ]          ),          \"menu\": lambda gui, control_type, attrs: _Builder(              gui=gui,              control_type=control_type,              element_name=\"MenuCtl\",              attributes=attrs,          )          ._get_adapter(\"lov\")  # need to be called before set_lov          ._set_lov()          .set_attributes(              [                  (\"id\",),                  (\"active\", PropertyType.dynamic_boolean, True),                  (\"label\"),                  (\"width\"),                  (\"width[mobile]\",),                  (\"on_action\", PropertyType.function),                  (\"inactive_ids\", PropertyType.dynamic_list),                  (\"hover_text\", PropertyType.dynamic_string),              ]          )          ._set_propagate(),          \"navbar\": lambda gui, control_type, attrs: _Builder(              gui=gui, control_type=control_type, element_name=\"NavBar\", attributes=attrs, default_value=None          )          ._get_adapter(\"lov\", multi_selection=False)  # need to be called before set_lov          ._set_lov()          .set_attributes(              [                  (\"id\",),                  (\"active\", PropertyType.dynamic_boolean, True),                  (\"hover_text\", PropertyType.dynamic_string),              ]          ),          \"number\": lambda gui, control_type, attrs: _Builder(              gui=gui,              control_type=control_type,              element_name=\"Input\",              attributes=attrs,              default_value=0,          )          ._set_input_type(\"number\")          .set_value_and_default(var_type=PropertyType.dynamic_number)          ._set_propagate()          .set_attributes(              [                  (\"id\",),                  (\"active\", PropertyType.dynamic_boolean, True),                  (\"hover_text\", PropertyType.dynamic_string),                  (\"on_change\", PropertyType.function),                  (\"on_action\", PropertyType.function),                  (\"label\",),                  (\"change_delay\", PropertyType.number, gui._get_config(\"change_delay\", None)),              ]          ),          \"pane\": lambda gui, control_type, attrs: _Builder(              gui=gui, control_type=control_type, element_name=\"Pane\", attributes=attrs, default_value=None          )          .set_value_and_default(var_type=PropertyType.dynamic_boolean)          ._set_partial()  # partial should be set before page          .set_attributes(              [                  (\"id\",),                  (\"page\",),                  (\"anchor\", PropertyType.string, \"left\"),                  (\"on_close\", PropertyType.function),                  (\"persistent\", PropertyType.boolean, False),                  (\"active\", PropertyType.dynamic_boolean, True),                  (\"width\", PropertyType.string_or_number, \"30vw\"),                  (\"height\", PropertyType.string_or_number, \"30vh\"),                  (\"hover_text\", PropertyType.dynamic_string),                  (\"on_change\", PropertyType.function),              ]          )          ._set_propagate(),          \"part\": lambda gui, control_type, attrs: _Builder(              gui=gui, control_type=control_type, element_name=\"Part\", attributes=attrs, default_value=None          )          ._set_partial()  # partial should be set before page          .set_attributes(              [                  (\"id\",),                  (\"page\", PropertyType.dynamic_string),                  (\"render\", PropertyType.dynamic_boolean, True),                  (\"height\", PropertyType.dynamic_string),                  (\"content\", PropertyType.toHtmlContent),              ]          ),          \"selector\": lambda gui, control_type, attrs: _Builder(              gui=gui, control_type=control_type, element_name=\"Selector\", attributes=attrs, default_value=None          )          .set_value_and_default(with_default=False, var_type=PropertyType.lov_value)          ._get_adapter(\"lov\")  # need to be called before set_lov          ._set_lov()          .set_attributes(              [                  (\"active\", PropertyType.dynamic_boolean, True),                  (\"dropdown\", PropertyType.boolean, False),                  (\"filter\", PropertyType.boolean),                  (\"height\", PropertyType.string_or_number),                  (\"hover_text\", PropertyType.dynamic_string),                  (\"id\",),                  (\"value_by_id\", PropertyType.boolean),                  (\"multiple\", PropertyType.boolean),                  (\"width\", PropertyType.string_or_number),                  (\"on_change\", PropertyType.function),                  (\"label\",),              ]          )          ._set_propagate(),          \"slider\": lambda gui, control_type, attrs: _Builder(              gui=gui,              control_type=control_type,              element_name=\"Slider\",              attributes=attrs,              default_value=0,          )          .set_value_and_default(native_type=True, var_type=PropertyType.slider_value)          .set_attributes(              [                  (\"active\", PropertyType.dynamic_boolean, True),                  (\"height\"),                  (\"hover_text\", PropertyType.dynamic_string),                  (\"id\",),                  (\"value_by_id\", PropertyType.boolean),                  (\"max\", PropertyType.number, 100),                  (\"min\", PropertyType.number, 0),                  (\"orientation\"),                  (\"width\", PropertyType.string, \"300px\"),                  (\"on_change\", PropertyType.function),                  (\"continuous\", PropertyType.boolean, True),                  (\"lov\", PropertyType.lov),                  (\"change_delay\", PropertyType.number, gui._get_config(\"change_delay\", None)),              ]          )          ._set_labels()          ._set_string_with_check(\"text_anchor\", _Factory.__TEXT_ANCHORS + [_Factory.__TEXT_ANCHOR_NONE], \"bottom\")          ._set_propagate(),          \"status\": lambda gui, control_type, attrs: _Builder(              gui=gui,              control_type=control_type,              element_name=\"Status\",              attributes=attrs,          )          .set_value_and_default(with_update=False)          .set_attributes(              [                  (\"id\",),                  (\"without_close\", PropertyType.boolean, False),                  (\"hover_text\", PropertyType.dynamic_string),              ]          ),          \"table\": lambda gui, control_type, attrs: _Builder(              gui=gui,              control_type=control_type,              element_name=\"Table\",              attributes=attrs,          )          .set_value_and_default(with_default=False, var_type=PropertyType.data)          ._get_dataframe_attributes()          .set_attributes(              [                  (\"page_size\", PropertyType.number, \"100\"),                  (\"allow_all_rows\", PropertyType.boolean),                  (\"show_all\", PropertyType.boolean),                  (\"auto_loading\", PropertyType.boolean),                  (\"width\", PropertyType.string_or_number, \"100%\"),                  (\"height\", PropertyType.string_or_number, \"80vh\"),                  (\"id\",),                  (\"active\", PropertyType.dynamic_boolean, True),                  (\"editable\", PropertyType.dynamic_boolean, True),                  (\"on_edit\", PropertyType.function),                  (\"on_delete\", PropertyType.function),                  (\"on_add\", PropertyType.function),                  (\"on_action\", PropertyType.function),                  (\"nan_value\",),                  (\"filter\", PropertyType.boolean),                  (\"hover_text\", PropertyType.dynamic_string),                  (\"size\",),              ]          )          ._set_propagate()          ._get_list_attribute(\"selected\", PropertyType.number)          ._set_table_pagesize_options(),          \"text\": lambda gui, control_type, attrs: _Builder(              gui=gui,              control_type=control_type,              element_name=\"Field\",              attributes=attrs,          )          .set_value_and_default(with_update=False)          ._set_dataType()          .set_attributes(              [                  (\"format\",),                  (\"id\",),                  (\"hover_text\", PropertyType.dynamic_string),                  (\"raw\", PropertyType.boolean, False),                  (\"mode\", PropertyType.string),              ]          ),          \"toggle\": lambda gui, control_type, attrs: _Builder(              gui=gui, control_type=control_type, element_name=\"Toggle\", attributes=attrs, default_value=None          )          .set_value_and_default(with_default=False, var_type=PropertyType.lov_value)          ._get_adapter(\"lov\", multi_selection=False)  # need to be called before set_lov          ._set_lov()          .set_attributes(              [                  (\"active\", PropertyType.dynamic_boolean, True),                  (\"hover_text\", PropertyType.dynamic_string),                  (\"id\",),                  (\"label\",),                  (\"value_by_id\", PropertyType.boolean),                  (\"unselected_value\", PropertyType.string, \"\"),                  (\"allow_unselect\", PropertyType.boolean),                  (\"on_change\", PropertyType.function),              ]          )          ._set_kind()          ._set_propagate(),          \"tree\": lambda gui, control_type, attrs: _Builder(              gui=gui,              control_type=control_type,              element_name=\"TreeView\",              attributes=attrs,          )          .set_value_and_default(with_default=False, var_type=PropertyType.lov_value)          .set_attributes(              [                  (\"active\", PropertyType.dynamic_boolean, True),                  (\"expanded\", PropertyType.boolean_or_list, True),                  (\"filter\", PropertyType.boolean),                  (\"hover_text\", PropertyType.dynamic_string),                  (\"height\", PropertyType.string_or_number),                  (\"id\",),                  (\"value_by_id\", PropertyType.boolean),                  (\"multiple\", PropertyType.boolean),                  (\"width\", PropertyType.string_or_number),                  (\"on_change\", PropertyType.function),                  (\"select_leafs_only\", PropertyType.boolean),                  (\"row_height\", PropertyType.string),                  (\"lov\", PropertyType.lov),              ]          )          ._set_propagate(),      }        # TODO: process \\\" in property value      _PROPERTY_RE = re.compile(r\"\\s+([a-zA-Z][\\.a-zA-Z_$0-9]*(?:\\[(?:.*?)\\])?)=\\\"((?:(?:(?<=\\\\)\\\")|[^\\\"])*)\\\"\")        @staticmethod      def set_library(library: \"ElementLibrary\"):          from ..extension.library import Element, ElementLibrary            if isinstance(library, ElementLibrary) and isinstance(library.get_name(), str) and library.get_elements():              elements = library.get_elements()              for name, element in elements.items():                  if isinstance(element, Element):                      element.check(name)              fact_lib = _Factory.__LIBRARIES.get(library.get_name())              if fact_lib is None:                  _Factory.__LIBRARIES.update({library.get_name(): [library]})              else:                  fact_lib.append(library)        @staticmethod      def get_default_property_name(control_name: str) -> t.Optional[str]:          name = (              control_name[: -len(_Factory._START_SUFFIX)]              if control_name.endswith(_Factory._START_SUFFIX)              else control_name[: -len(_Factory._END_SUFFIX)]              if control_name.endswith(_Factory._END_SUFFIX)              else control_name          )          name = name[len(_Factory.__TAIPY_NAME_SPACE) :] if name.startswith(_Factory.__TAIPY_NAME_SPACE) else name          prop = _Factory.__CONTROL_DEFAULT_PROP_NAME.get(name)          if prop is None:              _, _, element = _Factory.__get_library_element(name)              if element:                  prop = element.default_attribute          return prop        @staticmethod      def __get_library_element(name: str):          parts = name.split(\".\")          if len(parts) > 1:              element_name = \".\".join(parts[1:])              for lib in _Factory.__LIBRARIES.get(parts[0], []):                  elts = lib.get_elements()                  if isinstance(elts, dict):                      element = elts.get(element_name)                      if element:                          return lib, element_name, element          else:              element_name = name              for libs in list(_Factory.__LIBRARIES.values()):                  for lib in libs:                      elts = lib.get_elements()                      if isinstance(elts, dict):                          element = elts.get(element_name)                          if element:                              return lib, element_name, element          return None, None, None        @staticmethod      def call_builder(          gui: \"Gui\", name: str, all_properties: t.Optional[t.Dict[str, t.Any]] = None, is_html: t.Optional[bool] = False      ) -> t.Optional[t.Union[t.Any, t.Tuple[str, str]]]:          name = name[len(_Factory.__TAIPY_NAME_SPACE) :] if name.startswith(_Factory.__TAIPY_NAME_SPACE) else name          builder = _Factory.__CONTROL_BUILDERS.get(name)          built = None          if builder is None:              lib, element_name, element = _Factory.__get_library_element(name)              if lib:                  from ..extension.library import Element                    if isinstance(element, Element):                      return element._call_builder(element_name, gui, all_properties, lib, is_html)          else:              built = builder(gui, name, all_properties)          if isinstance(built, _Builder):              return built._build_to_string() if is_html else built.el          return None "}
{"text": "import contextlib  import json  import numbers  import time as _time  import typing as t  import xml.etree.ElementTree as etree  from datetime import date, datetime, time  from inspect import isclass  from urllib.parse import quote    from .._warnings import _warn  from ..partial import Partial  from ..types import PropertyType, _get_taipy_type  from ..utils import (      _date_to_string,      _get_broadcast_var_name,      _get_client_var_name,      _get_data_type,      _get_expr_var_name,      _getscopeattr,      _getscopeattr_drill,      _is_boolean,      _is_boolean_true,      _MapDict,      _to_camel_case,  )  from ..utils.chart_config_builder import _CHART_NAMES, _build_chart_config  from ..utils.table_col_builder import _enhance_columns, _get_name_indexed_property  from ..utils.types import _TaipyBase, _TaipyData  from .json import _TaipyJsonEncoder  from .utils import _add_to_dict_and_get, _get_columns_dict, _get_tuple_val    if t.TYPE_CHECKING:      from ..gui import Gui      class _Builder:      \"\"\"      Constructs an XML node that can be rendered as a React node.        This class can only be instantiated internally by Taipy.      \"\"\"        __keys: t.Dict[str, int] = {}        __BLOCK_CONTROLS = [\"dialog\", \"expandable\", \"pane\", \"part\"]        __TABLE_COLUMNS_DEPS = [          \"data\",          \"columns\",          \"date_format\",          \"number_format\",          \"nan_value\",          \"width\",          \"filter\",          \"editable\",          \"group_by\",          \"apply\",          \"style\",          \"tooltip\",      ]        def __init__(          self,          gui: \"Gui\",          control_type: str,          element_name: str,          attributes: t.Optional[t.Dict[str, t.Any]],          hash_names: t.Dict[str, str] = {},          default_value=\"<Empty>\",          lib_name: str = \"taipy\",      ):          from ..gui import Gui          from .factory import _Factory            self.el = etree.Element(element_name)            self.__control_type = control_type          self.__element_name = element_name          self.__lib_name = lib_name          self.__attributes = attributes or {}          self.__hashes = hash_names.copy()          self.__update_vars: t.List[str] = []          self.__gui: Gui = gui            self.__default_property_name = _Factory.get_default_property_name(control_type) or \"\"          default_property_value = self.__attributes.get(self.__default_property_name, None)          if default_property_value is None and default_value is not None:              self.__attributes[self.__default_property_name] = default_value            # Bind properties dictionary to attributes if condition is matched (will leave the binding for function at the builder )          if \"properties\" in self.__attributes:              (prop_dict, prop_hash) = _Builder.__parse_attribute_value(gui, self.__attributes[\"properties\"])              if prop_hash is None:                  prop_hash = prop_dict                  prop_hash = self.__gui._bind_var(prop_hash)                  if hasattr(self.__gui._bindings(), prop_hash):                      prop_dict = _getscopeattr(self.__gui, prop_hash)              if isinstance(prop_dict, (dict, _MapDict)):                  # Iterate through prop_dict and append to self.attributes                  var_name, _ = gui._get_real_var_name(prop_hash)                  for k, v in prop_dict.items():                      (val, key_hash) = _Builder.__parse_attribute_value(gui, v)                      self.__attributes[k] = (                          f\"{{None if ({var_name}) is None else ({var_name}).get('{k}')}}\" if key_hash is None else v                      )              else:                  _warn(f\"{self.__control_type}.properties ({prop_hash}) must be a dict.\")            # Bind potential function and expressions in self.attributes          self.__hashes.update(_Builder._get_variable_hash_names(gui, self.__attributes, hash_names))            # set classname          self.__set_class_names()          # define a unique key          self.set_attribute(\"key\", _Builder._get_key(self.__element_name))        @staticmethod      def __parse_attribute_value(gui: \"Gui\", value) -> t.Tuple:          if isinstance(value, str) and gui._is_expression(value):              hash_value = gui._evaluate_expr(value)              try:                  func = gui._get_user_function(hash_value)                  if callable(func):                      return (func, hash_value)                  return (_getscopeattr_drill(gui, hash_value), hash_value)              except AttributeError:                  _warn(f\"Expression '{value}' cannot be evaluated.\")          return (value, None)        @staticmethod      def _get_variable_hash_names(          gui: \"Gui\", attributes: t.Dict[str, t.Any], hash_names: t.Dict[str, str] = {}      ) -> t.Dict[str, str]:          hashes = {}          # Bind potential function and expressions in self.attributes          for k, v in attributes.items():              val = v              hashname = hash_names.get(k)              if hashname is None:                  if callable(v):                      if v.__name__ == \"<lambda>\":                          hashname = _get_expr_var_name(v.__code__)                          gui._bind_var_val(hashname, v)                      else:                          hashname = _get_expr_var_name(v.__name__)                  elif isinstance(v, str):                      # need to unescape the double quotes that were escaped during preprocessing                      (val, hashname) = _Builder.__parse_attribute_value(gui, v.replace('\\\\\"', '\"'))                    if val is not None or hashname:                      attributes[k] = val                  if hashname:                      hashes[k] = hashname          return hashes        @staticmethod      def __to_string(x: t.Any) -> str:          return str(x)        @staticmethod      def _get_key(name: str) -> str:          key_index = _Builder.__keys.get(name, 0)          _Builder.__keys[name] = key_index + 1          return f\"{name}.{key_index}\"        @staticmethod      def _reset_key() -> None:          _Builder.__keys = {}        def __get_list_of_(self, name: str):          lof = self.__attributes.get(name)          if isinstance(lof, str):              lof = list(lof.split(\";\"))          return lof        def get_name_indexed_property(self, name: str) -> t.Dict[str, t.Any]:          \"\"\"          TODO-undocumented          Returns all properties defined as <property name>[<named index>] as a dict.            Arguments:                name (str): The property name.          \"\"\"          return _get_name_indexed_property(self.__attributes, name)        def __get_boolean_attribute(self, name: str, default_value=False):          boolattr = self.__attributes.get(name, default_value)          return _is_boolean_true(boolattr) if isinstance(boolattr, str) else bool(boolattr)        def set_boolean_attribute(self, name: str, value: bool):          \"\"\"          TODO-undocumented          Defines a React Boolean attribute (attr={true|false}).            Arguments:              name (str): The property name.              value (bool): the boolean value.          \"\"\"          return self.__set_react_attribute(_to_camel_case(name), value)        def set_dict_attribute(self, name: str, default_value: t.Optional[t.Dict[str, t.Any]] = None):          \"\"\"          TODO-undocumented          Defines a React attribute as a stringified json dict.          The original property can be a dict or a string formed as <key 1>:<value 1>;<key 2>:<value 2>.            Arguments:              name (str): The property name.              default value (dict): used if no value is specified.          \"\"\"          dict_attr = self.__attributes.get(name)          if dict_attr is None:              dict_attr = default_value          if dict_attr is not None:              if isinstance(dict_attr, str):                  vals = [x.strip().split(\":\") for x in dict_attr.split(\";\")]                  dict_attr = {val[0].strip(): val[1].strip() for val in vals if len(val) > 1}              if isinstance(dict_attr, (dict, _MapDict)):                  self.__set_json_attribute(_to_camel_case(name), dict_attr)              else:                  _warn(f\"{self.__element_name}: {name} should be a dict: '{str(dict_attr)}'.\")          return self        def set_dynamic_dict_attribute(self, name: str, default_value: t.Optional[t.Dict[str, t.Any]] = None):          \"\"\"          TODO-undocumented          Defines a React attribute as a stringified json dict.          The original property can be a dict or a string formed as <key 1>:<value 1>;<key 2>:<value 2>.            Arguments:              name (str): The property name.              default value (dict): used if no value is specified.          \"\"\"          dict_attr = self.__attributes.get(name)          if dict_attr is None:              dict_attr = default_value          if dict_attr is not None:              if isinstance(dict_attr, str):                  vals = [x.strip().split(\":\") for x in dict_attr.split(\";\")]                  dict_attr = {val[0].strip(): val[1].strip() for val in vals if len(val) > 1}              if isinstance(dict_attr, (dict, _MapDict)):                  self.__set_json_attribute(_to_camel_case(\"default_\" + name), dict_attr)              else:                  _warn(f\"{self.__element_name}: {name} should be a dict: '{str(dict_attr)}'.\")          if dict_hash := self.__hashes.get(name):              dict_hash = self.__get_typed_hash_name(dict_hash, PropertyType.dynamic_dict)              prop_name = _to_camel_case(name)              self.__update_vars.append(f\"{prop_name}={dict_hash}\")              self.__set_react_attribute(prop_name, dict_hash)          return self        def __set_json_attribute(self, name, value):          return self.set_attribute(name, json.dumps(value, cls=_TaipyJsonEncoder))        def __set_list_of_(self, name: str):          lof = self.__get_list_of_(name)          if not isinstance(lof, (list, tuple)):              if lof is not None:                  _warn(f\"{self.__element_name}: {name} should be a list.\")              return self          return self.__set_json_attribute(_to_camel_case(name), lof)        def set_number_attribute(self, name: str, default_value: t.Optional[str] = None, optional: t.Optional[bool] = True):          \"\"\"          TODO-undocumented          Defines a React number attribute (attr={<number>}).            Arguments:                name (str): The property name.              default_value (optional(str)): the default value as a string.              optional (bool): Default to True, the property is required if False.          \"\"\"          value = self.__attributes.get(name, default_value)          if value is None:              if not optional:                  _warn(f\"Property {name} is required for control {self.__control_type}.\")              return self          if isinstance(value, str):              try:                  val = float(value)              except ValueError:                  raise ValueError(f\"Property {name} expects a number for control {self.__control_type}\")          elif isinstance(value, numbers.Number):              val = value  # type: ignore          else:              raise ValueError(                  f\"Property {name} expects a number for control {self.__control_type}, received {type(value)}\"              )          return self.__set_react_attribute(_to_camel_case(name), val)        def __set_string_attribute(          self, name: str, default_value: t.Optional[str] = None, optional: t.Optional[bool] = True      ):          strattr = self.__attributes.get(name, default_value)          if strattr is None:              if not optional:                  _warn(f\"Property {name} is required for control {self.__control_type}.\")              return self          return self.set_attribute(_to_camel_case(name), str(strattr))        def __set_dynamic_string_attribute(          self,          name: str,          default_value: t.Optional[str] = None,          with_update: t.Optional[bool] = False,          dynamic_property_name: t.Optional[str] = None,      ):          str_val = self.__attributes.get(name, default_value)          if str_val is not None:              self.set_attribute(                  _to_camel_case(f\"default_{name}\" if dynamic_property_name is None else name), str(str_val)              )          if hash_name := self.__hashes.get(name):              prop_name = _to_camel_case(name if dynamic_property_name is None else dynamic_property_name)              if with_update:                  self.__update_vars.append(f\"{prop_name}={hash_name}\")              self.__set_react_attribute(prop_name, hash_name)          return self        def __set_function_attribute(          self, name: str, default_value: t.Optional[str] = None, optional: t.Optional[bool] = True      ):          strattr = self.__attributes.get(name, default_value)          if strattr is None:              if not optional:                  _warn(f\"Property {name} is required for control {self.__control_type}.\")              return self          elif callable(strattr):              strattr = self.__hashes.get(name)              if strattr is None:                  return self          elif strattr:              strattr = str(strattr)              func = self.__gui._get_user_function(strattr)              if func == strattr:                  _warn(f\"{self.__control_type}.{name}: {strattr} is not a function.\")          return self.set_attribute(_to_camel_case(name), strattr) if strattr else self        def __set_string_or_number_attribute(self, name: str, default_value: t.Optional[t.Any] = None):          attr = self.__attributes.get(name, default_value)          if attr is None:              return self          if isinstance(attr, numbers.Number):              return self.__set_react_attribute(_to_camel_case(name), attr)          else:              return self.set_attribute(_to_camel_case(name), attr)        def __set_react_attribute(self, name: str, value: t.Any):          return self.set_attribute(name, \"{!\" + (str(value).lower() if isinstance(value, bool) else str(value)) + \"!}\")        def _get_adapter(self, var_name: str, property_name: t.Optional[str] = None, multi_selection=True):  # noqa: C901          property_name = var_name if property_name is None else property_name          lov = self.__get_list_of_(var_name)          if isinstance(lov, list):              adapter = self.__attributes.get(\"adapter\")              if adapter and isinstance(adapter, str):                  adapter = self.__gui._get_user_function(adapter)              if adapter and not callable(adapter):                  _warn(\"'adapter' property value is invalid.\")                  adapter = None              var_type = self.__attributes.get(\"type\")              if isclass(var_type):                  var_type = var_type.__name__  # type: ignore              if not isinstance(var_type, str):                  elt = None                  if len(lov) == 0:                      value = self.__attributes.get(\"value\")                      if isinstance(value, list):                          if len(value) > 0:                              elt = value[0]                      else:                          elt = value                  else:                      elt = lov[0]                  var_type = self.__gui._get_unique_type_adapter(type(elt).__name__)              if adapter is None:                  adapter = self.__gui._get_adapter_for_type(var_type)              elif var_type == str.__name__ and callable(adapter):                  var_type += (                      _get_expr_var_name(str(adapter.__code__))                      if adapter.__name__ == \"<lambda>\"                      else _get_expr_var_name(adapter.__name__)                  )              if lov_name := self.__hashes.get(var_name):                  if adapter is None:                      adapter = self.__gui._get_adapter_for_type(lov_name)                  else:                      self.__gui._add_type_for_var(lov_name, var_type)              if value_name := self.__hashes.get(\"value\"):                  if adapter is None:                      adapter = self.__gui._get_adapter_for_type(value_name)                  else:                      self.__gui._add_type_for_var(value_name, var_type)              if adapter is not None:                  self.__gui._add_adapter_for_type(var_type, adapter)  # type: ignore                ret_list = []              if len(lov) > 0:                  for elt in lov:                      ret = self.__gui._run_adapter(                          t.cast(t.Callable, adapter), elt, adapter.__name__ if callable(adapter) else \"adapter\"                      )  # type: ignore                      if ret is not None:                          ret_list.append(ret)              self.__attributes[f\"default_{property_name}\"] = ret_list                ret_list = []              value = self.__attributes.get(\"value\")              val_list = value if isinstance(value, list) else [value]              for val in val_list:                  ret = self.__gui._run_adapter(                      t.cast(t.Callable, adapter), val, adapter.__name__ if callable(adapter) else \"adapter\", id_only=True                  )  # type: ignore                  if ret is not None:                      ret_list.append(ret)              if multi_selection:                  self.__set_default_value(\"value\", ret_list)              else:                  ret_val = ret_list[0] if len(ret_list) else \"\"                  if ret_val == \"-1\" and self.__attributes.get(\"unselected_value\") is not None:                      ret_val = str(self.__attributes.get(\"unselected_value\", \"\"))                  self.__set_default_value(\"value\", ret_val)          return self        def __filter_attribute_names(self, names: t.Iterable[str]):          return [k for k in self.__attributes if k in names or any(k.startswith(n + \"[\") for n in names)]        def __get_holded_name(self, key: str):          name = self.__hashes.get(key)          if name:              v = self.__attributes.get(key)              if isinstance(v, _TaipyBase):                  return name[: len(v.get_hash()) + 1]          return name        def __filter_attributes_hashes(self, keys: t.List[str]):          hash_names = [k for k in self.__hashes if k in keys]          attr_names = [k for k in keys if k not in hash_names]          return (              {k: v for k, v in self.__attributes.items() if k in attr_names},              {k: self.__get_holded_name(k) for k in self.__hashes if k in hash_names},          )        def __build_rebuild_fn(self, fn_name: str, attribute_names: t.Iterable[str]):          rebuild = self.__attributes.get(\"rebuild\", False)          rebuild_hash = self.__hashes.get(\"rebuild\")          if rebuild_hash or rebuild:              attributes, hashes = self.__filter_attributes_hashes(self.__filter_attribute_names(attribute_names))              rebuild_name = f\"bool({self.__gui._get_real_var_name(rebuild_hash)[0]})\" if rebuild_hash else \"None\"              try:                  self.__gui._set_building(True)                  return self.__gui._evaluate_expr(                      \"{\"                      + f'{fn_name}({rebuild}, {rebuild_name}, \"{quote(json.dumps(attributes))}\", \"{quote(json.dumps(hashes))}\", {\", \".join([f\"{k}={v2}\" for k, v2 in {v: self.__gui._get_real_var_name(v)[0] for v in hashes.values()}.items()])})'                      + \"}\"                  )              finally:                  self.__gui._set_building(False)          return None        def _get_dataframe_attributes(self) -> \"_Builder\":          date_format = _add_to_dict_and_get(self.__attributes, \"date_format\", \"MM/dd/yyyy\")          data = self.__attributes.get(\"data\")          data_hash = self.__hashes.get(\"data\", \"\")          col_types = self.__gui._accessors._get_col_types(data_hash, _TaipyData(data, data_hash))          col_dict = _get_columns_dict(              data, self.__attributes.get(\"columns\", {}), col_types, date_format, self.__attributes.get(\"number_format\")          )            rebuild_fn_hash = self.__build_rebuild_fn(              self.__gui._get_rebuild_fn_name(\"_tbl_cols\"), _Builder.__TABLE_COLUMNS_DEPS          )          if rebuild_fn_hash:              self.__set_react_attribute(\"columns\", rebuild_fn_hash)          if col_dict is not None:              _enhance_columns(self.__attributes, self.__hashes, col_dict, self.__element_name)              self.__set_json_attribute(\"defaultColumns\", col_dict)          if line_style := self.__attributes.get(\"style\"):              if callable(line_style):                  value = self.__hashes.get(\"style\")              elif isinstance(line_style, str):                  value = line_style.strip()              else:                  value = None              if value in col_types.keys():                  _warn(f\"{self.__element_name}: style={value} must not be a column name.\")              elif value:                  self.set_attribute(\"lineStyle\", value)          if tooltip := self.__attributes.get(\"tooltip\"):              if callable(tooltip):                  value = self.__hashes.get(\"tooltip\")              elif isinstance(tooltip, str):                  value = tooltip.strip()              else:                  value = None              if value in col_types.keys():                  _warn(f\"{self.__element_name}: tooltip={value} must not be a column name.\")              elif value:                  self.set_attribute(\"tooltip\", value)          return self        def _get_chart_config(self, default_type: str, default_mode: str):          self.__attributes[\"_default_type\"] = default_type          self.__attributes[\"_default_mode\"] = default_mode          rebuild_fn_hash = self.__build_rebuild_fn(              self.__gui._get_rebuild_fn_name(\"_chart_conf\"), _CHART_NAMES + (\"_default_type\", \"_default_mode\", \"data\")          )          if rebuild_fn_hash:              self.__set_react_attribute(\"config\", rebuild_fn_hash)            # read column definitions          data = self.__attributes.get(\"data\")          data_hash = self.__hashes.get(\"data\", \"\")          col_types = self.__gui._accessors._get_col_types(data_hash, _TaipyData(data, data_hash))            config = _build_chart_config(self.__gui, self.__attributes, col_types)            self.__set_json_attribute(\"defaultConfig\", config)          self._set_chart_selected(max=len(config.get(\"traces\", \"\")))          self.__set_refresh_on_update()          return self        def _set_string_with_check(self, var_name: str, values: t.List[str], default_value: t.Optional[str] = None):          value = self.__attributes.get(var_name, default_value)          if value is not None:              value = str(value).lower()              self.__attributes[var_name] = value              if value not in values:                  _warn(f\"{self.__element_name}: {var_name}={value} should be in {values}.\")              else:                  self.__set_string_attribute(var_name, default_value)          return self        def __set_list_attribute(          self, name: str, hash_name: t.Optional[str], val: t.Any, elt_type: t.Type, dynamic=True      ) -> t.List[str]:          if not hash_name and isinstance(val, str):              val = [elt_type(t.strip()) for t in val.split(\";\")]          if isinstance(val, list):              if hash_name and dynamic:                  self.__set_react_attribute(name, hash_name)                  return [f\"{name}={hash_name}\"]              else:                  self.__set_json_attribute(name, val)          elif val is not None:              _warn(f\"{self.__element_name}: {name} should be a list of {elt_type}.\")          return []        def _set_chart_selected(self, max=0):          name = \"selected\"          default_sel = self.__attributes.get(name)          idx = 1          name_idx = f\"{name}[{idx}]\"          sel = self.__attributes.get(name_idx)          while idx <= max:              if sel is not None or default_sel is not None:                  self.__update_vars.extend(                      self.__set_list_attribute(                          f\"{name}{idx - 1}\",                          self.__hashes.get(name_idx if sel is not None else name),                          sel if sel is not None else default_sel,                          int,                      )                  )              idx += 1              name_idx = f\"{name}[{idx}]\"              sel = self.__attributes.get(name_idx)        def _get_list_attribute(self, name: str, list_type: PropertyType):          varname = self.__hashes.get(name)          if varname is None:              list_val = self.__attributes.get(name)              if isinstance(list_val, str):                  list_val = list(list_val.split(\";\"))              if isinstance(list_val, list):                  # TODO catch the cast exception                  if list_type.value == PropertyType.number.value:                      list_val = [int(v) for v in list_val]                  else:                      list_val = [int(v) for v in list_val]              else:                  if list_val is not None:                      _warn(f\"{self.__element_name}: {name} should be a list.\")                  list_val = []              self.__set_react_attribute(_to_camel_case(name), list_val)          else:              self.__set_react_attribute(_to_camel_case(name), varname)          return self        def __set_class_names(self):          self.set_attribute(\"libClassName\", self.__lib_name + \"-\" + self.__control_type.replace(\"_\", \"-\"))          return self.__set_dynamic_string_attribute(\"class_name\", dynamic_property_name=\"dynamic_class_name\")        def _set_dataType(self):          value = self.__attributes.get(\"value\")          return self.set_attribute(\"dataType\", _get_data_type(value))        def _set_file_content(self, var_name: str = \"content\"):          if hash_name := self.__hashes.get(var_name):              self.__set_update_var_name(hash_name)          else:              _warn(f\"file_selector: {var_name} should be bound.\")          return self        def _set_content(self, var_name: str = \"content\", image=True):          content = self.__attributes.get(var_name)          hash_name = self.__hashes.get(var_name)          if content is None and hash_name is None:              return self          value = self.__gui._get_content(hash_name or var_name, content, image)          if hash_name:              hash_name = self.__get_typed_hash_name(hash_name, PropertyType.image if image else PropertyType.content)          if hash_name:              self.__set_react_attribute(                  var_name,                  _get_client_var_name(hash_name),              )          return self.set_attribute(_to_camel_case(f\"default_{var_name}\"), value)        def _set_lov(self, var_name=\"lov\", property_name: t.Optional[str] = None):          property_name = var_name if property_name is None else property_name          self.__set_list_of_(f\"default_{property_name}\")          if hash_name := self.__hashes.get(var_name):              hash_name = self.__get_typed_hash_name(hash_name, PropertyType.lov)              self.__update_vars.append(f\"{property_name}={hash_name}\")              self.__set_react_attribute(property_name, hash_name)          return self        def __set_dynamic_string_list(self, var_name: str, default_value: t.Any):          hash_name = self.__hashes.get(var_name)          loi = self.__attributes.get(var_name)          if loi is None:              loi = default_value          if isinstance(loi, str):              loi = [s.strip() for s in loi.split(\";\") if s.strip()]          if isinstance(loi, list):              self.__set_json_attribute(_to_camel_case(f\"default_{var_name}\"), loi)          if hash_name:              self.__update_vars.append(f\"{var_name}={hash_name}\")              self.__set_react_attribute(var_name, hash_name)          return self        def __set_dynamic_number_attribute(self, var_name: str, default_value: t.Any):          hash_name = self.__hashes.get(var_name)          numVal = self.__attributes.get(var_name)          if numVal is None:              numVal = default_value          if isinstance(numVal, str):              try:                  numVal = float(numVal)              except Exception as e:                  _warn(f\"{self.__element_name}: {var_name} cannot be transformed into a number\", e)                  numVal = 0          if isinstance(numVal, numbers.Number):              self.__set_react_attribute(_to_camel_case(f\"default_{var_name}\"), numVal)          elif numVal is not None:              _warn(f\"{self.__element_name}: {var_name} value is not valid ({numVal}).\")          if hash_name:              hash_name = self.__get_typed_hash_name(hash_name, PropertyType.number)              self.__update_vars.append(f\"{var_name}={hash_name}\")              self.__set_react_attribute(var_name, hash_name)          return self        def __set_default_value(          self,          var_name: str,          value: t.Optional[t.Any] = None,          native_type: bool = False,          var_type: t.Optional[PropertyType] = None,      ):          if value is None:              value = self.__attributes.get(var_name)          default_var_name = _to_camel_case(f\"default_{var_name}\")          if isinstance(value, (datetime, date, time)):              return self.set_attribute(default_var_name, _date_to_string(value))          elif isinstance(value, str):              return self.set_attribute(default_var_name, value)          elif native_type and isinstance(value, numbers.Number):              return self.__set_react_attribute(default_var_name, value)          elif value is None:              return self.__set_react_attribute(default_var_name, \"null\")          elif var_type == PropertyType.lov_value:              # Done by _get_adapter              return self          elif isclass(var_type) and issubclass(var_type, _TaipyBase):  # type: ignore              return self.__set_default_value(var_name, t.cast(t.Callable, var_type)(value, \"\").get())          else:              return self.__set_json_attribute(default_var_name, value)        def __set_update_var_name(self, hash_name: str):          return self.set_attribute(\"updateVarName\", hash_name)        def set_value_and_default(          self,          var_name: t.Optional[str] = None,          with_update=True,          with_default=True,          native_type=False,          var_type: t.Optional[PropertyType] = None,          default_val: t.Any = None,      ):          \"\"\"          TODO-undocumented          Sets the value associated with the default property.            Arguments:                var_name (str): The property name (default to default property name).              with_update (optional(bool)): Should the attribute be dynamic (default True).              with_default (optional(bool)): Should a default attribute be set (default True).              native_type (optional(bool)): If var_type == dynamic_number, parse the value to number.              var_type (optional(PropertyType)): the property type (default to string).              default_val (optional(Any)): the default value.          \"\"\"          var_name = self.__default_property_name if var_name is None else var_name          if var_type == PropertyType.slider_value:              if self.__attributes.get(\"lov\"):                  var_type = PropertyType.lov_value                  native_type = False              else:                  var_type = (                      PropertyType.dynamic_lo_numbers                      if isinstance(self.__attributes.get(\"value\"), list)                      else PropertyType.dynamic_number                  )                  native_type = True          if var_type == PropertyType.dynamic_boolean:              return self.set_attributes([(var_name, var_type, bool(default_val), with_update)])          if hash_name := self.__hashes.get(var_name):              hash_name = self.__get_typed_hash_name(hash_name, var_type)              self.__set_react_attribute(                  _to_camel_case(var_name),                  _get_client_var_name(hash_name),              )              if with_update:                  self.__set_update_var_name(hash_name)              if with_default:                  if native_type:                      val = self.__attributes.get(var_name)                      if native_type and isinstance(val, str):                          with contextlib.suppress(Exception):                              val = float(val)                      self.__set_default_value(var_name, val, native_type=native_type)                  else:                      self.__set_default_value(var_name, var_type=var_type)          else:              value = self.__attributes.get(var_name)              if value is not None:                  if native_type:                      if isinstance(value, str):                          with contextlib.suppress(Exception):                              value = float(value)                      if isinstance(value, (int, float)):                          return self.__set_react_attribute(_to_camel_case(var_name), value)                  self.set_attribute(_to_camel_case(var_name), value)          return self        def _set_labels(self, var_name: str = \"labels\"):          if value := self.__attributes.get(var_name):              if _is_boolean_true(value):                  return self.__set_react_attribute(_to_camel_case(var_name), True)              elif isinstance(value, (dict, _MapDict)):                  return self.set_dict_attribute(var_name)          return self        def _set_partial(self):          if self.__control_type not in _Builder.__BLOCK_CONTROLS:              return self          if partial := self.__attributes.get(\"partial\"):              if self.__attributes.get(\"page\"):                  _warn(f\"{self.__element_name} control: page and partial should not be both defined.\")              if isinstance(partial, Partial):                  self.__attributes[\"page\"] = partial._route                  self.__set_react_attribute(\"partial\", partial._route)                  self.__set_react_attribute(\"defaultPartial\", True)          return self        def _set_propagate(self):          val = self.__get_boolean_attribute(\"propagate\", self.__gui._config.config.get(\"propagate\"))          return self if val else self.set_boolean_attribute(\"propagate\", False)        def __set_refresh_on_update(self):          if self.__update_vars:              self.set_attribute(\"updateVars\", \";\".join(self.__update_vars))          return self        def _set_table_pagesize_options(self, default_size=[50, 100, 500]):          page_size_options = self.__attributes.get(\"page_size_options\", default_size)          if isinstance(page_size_options, str):              try:                  page_size_options = [int(s.strip()) for s in page_size_options.split(\";\")]              except Exception as e:                  _warn(f\"{self.__element_name}: page_size_options value is invalid ({page_size_options})\", e)          if isinstance(page_size_options, list):              self.__set_json_attribute(\"pageSizeOptions\", page_size_options)          else:              _warn(f\"{self.__element_name}: page_size_options should be a list.\")          return self        def _set_input_type(self, type_name: str, allow_password=False):          if allow_password and self.__get_boolean_attribute(\"password\", False):              return self.set_attribute(\"type\", \"password\")          return self.set_attribute(\"type\", type_name)        def _set_kind(self):          if self.__attributes.get(\"theme\", False):              self.set_attribute(\"kind\", \"theme\")          return self        def __get_typed_hash_name(self, hash_name: str, var_type: t.Optional[PropertyType]) -> str:          if taipy_type := _get_taipy_type(var_type):              expr = self.__gui._get_expr_from_hash(hash_name)              hash_name = self.__gui._evaluate_bind_holder(taipy_type, expr)          return hash_name        def __set_dynamic_bool_attribute(self, name: str, def_val: t.Any, with_update: bool, update_main=True):          hash_name = self.__hashes.get(name)          val = self.__get_boolean_attribute(name, def_val)          default_name = f\"default_{name}\" if hash_name is not None else name          if val != def_val:              self.set_boolean_attribute(default_name, val)          if hash_name is not None:              hash_name = self.__get_typed_hash_name(hash_name, PropertyType.dynamic_boolean)              self.__set_react_attribute(_to_camel_case(name), _get_client_var_name(hash_name))              if with_update:                  if update_main:                      self.__set_update_var_name(hash_name)                  else:                      self.__update_vars.append(f\"{_to_camel_case(name)}={hash_name}\")        def __set_dynamic_property_without_default(          self, name: str, property_type: PropertyType, optional: t.Optional[bool] = False      ):          hash_name = self.__hashes.get(name)          if hash_name is None:              if not optional:                  _warn(f\"{self.__element_name}.{name} should be bound.\")          else:              hash_name = self.__get_typed_hash_name(hash_name, property_type)              self.__update_vars.append(f\"{_to_camel_case(name)}={hash_name}\")              self.__set_react_attribute(_to_camel_case(name), _get_client_var_name(hash_name))          return self        def __set_html_content(self, name: str, property_name: str, property_type: PropertyType):          hash_name = self.__hashes.get(name)          if not hash_name:              return self          front_var = self.__get_typed_hash_name(hash_name, property_type)          self.set_attribute(              _to_camel_case(f\"default_{property_name}\"),              self.__gui._get_user_content_url(                  None,                  {                      \"variable_name\": front_var,                      self.__gui._HTML_CONTENT_KEY: str(_time.time()),                  },              ),          )          return self.__set_react_attribute(_to_camel_case(property_name), _get_client_var_name(front_var))        def set_attributes(self, attributes: t.List[tuple]):  # noqa: C901          \"\"\"          TODO-undocumented          Sets the attributes from the property with type and default value.            Arguments:                attributes (list(tuple)): The list of attributes as (property name, property type, default value).          \"\"\"          for attr in attributes:              if not isinstance(attr, tuple):                  attr = (attr,)              var_type = _get_tuple_val(attr, 1, PropertyType.string)              if var_type == PropertyType.boolean:                  def_val = _get_tuple_val(attr, 2, False)                  val = self.__get_boolean_attribute(attr[0], def_val)                  if val != def_val:                      self.set_boolean_attribute(attr[0], val)              elif var_type == PropertyType.dynamic_boolean:                  self.__set_dynamic_bool_attribute(                      attr[0],                      _get_tuple_val(attr, 2, False),                      _get_tuple_val(attr, 3, False),                      _get_tuple_val(attr, 4, True),                  )              elif var_type == PropertyType.number:                  self.set_number_attribute(attr[0], _get_tuple_val(attr, 2, None))              elif var_type == PropertyType.dynamic_number:                  self.__set_dynamic_number_attribute(attr[0], _get_tuple_val(attr, 2, None))              elif var_type == PropertyType.string:                  self.__set_string_attribute(attr[0], _get_tuple_val(attr, 2, None), _get_tuple_val(attr, 3, True))              elif var_type == PropertyType.dynamic_string:                  self.__set_dynamic_string_attribute(                      attr[0], _get_tuple_val(attr, 2, None), _get_tuple_val(attr, 3, False)                  )              elif var_type == PropertyType.string_list:                  self.__set_list_attribute(                      attr[0], self.__hashes.get(attr[0]), self.__attributes.get(attr[0]), str, False                  )              elif var_type == PropertyType.function:                  self.__set_function_attribute(attr[0], _get_tuple_val(attr, 2, None), _get_tuple_val(attr, 3, True))              elif var_type == PropertyType.react:                  prop_name = _to_camel_case(attr[0])                  if hash_name := self.__hashes.get(attr[0]):                      self.__update_vars.append(f\"{prop_name}={hash_name}\")                      self.__set_react_attribute(prop_name, hash_name)                  else:                      self.__set_react_attribute(prop_name, self.__attributes.get(attr[0], _get_tuple_val(attr, 2, None)))              elif var_type == PropertyType.broadcast:                  self.__set_react_attribute(                      _to_camel_case(attr[0]), _get_broadcast_var_name(_get_tuple_val(attr, 2, None))                  )              elif var_type == PropertyType.string_or_number:                  self.__set_string_or_number_attribute(attr[0], _get_tuple_val(attr, 2, None))              elif var_type == PropertyType.dict:                  self.set_dict_attribute(attr[0], _get_tuple_val(attr, 2, None))              elif var_type == PropertyType.dynamic_dict:                  self.set_dynamic_dict_attribute(attr[0], _get_tuple_val(attr, 2, None))              elif var_type == PropertyType.dynamic_list:                  self.__set_dynamic_string_list(attr[0], _get_tuple_val(attr, 2, None))              elif var_type == PropertyType.boolean_or_list:                  if _is_boolean(self.__attributes.get(attr[0])):                      self.__set_dynamic_bool_attribute(attr[0], _get_tuple_val(attr, 2, False), True, update_main=False)                  else:                      self.__set_dynamic_string_list(attr[0], _get_tuple_val(attr, 2, None))              elif var_type == PropertyType.data:                  self.__set_dynamic_property_without_default(attr[0], var_type)              elif var_type == PropertyType.lov:                  self._get_adapter(attr[0])  # need to be called before set_lov                  self._set_lov(attr[0])              elif var_type == PropertyType.lov_value:                  self.__set_dynamic_property_without_default(                      attr[0], var_type, _get_tuple_val(attr, 2, None) == \"optional\"                  )              elif var_type == PropertyType.toHtmlContent:                  self.__set_html_content(attr[0], \"page\", var_type)              elif isclass(var_type) and issubclass(var_type, _TaipyBase):                  if hash_name := self.__hashes.get(attr[0]):                      prop_name = _to_camel_case(attr[0])                      expr = self.__gui._get_expr_from_hash(hash_name)                      hash_name = self.__gui._evaluate_bind_holder(var_type, expr)                      self.__update_vars.append(f\"{prop_name}={hash_name}\")                      self.__set_react_attribute(prop_name, hash_name)                self.__set_refresh_on_update()          return self        def set_attribute(self, name: str, value: t.Any):          \"\"\"          TODO-undocumented          Sets an attribute.            Arguments:                name (str): The name of the attribute.              value (Any): The value of the attribute (must be json serializable).          \"\"\"          self.el.set(name, value)          return self        def get_element(self):          \"\"\"          TODO-undocumented          Returns the xml.etree.ElementTree.Element          \"\"\"          return self.el        def _build_to_string(self):          el_str = str(etree.tostring(self.el, encoding=\"utf8\").decode(\"utf8\"))          el_str = el_str.replace(\"<?xml version='1.0' encoding='utf8'?>\\n\", \"\")          el_str = el_str.replace(\"/>\", \">\")          return el_str, self.__element_name "}
{"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": "import re  import typing as t  from typing import Any, List, Tuple    from markdown.preprocessors import Preprocessor as MdPreprocessor    from ..._warnings import _warn  from ..builder import _Builder  from .factory import _MarkdownFactory    if t.TYPE_CHECKING:      from ...gui import Gui      class _Preprocessor(MdPreprocessor):      # ----------------------------------------------------------------------      # Finds, in the Markdown text, control declaration constructs:      #     <|<some value>|>      # or      #     <|<some value>|<control_type>|>      # or      #     <|<some value>|<control_type>|<prop_name[=propvalue]>>      # or      #     <|<control_type>|<prop_name[=propvalue]>>      #      # These constructs are converted a fragment that the ControlPattern      # processes to create the components that get generated.      #     <control_type> prop_name=\"prop_value\" ...      # Note that if a value is provided before the control_type, it is set      # as the default property value for that control type.      # The default control type is 'text'.      # ----------------------------------------------------------------------      # Control in Markdown      __CONTROL_RE = re.compile(r\"<\\|(.*?)\\|>\")      # Opening tag      __OPENING_TAG_RE = re.compile(r\"<([0-9a-zA-Z\\_\\.]*)\\|((?:(?!\\|>).)*)\\s*$\")      # Closing tag      __CLOSING_TAG_RE = re.compile(r\"^\\s*\\|([0-9a-zA-Z\\_\\.]*)>\")      # Link in Markdown      __LINK_RE = re.compile(r\"(\\[[^\\]]*?\\]\\([^\\)]*?\\))\")      # Split properties and control type      __SPLIT_RE = re.compile(r\"(?<!\\\\\\\\)\\|\")      # Property syntax: '<prop_name>[=<prop_value>]'      #   If <prop_value> is omitted:      #     '<prop_name>' is equivalent to '<prop_name>=true'      #     'not <prop_name>' is equivalent to '<prop_name>=false'      #       'not', 'dont', 'don't' are equivalent in this context      #  Note 1: 'not <prop_name>=<prop_value>' is an invalid syntax      #  Note 2: Space characters after the equal sign are significative      __PROPERTY_RE = re.compile(r\"((?:don'?t|not)\\s+)?([a-zA-Z][\\.a-zA-Z_$0-9]*(?:\\[(?:.*?)\\])?)\\s*(?:=(.*))?$\")        _gui: \"Gui\"        @staticmethod      def extend(md, gui, priority):          instance = _Preprocessor(md)          md.preprocessors.register(instance, \"taipy\", priority)          instance._gui = gui        def _make_prop_pair(self, prop_name: str, prop_value: str) -> Tuple[str, str]:          # Un-escape pipe character in property value          return (prop_name, prop_value.replace(\"\\\\|\", \"|\"))        def run(self, lines: List[str]) -> List[str]:          new_lines = []          tag_queue = []          for line_count, line in enumerate(lines, start=1):              new_line = \"\"              last_index = 0              # Opening tags              m = _Preprocessor.__OPENING_TAG_RE.search(line)              if m is not None:                  tag = \"part\"                  properties: List[Tuple[str, str]] = []                  if m.group(2):                      tag, properties = self._process_control(m.group(2), line_count, tag)                  if tag in _MarkdownFactory._TAIPY_BLOCK_TAGS:                      tag_queue.append((tag, line_count, m.group(1) or None))                      new_line_delimeter = \"\\n\" if line.startswith(\"<|\") else \"\\n\\n\"                      line = (                          line[: m.start()]                          + new_line_delimeter                          + _MarkdownFactory._TAIPY_START                          + tag                          + _MarkdownFactory._START_SUFFIX                      )                      for property in properties:                          prop_value = property[1].replace('\"', '\\\\\"')                          line += f' {property[0]}=\"{prop_value}\"'                      line += _MarkdownFactory._TAIPY_END + new_line_delimeter                  else:                      _warn(f\"Invalid tag name '{tag}' in line {line_count}.\")              # Other controls              for m in _Preprocessor.__CONTROL_RE.finditer(line):                  control_name, properties = self._process_control(m.group(1), line_count)                  new_line += line[last_index : m.start()]                  control_text = _MarkdownFactory._TAIPY_START + control_name                  for property in properties:                      prop_value = property[1].replace('\"', '\\\\\"')                      control_text += f' {property[0]}=\"{prop_value}\"'                  control_text += _MarkdownFactory._TAIPY_END                  new_line += control_text                  last_index = m.end()              new_line = line if last_index == 0 else new_line + line[last_index:]              # Add key attribute to links              line = new_line              new_line = \"\"              last_index = 0              for m in _Preprocessor.__LINK_RE.finditer(line):                  new_line += line[last_index : m.end()]                  new_line += \"{: key=\" + _Builder._get_key(\"link\") + \"}\"                  last_index = m.end()              new_line = line if last_index == 0 else new_line + line[last_index:]              # Look for a closing tag              m = _Preprocessor.__CLOSING_TAG_RE.search(new_line)              if m is not None:                  if len(tag_queue):                      open_tag, open_tag_line_count, open_tag_identifier = tag_queue.pop()                      close_tag_identifier = m.group(1)                      if close_tag_identifier and not open_tag_identifier:                          _warn(                              f\"Missing opening '{open_tag}' tag identifier '{close_tag_identifier}' in line {open_tag_line_count}.\"                          )                      if open_tag_identifier and not close_tag_identifier:                          _warn(                              f\"Missing closing '{open_tag}' tag identifier '{open_tag_identifier}' in line {line_count}.\"                          )                      if close_tag_identifier and open_tag_identifier and close_tag_identifier != open_tag_identifier:                          _warn(                              f\"Unmatched '{open_tag}' tag identifier in line {open_tag_line_count} and line {line_count}.\"                          )                      new_line = (                          new_line[: m.start()]                          + _MarkdownFactory._TAIPY_START                          + open_tag                          + _MarkdownFactory._END_SUFFIX                          + _MarkdownFactory._TAIPY_END                          + \"\\n\"                          + new_line[m.end() :]                      )                  else:                      new_line = (                          new_line[: m.start()]                          + f\"<div>No matching opened tag on line {line_count}</div>\"                          + new_line[m.end() :]                      )                      _warn(f\"Line {line_count} has an unmatched closing tag.\")              # append the new line              new_lines.append(new_line)          # Issue #337: add an empty string at the beginning of new_lines list if there is not one          # so that markdown extension would be able to render properly          if new_lines and new_lines[0] != \"\":              new_lines.insert(0, \"\")          # Check for tags left unclosed (but close them anyway)          for tag, line_no, _ in tag_queue:              new_lines.append(                  _MarkdownFactory._TAIPY_START + tag + _MarkdownFactory._END_SUFFIX + _MarkdownFactory._TAIPY_END              )              _warn(f\"Opened tag {tag} in line {line_no} is not closed.\")          return new_lines        def _process_control(          self, prop_string: str, line_count: int, default_control_name: str = _MarkdownFactory.DEFAULT_CONTROL      ) -> Tuple[str, List[Tuple[str, str]]]:          fragments = [f for f in _Preprocessor.__SPLIT_RE.split(prop_string) if f]          control_name = None          default_prop_name = None          default_prop_value = None          properties: List[Tuple[str, Any]] = []          for fragment in fragments:              if control_name is None and _MarkdownFactory.get_default_property_name(fragment):                  control_name = fragment              elif control_name is None and default_prop_value is None:                  default_prop_value = fragment              elif prop_match := _Preprocessor.__PROPERTY_RE.match(fragment):                  not_prefix = prop_match.group(1)                  prop_name = prop_match.group(2)                  val = prop_match.group(3)                  if not_prefix and val:                      _warn(f\"Negated property {prop_name} value ignored at {line_count}.\")                  prop_value = \"True\"                  if not_prefix:                      prop_value = \"False\"                  elif val:                      prop_value = val                  properties.append(self._make_prop_pair(prop_name, prop_value))              elif len(fragment) > 1 and fragment[0] == \"{\" and fragment[-1] == \"}\":                  properties.append(self._make_prop_pair(fragment[1:-1], fragment))              else:                  _warn(f\"Bad Taipy property format at line {line_count}: '{fragment}'.\")          if control_name is None:              if properties and all(attribute != properties[0][0] for attribute in _MarkdownFactory._TEXT_ATTRIBUTES):                  control_name = properties[0][0]                  properties = properties[1:]                  _warn(f'Unrecognized control {control_name} at line {line_count}: \"<|{prop_string}|>\".')              else:                  control_name = default_control_name          if default_prop_value is not None:              default_prop_name = _MarkdownFactory.get_default_property_name(control_name)              # Set property only if it is not already defined              if default_prop_name and default_prop_name not in [x[0] for x in properties]:                  properties.insert(0, self._make_prop_pair(default_prop_name, default_prop_value))          return control_name, properties "}
{"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": "# Main Application  import os  import re    from taipy.gui import Gui, notify, navigate    import pandas as pd  from datetime import datetime  import chardet    from utils import (      contains_related_word,      categorize_columns_by_datatype,      generate_prompts,      all_chart_types,  )    from similar_columns import replace_values_in_string    import csv  import os    from llm_utils import (      prompt_localllm_fsl,      prompt_localllm_fsl_plot,  )    MAX_FILE_SIZE_MB = 22  # Maximum allowed file size in MB    LOCAL_LLM_URL = \"http://20.234.124.198:5000/generate_code\"    ORIGINAL_DATA_PATH = \"sales_data_sample.csv\"  original_data = pd.read_csv(ORIGINAL_DATA_PATH, sep=\",\", encoding=\"ISO-8859-1\")  original_data[\"ORDERDATE\"] = pd.to_datetime(original_data[\"ORDERDATE\"])  original_data = original_data.sort_values(by=\"ORDERDATE\")    df = pd.DataFrame(original_data)  df.columns = df.columns.str.upper()    default_data = original_data.copy()  data = df  processed_data = original_data.copy()  user_input = \"\"  content = None  data_path = \"\"  render_examples = True  show_tips = True  past_prompts = []  plot_result = \"\"    suggested_prompts = [\"\"] * 5  sample_user_inputs = [      \"What are the 5 most profitable cities?\",      \"Plot in a bar chart sales of the 5 most profitable cities\",      \"Plot sales by product line in a pie chart\",      \"Plot in a pie chart sales by country\",      \"Display in a bar chart sales by product line\",  ]    show_suggested_prompts = False  prompt_mode = True  data_mode = False  show_modified_data = True  edit_table = pd.DataFrame()    debug_log = \"\"  expandPromptHelp = False    CONTEXT_PATH = \"context_data.csv\"  context_data = pd.read_csv(CONTEXT_PATH, sep=\";\")  context = \"\"  for instruction, code in zip(context_data[\"instruction\"], context_data[\"code\"]):      example = f\"{instruction}\\n{code}\\n\"      context += example      # Categorize columns by type for the prompt builder  categorized_columns = categorize_columns_by_datatype(df)  float_columns = categorized_columns[\"float_columns\"]  int_columns = categorized_columns[\"int_columns\"]  string_columns = categorized_columns[\"string_columns\"]  date_columns = categorized_columns[\"date_columns\"]  float_int_columns = float_columns + int_columns  date_string_columns = date_columns + string_columns  date_string_columns_toggle = date_string_columns.copy()  selected_chart_types = \"\"  selected_date_string_columns = \"\"  selected_float_int_columns = \"\"      def reset_prompt_builder(state) -> None:      \"\"\"      Resets the list of possible values for the prompt builder      \"\"\"      state.categorized_columns = categorize_columns_by_datatype(state.data)      divide_columns(state)      state.selected_chart_types = \"\"      state.selected_date_string_columns = \"\"      state.selected_float_int_columns = \"\"      def divide_columns(state) -> None:      \"\"\"      Divides columns by type for the prompt builder      \"\"\"      state.float_columns = state.categorized_columns[\"float_columns\"]      state.int_columns = state.categorized_columns[\"int_columns\"]      state.string_columns = state.categorized_columns[\"string_columns\"]      state.date_columns = state.categorized_columns[\"date_columns\"]      state.float_int_columns = state.float_columns + state.int_columns      state.date_string_columns = state.date_columns + state.string_columns      state.date_string_columns_toggle = state.date_string_columns.copy()      def plot(state) -> None:      \"\"\"      Prompts local starcoder to modify or plot data        Args:          state (State): Taipy GUI state      \"\"\"      state.p.update_content(state, \"\")        response = prompt_localllm_fsl_plot(          state.data.head(), state.user_input, 32, LOCAL_LLM_URL      )        code = re.split(\"\\n\", response[0])[0]        code = f\"<{code}\"      if not code.endswith(\"|>\"):          code += \"|>\"        # state.plot_result = plot_prompt(API_URL, headers, context, state, state.user_input)      output_code = replace_values_in_string(code, state.data.columns.tolist())      state.plot_result = output_code      print(f\"Plot Code: {state.plot_result}\")      state.debug_log = state.debug_log + f\"; Generated Taipy Code: {state.plot_result}\"      state.p.update_content(state, state.plot_result)      notify(state, \"success\", \"Plot Updated!\")      def uppercase_field_labels(code):      # Use regular expression to find text with eventual commas between [' and ']      pattern = r\"\\['(.*?)'\\]\"      modified_code = re.sub(pattern, lambda match: f\"['{match.group(1).upper()}']\", code)        return modified_code      def modify_data(state) -> None:      \"\"\"      Prompts local starcoder to modify or plot data      \"\"\"      notify(state, \"info\", \"Running query...\")        reset_data(state)        state.content = None      current_time = datetime.now().strftime(\"%H:%M\")      state.past_prompts = [current_time + \"\\n\" + state.user_input] + state.past_prompts        print(f\"User Input: {state.user_input}\")        response = prompt_localllm_fsl(state.data, state.user_input, 64, LOCAL_LLM_URL)      # code = re.split('|', response[0])[0]        code = response[0].split(\"|\")[0]      code = uppercase_field_labels(code)        plot_index = code.find(\".plot\")      if plot_index != -1:          code = code[:plot_index]        # Create a dictionary for globals and locals to use in the exec() function      globals_dict = {}      locals_dict = {\"df\": state.data}  # Include 'df' if it's not already available      # Execute the code as a string      import_code = \"import pandas as pd;\"      # If code does not start with \"df = \", add it      if not code.startswith(\"df = \"):          code = \"df = \" + code      print(f\"Data Code: {code}\")      state.debug_log = f\"Generated Pandas Code: {code}\"      try:          exec(import_code + code, globals_dict, locals_dict)          pandas_output = locals_dict[\"df\"]      except Exception as e:          on_exception(state, \"modify_data\", e)          return        # Parse if output is DataFrame, Series, string...      if isinstance(pandas_output, pd.DataFrame):          state.data = pandas_output          notify(state, \"success\", \"Data successfully modified!\")      elif isinstance(pandas_output, pd.Series):          state.data = pd.DataFrame(pandas_output).reset_index()          notify(state, \"success\", \"Data successfully modified!\")      # If int, str, float, bool, list      elif isinstance(pandas_output, (int, str, float, bool, list)):          state.data = pd.DataFrame([pandas_output])          notify(state, \"success\", \"Data successfully modified!\")      # Everything else      else:          state.data = state.data          state.show_modified_data = True        # If user asked for a plot      if contains_related_word(state.user_input):          state.show_modified_data = True          plot(state)      def on_exception(state, function_name: str, ex: Exception) -> None:      \"\"\"      Catches exceptions and notifies user in Taipy GUI        Args:          state (State): Taipy GUI state          function_name (str): Name of function where exception occured          ex (Exception): Exception      \"\"\"      notify(state, \"error\", f\"An error occured in {function_name}: {ex}\")      def reset_data(state) -> None:      \"\"\"      Resets data to original data, resets plot      \"\"\"      state.data = state.default_data.copy()      def example(state, id, _) -> None:      \"\"\"      Runs an example prompt      \"\"\"      _index = int(id.split(\"example\")[1])      state.user_input = state.sample_user_inputs[_index]      modify_data(state)      def suggest_prompt(state, id, _) -> None:      \"\"\"      Runs an suggest prompt      \"\"\"      _index = int(id.split(\"suggest\")[1])      state.user_input = state.suggested_prompts[_index]      modify_data(state)      def remove_spaces_and_convert_to_numeric(value):      if isinstance(value, str):          return pd.to_numeric(value.replace(\" \", \"\"), errors=\"coerce\")      return value      def read_data(file_path: str):      \"\"\"      Read csv file from a path and remove spaces from columns with numeric values        Args:          file_path: Path to csv file      \"\"\"        try:          # Check the file size          file_size_mb = os.path.getsize(file_path) / (1024 * 1024)  # in MB          if file_size_mb > MAX_FILE_SIZE_MB:              print(                  f\"File size exceeds {MAX_FILE_SIZE_MB}MB. Please choose a smaller file.\"              )              return \"Max_File\"            # Detect the file encoding          with open(file_path, \"rb\") as file:              result = chardet.detect(file.read())          detected_encoding = result[\"encoding\"]            # Detect the delimiter using csv.Sniffer          try:              with open(file_path, \"r\", encoding=detected_encoding) as file:                  sniffer = csv.Sniffer()                  sample_data = file.read(1024)  # Read a sample of the data                  delimiter = sniffer.sniff(sample_data).delimiter          except Exception as e:              print(f\"Error detecting delimiter: {e}\")              delimiter = \",\"            output_csv_file_path = \"modified_file.csv\"          rows = []          # Open the input CSV file for reading and the output CSV file for writing          with open(file_path, \"r\") as input_file, open(              output_csv_file_path, \"w\"          ) as output_file:              # Iterate through each line in the input file              csv_reader = csv.reader(input_file)              # Iterate through each row in the CSV file              found_header = False              for row in csv_reader:                  found = 0                  for cell in row:                      if cell == \"\":                          found = found + 1                  if found_header:                      rows.append(row)                  elif found <= 2:                      found_header = True                      rows.append(row)                # Specify the CSV file path where you want to save the data              csv_writer = csv.writer(output_file)              for row in rows:                  csv_writer.writerow(row)            # Read the data using detected encoding and delimiter          df = pd.read_csv(              output_csv_file_path,              encoding=detected_encoding,              delimiter=delimiter,              on_bad_lines=\"skip\",          )            # Remove spaces in numeric columns          columns_with_spaces = []          for column in df.columns:              if df[column].dtype == \"object\":  # Check if the column contains text                  if df[column].str.contains(r\"\\d{1,3}( \\d{3})+\").any():                      columns_with_spaces.append(column)          for column in columns_with_spaces:              df[column] = df[column].apply(remove_spaces_and_convert_to_numeric)            return df      except Exception as e:          print(f\"Error reading data: {e}\")          return None      def data_upload(state) -> None:      \"\"\"      Changes dataset to uploaded dataset      Generate prompt suggestions      \"\"\"        state.p.update_content(state, \"\")      state.suggested_prompts = []      state.show_tips = False        content = read_data(state.data_path)      if content is str:          notify(state, \"error\", f\"File size exceeds {MAX_FILE_SIZE_MB}MB.\")          return None        state.default_data = content        df = pd.DataFrame(state.default_data)      df.columns = df.columns.str.upper()        # get list of columns with same data types      categorized_columns = categorize_columns_by_datatype(df)        # prompt builder      state.categorized_columns = categorize_columns_by_datatype(df)      divide_columns(state)        prompts = generate_prompts(state.categorized_columns, 5)      state.suggested_prompts = prompts        # Convert specified columns to datetime      for column in categorized_columns[\"date_columns\"]:          df[column] = pd.to_datetime(df[column], errors=\"coerce\")        # Convert specified columns to string      for column in categorized_columns[\"string_columns\"]:          df[column] = df[column].astype(\"string\")        state.data = df        state.processed_data = state.default_data.copy()        state.render_examples = False      state.show_suggested_prompts = True      show_columns_fix(state)      def reset_app(state) -> None:      \"\"\"      Resets app to original state      \"\"\"      state.p.update_content(state, \"\")      state.default_data = original_data.copy()      reset_data(state)      state.user_input = \"\"      state.content = None      state.data_path = \"\"      state.render_examples = True      state.show_tips = True      state.past_prompts = []      state.plot_result = \"\"      state.suggested_prompts = [\"\"] * 5      state.show_suggested_prompts = False      state.prompt_mode = True      state.data_mode = False      state.show_modified_data = True      state.edit_table = pd.DataFrame()      state.processed_data = original_data.copy()      show_columns_fix(state)      reset_prompt_builder(state)      state.categorized_columns = categorize_columns_by_datatype(df)      navigate(state, force=True)      def show_prompt(state, id, action) -> None:      \"\"\"      Selects the active page between \"Prompt\" and \"Data Processing\"      \"\"\"      show_columns_fix(state)      if \"show_prompt_button\" in id:          state.prompt_mode = True          state.data_mode = False      if \"show_data_processing_button\" in id:          state.prompt_mode = False          state.data_mode = True      def show_columns_fix(state):      \"\"\"      On Data Processing Page, generate the title and data type text fields      \"\"\"      # Get the titles and data types from the header      try:          df = pd.DataFrame(state.processed_data)          title_row = df.columns.tolist()          data_types = df.dtypes.tolist()            state.edit_table = pd.DataFrame(              [title_row, [reverse_types_dict[str(d)] for d in data_types]],              columns=title_row,          )            state.partial_columns_fix.update_content(              state,              \"\"\"<|{edit_table}|table|show_all|on_edit=on_edit|width=100%|class_name=edit_table|>              *Accepted values for types are: int, float, str, date, bool*{: .text-small}              \"\"\",          )            categorized_columns = categorize_columns_by_datatype(state.data)          prompts = generate_prompts(categorized_columns, 5)          state.suggested_prompts = prompts        except Exception as e:          print(f\"Error reading data: {e}\")          return None      def on_edit(state, var_name, action, payload):      index = payload[\"index\"]      col = payload[\"col\"]      value = payload[\"value\"]        col = state.edit_table.columns.get_loc(col)        if index == 0:          on_title_change(state, index, col, value)      elif index == 1:          on_datatype_change(state, index, col, value)        more_prompt(state)      reset_prompt_builder(state)      state.default_data = state.data.copy()      def on_title_change(state, index, col, value):      \"\"\"      Changes the title of a column as requested by the user      \"\"\"      df = pd.DataFrame(state.processed_data)      df.rename(columns={df.columns[col]: value}, inplace=True)      state.data = state.processed_data.copy()      show_columns_fix(state)      types_dict = {      \"int\": \"int64\",      \"float\": \"float64\",      \"str\": \"string\",      \"date\": \"datetime64[ns]\",      \"bool\": \"bool\",  }    reverse_types_dict = {      \"int64\": \"int\",      \"float64\": \"float\",      \"string\": \"str\",      \"datetime64[ns]\": \"date\",      \"bool\": \"bool\",      \"object\": \"object\",  }      def on_datatype_change(state, index, col, value):      \"\"\"      Changes the data type of a column as requested by the user      \"\"\"      # Check if value is in types_dict      if value not in types_dict:          notify(              state, \"error\", \"The only accepted values are: int, float, str, date, bool\"          )          return      value = types_dict[value]      df = pd.DataFrame(state.processed_data)      if value in [\"int64\", \"float64\"]:          notify(state, \"info\", \"Non-numeric values will be removed\")          df.iloc[:, col] = pd.to_numeric(df.iloc[:, col], errors=\"coerce\")          df = df.dropna()      df.iloc[:, col] = df.iloc[:, col].astype(value)      state.data = state.processed_data.copy()      show_columns_fix(state)      def more_prompt(state) -> None:      \"\"\"      Generates more prompt suggestions      \"\"\"      df = pd.DataFrame(state.processed_data)      categorized_columns = categorize_columns_by_datatype(df)      prompts = generate_prompts(categorized_columns, 5)      state.suggested_prompts = prompts      def build_prompt(state) -> None:      \"\"\"      Generates a prompt using the prompt builder      \"\"\"      if state.selected_date_string_columns != \"\":          state.user_input = f\"Plot a {state.selected_chart_types} of {state.selected_float_int_columns} by {state.selected_date_string_columns}\"      else:          state.user_input = (              f\"Plot a {state.selected_chart_types} of {state.selected_float_int_columns}\"          )      modify_data(state)      def on_select_change(state) -> None:      \"\"\"      Restricts the possible values for the prompt builder according to datatype      \"\"\"      if state.selected_chart_types == \"histogram\":          state.date_string_columns_toggle = []          state.selected_date_string_columns = \"\"      elif state.selected_chart_types == \"scatter plot\":          state.date_string_columns_toggle = (              state.date_string_columns + state.float_int_columns          )      else:          state.date_string_columns_toggle = state.date_string_columns      page = \"\"\"  <|layout|columns=300px 1|    <|part|render=True|class_name=sidebar|  # Talk To **Taipy**{: .color-primary} # {: .logo-text}    <|Reset App|button|on_action=reset_app|class_name=fullwidth plain|id=reset_app_button|>    ### Previous activities ### {: .h5 .mt2 .mb-half}  <|tree|lov={past_prompts[:5]}|class_name=past_prompts_list|multiple|>    |>    <|part|render=True|class_name=p2|    <|part|class_name=tabs pl1 pr1|  <|part|render={prompt_mode}|  <|Prompt|button|on_action=show_prompt|id=show_prompt_button|class_name=tab active|>  <|Data Preprocessing|button|on_action=show_prompt|id=show_data_processing_button|class_name=tab|>  |>  <|part|render={data_mode}|  <|Prompt|button|on_action=show_prompt|id=show_prompt_button|class_name=tab|>  <|Data Preprocessing|button|on_action=show_prompt|id=show_data_processing_button|class_name=tab active|>  |>  |>    <|part|render={prompt_mode}|    <|card    ### Prompt ### {: .h4 .mt0 .mb-half}  <|{user_input}|input|on_action=modify_data|class_name=fullwidth|label=Enter your prompt here|id=prompt|change_delay=550|>    <|Need help for building a prompt?|expandable|expanded={expandPromptHelp}|class_name=prompt-help mt0|    #### Prompt suggestions #### {: .h6 .mt1 .mb-half}  <|part|render={show_tips}|  <|{sample_user_inputs[0]}|button|on_action=example|class_name=button_link|id=example0|>  <|{sample_user_inputs[1]}|button|on_action=example|class_name=button_link|id=example1|>  <|{sample_user_inputs[2]}|button|on_action=example|class_name=button_link|id=example2|>  <|{sample_user_inputs[3]}|button|on_action=example|class_name=button_link|id=example3|>  <|{sample_user_inputs[4]}|button|on_action=example|class_name=button_link|id=example4|>  |>    <|part|render={show_suggested_prompts}|  <|{suggested_prompts[0]}|button|on_action=suggest_prompt|class_name=button_link|id=suggest0|>  <|{suggested_prompts[1]}|button|on_action=suggest_prompt|class_name=button_link|id=suggest1|>  <|{suggested_prompts[2]}|button|on_action=suggest_prompt|class_name=button_link|id=suggest2|>  <|{suggested_prompts[3]}|button|on_action=suggest_prompt|class_name=button_link|id=suggest3|>  <|{suggested_prompts[4]}|button|on_action=suggest_prompt|class_name=button_link|id=suggest4|>  <|More prompts|button|on_action=more_prompt|id=more_prompt_button|>  |>    #### Prompt builder ### {: .h6 .mt1 .mb-half}  <|layout|columns=auto 1 auto 1 auto 1 auto|class_name=align-columns-center  <|  Plot a  |>  <|{selected_chart_types}|selector|lov={all_chart_types}|dropdown=True|on_change=on_select_change|class_name=fullwidth|id=chart_type_select|>  <|  of  |>  <|{selected_float_int_columns}|selector|lov={float_int_columns}|dropdown=True|on_change=on_select_change|class_name=fullwidth|id=float_int_select|>  <|  by  |>  <|{selected_date_string_columns}|selector|lov={date_string_columns_toggle}|dropdown=True|on_change=on_select_change|class_name=fullwidth|id=date_string_select|>    <|Build|button|on_action=build_prompt|class_name=button_link|class_name=plain|>  |>    |>    |>    <|part|class_name=card mt1|    <|part|render=False|  ### Original Data Table ### {: .h4 .mt0 .mb-half}  <|{original_data}|table|width=100%|page_size=5|rebuild|class_name=table|>  <center>  <|{content}|image|width=50%|>  </center>  |>    <|part|render={show_modified_data}|  <|Original Data Table|expandable|expanded=False|  <|{default_data}|table|width=100%|page_size=5|rebuild|class_name=table|>  |>  <br />  ### Modified Data Table ### {: .h5 .mt0 .mb-half}  <|{data}|table|width=100%|page_size=5|rebuild|class_name=table|>  |>    ### Graphs/Charts ### {: .h5 .mt1 .mb-half}  <|part|partial={p}|>  |>    <|Debug Logs|expandable|expanded=True|  <|{debug_log}|text|>  |>    |>    <|part|render={data_mode}|    <|card    <|layout|columns=1 auto|class_name=align-columns-center  ### Data Preprocessing ### {: .h4 .mt0 .mb-half}  <|{data_path}|file_selector|on_action=data_upload|label=Upload your CSV file|class_name=plain|>  |>    #### Edit column names and data types ### {: .h6 .mt1 .mb-half}  <|part|partial={partial_columns_fix}|>  |>      <|part|class_name=card mt1|  ### Data Table ### {: .h4 .mt0 .mb-half}  <|{data}|table|width=100%|page_size=5|rebuild|>  |>     |>  <br />  Any issues or suggestions? Mail them to: **support@taipy.io**{: .color-primary}    We only store the prompts you enter for the sole purpose of improving our product and counting daily active users. We do not store any of your data. For more information, please read our [Privacy Policy](https://www.taipy.io/privacy-policy/)  |>  |>  \"\"\"  gui = Gui(page)  partial_columns_fix = gui.add_partial(\"\")  p = gui.add_partial(\"\")  gui.run(title=\"Talk To Taipy\", margin=\"0rem\", debug=True, use_reloader=True, port=5039) "}
{"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 from standard library  import logging  import random  import re    # Import from 3rd party libraries  from taipy.gui import Gui, notify, state  import taipy    # Import modules  import oai    # Configure logger  logging.basicConfig(format=\"\\n%(asctime)s\\n%(message)s\", level=logging.INFO, force=True)      def error_prompt_flagged(state, prompt):      \"\"\"Notify user that a prompt has been flagged.\"\"\"      notify(state, \"error\", \"Prompt flagged as inappropriate.\")      logging.info(f\"Prompt flagged as inappropriate: {prompt}\")      def error_too_many_requests(state):      \"\"\"Notify user that too many requests have been made.\"\"\"      notify(          state,          \"error\",          \"Too many requests. Please wait a few seconds before generating another text or image.\",      )      logging.info(f\"Session request limit reached: {state.n_requests}\")      state.n_requests = 1      # Define functions  def generate_text(state):      \"\"\"Generate Tweet text.\"\"\"      state.tweet = \"\"      state.image = None        # Check the number of requests done by the user      if state.n_requests >= 5:          error_too_many_requests(state)          return        # Check if the user has put a topic      if state.topic == \"\":          notify(state, \"error\", \"Please enter a topic\")          return        # Create the prompt and add a style or not      if state.style == \"\":          state.prompt = (              f\"Write a {state.mood}Tweet about {state.topic} in less than 120 characters \"              f\"and with the style of {state.style}:\\n\\n\\n\\n\"          )      else:          state.prompt = f\"Write a {state.mood}Tweet about {state.topic} in less than 120 characters:\\n\\n\"        # openai configured and check if text is flagged      openai = oai.Openai()      flagged = openai.moderate(state.prompt)        if flagged:          error_prompt_flagged(state, f\"Prompt: {state.prompt}\\n\")          return      else:          # Generate the tweet          state.n_requests += 1          state.tweet = openai.complete(state.prompt).strip().replace('\"', \"\")            # Notify the user in console and in the GUI          logging.info(              f\"Topic: {state.prompt}{state.mood}{state.style}\\n\" f\"Tweet: {state.tweet}\"          )          notify(state, \"success\", \"Tweet created!\")      def generate_image(state):      \"\"\"Generate Tweet image.\"\"\"      notify(state, \"info\", \"Generating image...\")        # Check the number of requests done by the user      if state.n_requests >= 5:          error_too_many_requests(state)          return        state.image = None        # Creates the prompt      prompt_wo_hashtags = re.sub(\"#[A-Za-z0-9_]+\", \"\", state.prompt)      processing_prompt = (          \"Create a detailed but brief description of an image that captures \"          f\"the essence of the following text:\\n{prompt_wo_hashtags}\\n\\n\"      )        # Openai configured and check if text is flagged      openai = oai.Openai()      flagged = openai.moderate(processing_prompt)        if flagged:          error_prompt_flagged(state, processing_prompt)          return      else:          state.n_requests += 1          # Generate the prompt that will create the image          processed_prompt = (              openai.complete(prompt=processing_prompt, temperature=0.5, max_tokens=40)              .strip()              .replace('\"', \"\")              .split(\".\")[0]              + \".\"          )            # Generate the image          state.image = openai.image(processed_prompt)            # Notify the user in console and in the GUI          logging.info(f\"Tweet: {state.prompt}\\nImage prompt: {processed_prompt}\")          notify(state, \"success\", f\"Image created!\")      def feeling_lucky(state):      \"\"\"Generate a feeling-lucky tweet.\"\"\"      with open(\"moods.txt\") as f:          sample_moods = f.read().splitlines()      state.topic = \"an interesting topic\"      state.mood = random.choice(sample_moods)      state.style = \"\"      generate_text(state)      # Variables  tweet = \"\"  prompt = \"\"  n_requests = 0    topic = \"AI\"  mood = \"inspirational\"  style = \"elonmusk\"    image = None      # Called whever there is a problem  def on_exception(state, function_name: str, ex: Exception):      logging.error(f\"Problem {ex} \\nin {function_name}\")      notify(state, \"error\", f\"Problem {ex} \\nin {function_name}\")      def update_documents(state: taipy.gui.state, docs: list[dict]) -> None:      \"\"\"      Updates a partial with a list of documents        Args:          state: The state of the GUI          docs: A list of documents      \"\"\"      updated_part = \"\"      for doc in docs:          title = doc[\"title\"]          summary = doc[\"summary\"]          link = doc[\"link\"]          updated_part += f\"\"\"          <a href=\"{link}\" target=\"_blank\">              <h3>{title}</h3>          </a>          <p>{summary}</p>          <br/>          \"\"\"      state.p.update_content(state, updated_part)      # Markdown for the entire page  ## <text|  ## |text>  ## \"text\" here is just a name given to my part/my section  ## it has no meaning in the code  page = \"\"\"  <|container|  # **Generate**{: .color-primary} Tweets    This mini-app generates Tweets using OpenAI's GPT-3 based [Davinci model](https://beta.openai.com/docs/models/overview) for texts and [DALL\u00b7E](https://beta.openai.com/docs/guides/images) for images. You can find the code on [GitHub](https://github.com/Avaiga/demo-tweet-generation) and the original author on [Twitter](https://twitter.com/kinosal).    <br/>    <a href=\"{azaz}\" target=\"_blank\">      <h3>{sqdqs}</h3>  </a>  <p>{qfqffqs}</p>  <br/>    <|layout|columns=1 1 1|gap=30px|class_name=card|  <topic|  ## **Topic**{: .color-primary} (or hashtag)    <|{topic}|input|label=Topic (or hashtag)|>  |topic>    <mood|  ## **Mood**{: .color-primary}    <|{mood}|input|label=Mood (e.g. inspirational, funny, serious) (optional)|>  |mood>    <style|  ## Twitter **account**{: .color-primary}    <|{style}|input|label=Twitter account handle to style-copy recent Tweets (optional)|>  |style>    Create a Generate text button  <|Generate text|button|on_action=generate_text|label=Generate text|>    <|Feeling lucky|button|on_action=feeling_lucky|label=Feeling Lucky|>  |>    <br/>    ---    <br/>    ### Generated **Tweet**{: .color-primary}    Create a text input for the tweet  <|{tweet}|input|multiline|label=Resulting tweet|class_name=fullwidth|>    <center><|Generate image|button|on_action=generate_image|label=Generate image|active={prompt!=\"\" and tweet!=\"\"}|></center>    <image|part|render={prompt != \"\" and tweet != \"\" and image is not None}|class_name=card|  ### **Image**{: .color-primary} from Dall-e    Display image  <center><|{image}|image|height=400px|></center>  |image>    Break line  <br/>    **Code from [@kinosal](https://twitter.com/kinosal)**    Original code can be found [here](https://github.com/kinosal/tweet)  |>  \"\"\"      if __name__ == \"__main__\":      Gui(page).run(dark_mode=False, port=5089) "}
{"text": "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": "# \uae30\ubcf8 \ud328\ud0a4\uc9c0  import pandas as pd    # \ud0c0\uc774\ud53c \ud568\uc218  import taipy as tp  from taipy.gui import Gui, Icon    # \uad6c\uc131 \uac00\uc838\uc624\uae30  from config.config import scenario_cfg  from taipy.core.config.config import Config    import os    # \uc784\uc2dc \ud30c\uc77c\uc744 \uc0dd\uc131\ud558\uae30 \uc704\ud574 import  import pathlib    # \uc774 \uacbd\ub85c\ub294 Datasouces \ud398\uc774\uc9c0\uc5d0\uc11c \ud14c\uc774\ube14\uc744 \ub2e4\uc6b4\ub85c\ub4dc\ud560 \uc218 \uc788\ub294 \uc784\uc2dc \ud30c\uc77c\uc744 \ub9cc\ub4dc\ub294 \ub370 \uc0ac\uc6a9\ub429\ub2c8\ub2e4.  #   tempdir = pathlib.Path(\".tmp\")  tempdir.mkdir(exist_ok=True)  PATH_TO_TABLE = str(tempdir / \"table.csv\")    ###############################################################################  # \ub370\uc774\ud130 \uc800\uc7a5\uc18c\ub97c \uccad\uc18c\ud569\ub2c8\ub2e4.  ###############################################################################    Config.configure_global_app(clean_entities_enabled=True)  tp.clean_all_entities()    ##############################################################################################################################  # \uc2dc\ub098\ub9ac\uc624 \uc2e4\ud589  ##############################################################################################################################    def create_first_scenario(scenario_cfg):      global scenario      scenario = tp.create_scenario(scenario_cfg)      tp.submit(scenario)        create_first_scenario(scenario_cfg)    # ############################################################################################################################  # \ucd08\uae30\ud654 - \uc2dc\ub098\ub9ac\uc624\uc758 \uac12\uc744 \uc77d\uc744 \uc218 \uc788\uc2b5\ub2c8\ub2e4.  ##############################################################################################################################  forecast_values_baseline = scenario.pipelines['pipeline_baseline'].forecast_dataset.read()  forecast_values = scenario.pipelines['pipeline_model'].forecast_dataset.read()    test_dataset = scenario.pipelines['pipeline_baseline'].test_dataset.read()  train_dataset = scenario.pipelines['pipeline_preprocessing'].train_dataset.read()  roc_dataset = scenario.pipelines['pipeline_baseline'].roc_data.read()    test_dataset.columns = [str(column).upper() for column in test_dataset.columns]    # \ud788\uc2a4\ud1a0\uadf8\ub7a8\uacfc \uc0b0\uc810\ub3c4\ub97c \uc774\uc6a9\ud55c \ub370\uc774\ud130 \uc2dc\uac01\ud654\ub97c \uc704\ud55c \uac83\uc785\ub2c8\ub2e4.  select_x = test_dataset.drop('EXITED',axis=1).columns.tolist()  x_selected = select_x[0]    select_y = select_x  y_selected = select_y[1]    ##############################################################################################################################  # \ucd08\uae30\ud654 - \ucc28\ud2b8\uc5d0 \uc0ac\uc6a9\ub420 \uacb0\uacfc\ub97c \uc7ac\uac1c\ud558\ub294 \ub370\uc774\ud130\uc14b \uc0dd\uc131  ##############################################################################################################################  from pages.main_dialog import *    values_baseline = scenario.pipelines['pipeline_baseline'].results.read()  values_model = scenario.pipelines['pipeline_model'].results.read()    values = values_baseline.copy()    forecast_series = values['Forecast']  true_series = values['Historical']      scatter_dataset_pred = creation_scatter_dataset_pred(test_dataset,forecast_series)  histo_full_pred = creation_histo_full_pred(test_dataset,forecast_series)    histo_full = creation_histo_full(test_dataset)  scatter_dataset = creation_scatter_dataset(test_dataset)    features_table = scenario.pipelines['pipeline_train_baseline'].feature_importance.read()    # \uc62c\ubc14\ub978 \ud30c\uc774\ud504\ub77c\uc778\uc744 \uac00\uc838\uc624\ub294 \uc77c\ubc18 \ucf54\ub4dc\uc758 \ud30c\uc774\ud504\ub77c\uc778 \ube44\uad50  #   pipelines_to_compare = [pipeline for pipeline in scenario.pipelines if 'train' not in pipeline and 'preprocessing' not in pipeline]    accuracy_graph, f1_score_graph, score_auc_graph = compare_models_baseline(scenario, pipelines_to_compare) # comes from the compare_models.py    ##############################################################################################################################  # \ucd08\uae30\ud654 - \ud45c\uc2dc\ub420 \ubaa8\ub378\uc758 \uc815\ud655\ub3c4\uc640 \ud074\ub798\uc2a4 \ubd84\ud3ec\ub97c \ubcf4\uae30 \uc704\ud55c \ud30c\uc774 \ucc28\ud2b8 \uc0dd\uc131  ##############################################################################################################################  # '\uae30\uc900' \ubaa8\ub378\uc5d0 \ub300\ud55c \uba54\ud2b8\ub9ad\uc744 \uacc4\uc0b0\ud569\ub2c8\ub2e4.  (number_of_predictions,   accuracy, f1_score, score_auc,   number_of_good_predictions,   number_of_false_predictions,   fp_, tp_, fn_, tn_) = c_update_metrics(scenario, 'pipeline_baseline')    # \ud30c\uc774 \ucc28\ud2b8  pie_plotly = pd.DataFrame({\"values\": [number_of_good_predictions, number_of_false_predictions],                             \"labels\": [\"Correct predictions\", \"False predictions\"]})    distrib_class = pd.DataFrame({\"values\": [len(values[values[\"Historical\"]==0]),len(values[values[\"Historical\"]==1])],                                \"labels\" : [\"Stayed\", \"Exited\"]})    ##############################################################################################################################  # \ucd08\uae30\ud654 - \ud45c\uc2dc\ub420 False/positive/negative/true \ud14c\uc774\ube14 \uc0dd\uc131  ##############################################################################################################################    score_table = pd.DataFrame({\"Score\":[\"Predicted stayed\", \"Predicted exited\"],                              \"Stayed\": [tn_, fp_],                              \"Exited\" : [fn_, tp_]})    pie_confusion_matrix = pd.DataFrame({\"values\": [tp_,tn_,fp_,fn_],                                \"labels\" : [\"True Positive\",\"True Negative\",\"False Positive\",  \"False Negative\"]})    ##############################################################################################################################  # \ucd08\uae30\ud654 - \uadf8\ub798\ud53d \uc0ac\uc6a9\uc790 \uc778\ud130\ud398\uc774\uc2a4 \uc0dd\uc131(\uc0c1\ud0dc)  ##############################################################################################################################    # The list of pages that will be shown in the menu at the left of the page  menu_lov = [(\"Data Visualization\", Icon('images/histogram_menu.svg', 'Data Visualization')),              (\"Model Manager\", Icon('images/model.svg', 'Model Manager')),              (\"Compare Models\", Icon('images/compare.svg', 'Compare Models')),              ('Databases', Icon('images/Datanode.svg', 'Databases'))]    width_plotly = \"450px\"  height_plotly = \"450px\"    page_markdown = \"\"\"  <|toggle|theme|>  <|menu|label=Menu|lov={menu_lov}|on_action=menu_fct|>    <|part|render={page == 'Data Visualization'}|  \"\"\" + dv_data_visualization_md + \"\"\"  |>    <|part|render={page == 'Model Manager'}|  \"\"\" + mm_model_manager_md + \"\"\"  |>    <|part|render={page == 'Compare Models'}|  \"\"\" + cm_compare_models_md + \"\"\"  |>    <|part|render={page == 'Databases'}|  \"\"\" + db_databases_md + \"\"\"  |>    \"\"\"    # \ucd08\uae30 \ud398\uc774\uc9c0\ub294 \"\uc2dc\ub098\ub9ac\uc624 \uad00\ub9ac\uc790\" \ud398\uc774\uc9c0\uc785\ub2c8\ub2e4.  page = \"Data Visualization\"  def menu_fct(state,var_name:str,fct,var_value):      \"\"\"\uba54\ub274 \ucee8\ud2b8\ub864\uc5d0 \ubcc0\uacbd\uc774 \uc788\uc744 \ub54c \ud638\ucd9c\ub418\ub294 \ud568\uc218        Args:          state : Taipy\uc758 \uc0c1\ud0dc \uac1d\uccb4          var_name (str): \ubcc0\uacbd\ub41c \ubcc0\uc218\uba85          var_value (obj): \ubcc0\uacbd\ub41c \ubcc0\uc218 \uac12      \"\"\"      # \uc62c\ubc14\ub978 \ud398\uc774\uc9c0\ub97c \ub80c\ub354\ub9c1\ud558\uae30 \uc704\ud574 state.page \ubcc0\uc218\uc758 \uac12\uc744 \ubcc0\uacbd\ud569\ub2c8\ub2e4.      try :          state.page = var_value['args'][0]      except:          print(\"Warning : No args were found\")      pass      # \uc608\uce21 \ud14c\uc774\ube14\uc744 \uc704\ud55c \ud568\uc218. \ub098\uc05c \uc608\uce21\uc740 \ube68\uac04\uc0c9\uc774\uace0 \uc88b\uc740 \uc608\uce21\uc740 \ub179\uc0c9\uc785\ub2c8\ub2e4(css \ud074\ub798\uc2a4).  def get_style(state, index, row):      return 'red' if row['Historical']!=row['Forecast'] else 'green'      ##############################################################################################################################  # \uc804\uccb4 \ub9c8\ud06c\ub2e4\uc6b4 \uc0dd\uc131  ##############################################################################################################################      # dialog_md\ub294 main_dialog.py\uc5d0 \uc788\uc2b5\ub2c8\ub2e4.  # the other are found in the dialogs folder  entire_markdown = page_markdown + dialog_md    # \ud398\uc774\uc9c0 \uc0dd\uc131\uc5d0 \uc0ac\uc6a9\ub420 \uac1d\uccb4  gui = Gui(page=entire_markdown, css_file='main')  dialog_partial_roc = gui.add_partial(dialog_roc)    partial_scatter = gui.add_partial(creation_of_dialog_scatter(x_selected))  partial_histo = gui.add_partial(creation_of_dialog_histogram(x_selected))    partial_scatter_pred = gui.add_partial(creation_of_dialog_scatter_pred(x_selected))  partial_histo_pred = gui.add_partial(creation_of_dialog_histogram_pred(x_selected))    def update_partial_charts(state):      \"\"\"\uc774 \ud568\uc218\ub294 \ucc28\ud2b8\uc640 \uc120\ud0dd\uae30\ub97c \ud3ec\ud568\ud558\ub294 4\uac1c\uc758 \ubd80\ubd84\uc744 \uc5c5\ub370\uc774\ud2b8\ud569\ub2c8\ub2e4.       Partials\ub294 \uc544\ub798 \uae30\ub2a5\uc744 \uc0ac\uc6a9\ud558\uc5ec \ub7f0\ud0c0\uc784\uc5d0 \ub2e4\uc2dc \ub85c\ub4dc\ud560 \uc218 \uc788\ub294 \ubbf8\ub2c8 \ud398\uc774\uc9c0\uc785\ub2c8\ub2e4.       \ucc28\ud2b8\uc758 \ub0b4\uc6a9\uc744 \ubcc0\uacbd\ud558\uae30 \uc704\ud574 \ub2e4\uc2dc \ub85c\ub4dc\ub429\ub2c8\ub2e4.        Args:          state: GUI\uc5d0\uc11c \uc0ac\uc6a9\ub418\ub294 \ubaa8\ub4e0 \ubcc0\uc218\ub97c \ud3ec\ud568\ud558\ub294 \uac1d\uccb4      \"\"\"      state.partial_scatter.update_content(state, creation_of_dialog_scatter(state.x_selected, state))      state.partial_histo.update_content(state, creation_of_dialog_histogram(state.x_selected, state))            state.partial_scatter_pred.update_content(state, creation_of_dialog_scatter_pred(state.x_selected, state))      state.partial_histo_pred.update_content(state, creation_of_dialog_histogram_pred(state.x_selected, state))      ##############################################################################################################################  # \ud45c\uc2dc\ub41c \ubcc0\uc218 \uc5c5\ub370\uc774\ud2b8  ##############################################################################################################################      def update_variables(state, pipeline):      \"\"\"\uc774 \ud568\uc218\ub294 \uc751\uc6a9 \ud504\ub85c\uadf8\ub7a8\uc5d0\uc11c \uc0ac\uc6a9\ub418\ub294 \ub2e4\uc591\ud55c \ubcc0\uc218\uc640 \ub370\uc774\ud130 \ud504\ub808\uc784\uc744 \uc5c5\ub370\uc774\ud2b8\ud569\ub2c8\ub2e4.        Args:          state: GUI\uc5d0\uc11c \uc0ac\uc6a9\ub418\ub294 \ubaa8\ub4e0 \ubcc0\uc218\ub97c \ud3ec\ud568\ud558\ub294 \uac1d\uccb4          pipeline (str): \ubcc0\uc218\ub97c \uc5c5\ub370\uc774\ud2b8\ud558\ub294 \ub370 \uc0ac\uc6a9\ub418\ub294 \ud30c\uc774\ud504\ub77c\uc778\uc758 \uc774\ub984      \"\"\"      global scenario      pipeline_str = 'pipeline_'+pipeline            if pipeline == 'baseline':          state.values = scenario.pipelines[pipeline_str].results.read()      else:          state.values = scenario.pipelines[pipeline_str].results.read()                state.forecast_series = state.values['Forecast']      state.true_series = state.values[\"Historical\"]                  (state.number_of_predictions,      state.accuracy, state.f1_score, state.score_auc,      number_of_good_predictions, number_of_false_predictions,      fp_, tp_, fn_, tn_) = c_update_metrics(scenario, pipeline_str)                  update_charts(state, pipeline_str, number_of_good_predictions, number_of_false_predictions, fp_, tp_, fn_, tn_)            def update_charts(state, pipeline_str, number_of_good_predictions, number_of_false_predictions, fp_, tp_, fn_, tn_):      \"\"\"\uc774 \ud568\uc218\ub294 GUI\uc758 \ubaa8\ub4e0 \ucc28\ud2b8\ub97c \uc5c5\ub370\uc774\ud2b8\ud569\ub2c8\ub2e4.        Args:          state: GUI\uc5d0\uc11c \uc0ac\uc6a9\ub418\ub294 \ubaa8\ub4e0 \ubcc0\uc218\ub97c \ud3ec\ud568\ud558\ub294 \uac1d\uccb4          pipeline_str(str): \ud45c\uc2dc\ub41c \ud30c\uc774\ud504\ub77c\uc778\uc758 \uc774\ub984          number_of_good_predictions(int): \uc88b\uc740 \uc608\uce21\uc758 \uc218          number_of_false_predictions(int): \uc798\ubabb\ub41c \uc608\uce21\uc758 \uc218          fp_ (float): \uc704\uc591\uc131 \ube44\uc728          tp_ (float): \ucc38 \uae0d\uc815 \ube44\uc728          fn_ (float): \uc704\uc74c\uc131 \ube44\uc728          tn_ (float): \ucc38 \uc74c\uc218 \ube44\uc728      \"\"\"      state.roc_dataset = scenario.pipelines[pipeline_str].roc_data.read()            if 'model' in pipeline_str:          state.features_table = scenario.pipelines['pipeline_train_model'].feature_importance.read()      elif 'baseline' in pipeline_str:          state.features_table = scenario.pipelines['pipeline_train_baseline'].feature_importance.read()        state.score_table = pd.DataFrame({\"Score\":[\"Predicted stayed\", \"Predicted exited\"],                                        \"Stayed\": [tn_, fp_],                                        \"Exited\" : [fn_, tp_]})        state.pie_confusion_matrix = pd.DataFrame({\"values\": [tp_, tn_, fp_, fn_],                                                 \"labels\" : [\"True Positive\", \"True Negative\", \"False Positive\", \"False Negative\"]})        state.scatter_dataset_pred = creation_scatter_dataset_pred(test_dataset, state.forecast_series)      state.histo_full_pred = creation_histo_full_pred(test_dataset, state.forecast_series)              # \ud30c\uc774 \ucc28\ud2b8      state.pie_plotly = pd.DataFrame({\"values\": [number_of_good_predictions, number_of_false_predictions],                                       \"labels\": [\"Correct predictions\", \"False predictions\"]})        state.distrib_class = pd.DataFrame({\"values\": [len(state.values[state.values[\"Historical\"]==0]),                                                     len(state.values[state.values[\"Historical\"]==1])],                                          \"labels\" : [\"Stayed\", \"Exited\"]})      ##############################################################################################################################  # on_change \ud568\uc218  ##############################################################################################################################    # \ub2e4\ub978 \uae30\ub2a5\uc740 frontend/dialogs\uc758 \uc624\ub978\ucabd \ud3f4\ub354\uc5d0 \uc788\uc2b5\ub2c8\ub2e4.  def on_change(state, var_name, var_value):      \"\"\"\uc774 \ud568\uc218\ub294 GUI\uc5d0\uc11c \ubcc0\uc218\uac00 \ubcc0\uacbd\ub420 \ub54c \ud638\ucd9c\ub429\ub2c8\ub2e4.        Args:          state : GUI\uc5d0\uc11c \uc0ac\uc6a9\ub418\ub294 \ubaa8\ub4e0 \ubcc0\uc218\ub97c \ud3ec\ud568\ud558\ub294 \uac1d\uccb4          var_name (str): \ubcc0\uacbd\ub41c \ubcc0\uc218\uc758 \uc774\ub984          var_value (obj): \ubcc0\uacbd\ub41c \ubcc0\uc218\uc758 \uac12      \"\"\"      if var_name == 'x_selected' or var_name == 'y_selected':          update_partial_charts(state)            if var_name == 'mm_algorithm_selected':          if var_value == 'Baseline':              update_variables(state,'baseline')          if var_value == 'ML':              update_variables(state,'model')                if (var_name == 'mm_algorithm_selected' or var_name == \"db_table_selected\" and state.page == 'Databases') or (var_name == 'page' and var_value == 'Databases'):          # '\ub370\uc774\ud130\ubca0\uc774\uc2a4' \ud398\uc774\uc9c0\uc5d0 \uc788\ub294 \uacbd\uc6b0 \uc784\uc2dc csv \ud30c\uc77c\uc744 \ub9cc\ub4e4\uc5b4\uc57c \ud569\ub2c8\ub2e4.          handle_temp_csv_path(state)                   if var_name == 'page' and var_value != 'Databases':          delete_temp_csv()        def delete_temp_csv():      \"\"\"\uc774 \ud568\uc218\ub294 \uc784\uc2dc csv \ud30c\uc77c\uc744 \uc0ad\uc81c\ud569\ub2c8\ub2e4.\"\"\"      if os.path.exists(PATH_TO_TABLE):          os.remove(PATH_TO_TABLE)    def handle_temp_csv_path(state):      \"\"\"\uc784\uc2dc csv \ud30c\uc77c\uc774 \uc874\uc7ac\ud558\ub294\uc9c0 \ud655\uc778\ud558\ub294 \ud568\uc218\uc785\ub2c8\ub2e4. \uc874\uc7ac\ud558\uba74 \uc0ad\uc81c\ud569\ub2c8\ub2e4.       \uadf8\ub7ec\uba74 \uc784\uc2dc csv \ud30c\uc77c\uc774 \uc624\ub978\ucabd \ud14c\uc774\ube14\uc5d0 \ub300\ud574 \uc0dd\uc131\ub429\ub2c8\ub2e4.        Args:          state: GUI\uc5d0\uc11c \uc0ac\uc6a9\ub418\ub294 \ubaa8\ub4e0 \ubcc0\uc218\ub97c \ud3ec\ud568\ud558\ub294 \uac1d\uccb4      \"\"\"      if os.path.exists(PATH_TO_TABLE):          os.remove(PATH_TO_TABLE)      if state.db_table_selected == 'Test Dataset':          state.test_dataset.to_csv(PATH_TO_TABLE, sep=';')      if state.db_table_selected == 'Confusion Matrix':          state.score_table.to_csv(PATH_TO_TABLE, sep=';')      if state.db_table_selected == \"Training Dataset\":          train_dataset.to_csv(PATH_TO_TABLE, sep=';')      if state.db_table_selected == \"Forecast Dataset\":          values.to_csv(PATH_TO_TABLE, sep=';')          ##############################################################################################################################  # GUI \uc2e4\ud589  ##############################################################################################################################  if __name__ == '__main__':      gui.run(title=\"Churn classification\",      \t\thost='0.0.0.0',      \t\tport=os.environ.get('PORT', '5050'),      \t\tdark_mode=False)  else:      app = gui.run(title=\"Churn classification\",      \t         dark_mode=False,                   run_server=False) "}
{"text": "from algos.algos import *  from taipy import Scope, Frequency, Config  ##############################################################################################################################  # \ub370\uc774\ud130\ub178\ub4dc \uc0dd\uc131  ##############################################################################################################################  # \ub370\uc774\ud130\ubca0\uc774\uc2a4\uc5d0 \uc5f0\uacb0\ud558\ub294 \ubc29\ubc95  path_to_csv = 'data/churn.csv'    # csv\uc758 \uacbd\ub85c\uc640 \ud53c\ud074\uc758 file_path  initial_dataset = Config.configure_data_node(id=\"initial_dataset\",                                               path=path_to_csv,                                               storage_type=\"csv\",                                               has_header=True)    date_cfg = Config.configure_data_node(id=\"date\", default_data=\"None\")    preprocessed_dataset = Config.configure_data_node(id=\"preprocessed_dataset\",                                                    cacheable=True,                                                    validity_period=dt.timedelta(days=1))    # \ucc98\ub9ac\ub41c \ub370\uc774\ud130\ub97c \ud3ec\ud568\ud558\ub294 \ucd5c\uc885 \ub370\uc774\ud130 \ub178\ub4dc  train_dataset = Config.configure_data_node(id=\"train_dataset\",                                             cacheable=True,                                             validity_period=dt.timedelta(days=1))    # \ucc98\ub9ac\ub41c \ub370\uc774\ud130\ub97c \ud3ec\ud568\ud558\ub294 \ucd5c\uc885 \ub370\uc774\ud130 \ub178\ub4dc  trained_model = Config.configure_data_node(id=\"trained_model\",                                             cacheable=True,                                             validity_period=dt.timedelta(days=1))    trained_model_baseline = Config.configure_data_node(id=\"trained_model_baseline\",                                                      cacheable=True,                                                      validity_period=dt.timedelta(days=1))      # \ucc98\ub9ac\ub41c \ub370\uc774\ud130\ub97c \ud3ec\ud568\ud558\ub294 \ucd5c\uc885 \ub370\uc774\ud130 \ub178\ub4dc  test_dataset = Config.configure_data_node(id=\"test_dataset\",                                            cacheable=True,                                            validity_period=dt.timedelta(days=1))    forecast_dataset = Config.configure_data_node(id=\"forecast_dataset\",                                            scope=Scope.PIPELINE,                                               cacheable=True,                                               validity_period=dt.timedelta(days=1))    roc_data = Config.configure_data_node(id=\"roc_data\",                                        scope=Scope.PIPELINE,                                        cacheable=True,                                        validity_period=dt.timedelta(days=1))    score_auc = Config.configure_data_node(id=\"score_auc\",                                         scope=Scope.PIPELINE,                                         cacheable=True,                                         validity_period=dt.timedelta(days=1))    metrics = Config.configure_data_node(id=\"metrics\",                                       scope=Scope.PIPELINE,                                       cacheable=True,                                       validity_period=dt.timedelta(days=1))    feature_importance_cfg = Config.configure_data_node(id=\"feature_importance\",                                                      scope=Scope.PIPELINE)      results = Config.configure_data_node(id=\"results\",                                       scope=Scope.PIPELINE,                                       cacheable=True,                                       validity_period=dt.timedelta(days=1))      ##############################################################################################################################  # \uc791\uc5c5 \uc0dd\uc131  ##############################################################################################################################    # \uc791\uc5c5\uc740 \ud568\uc218\ub97c \uc2e4\ud589\ud558\ub294 \ub3d9\uc548 \uc785\ub825 \ub370\uc774\ud130 \ub178\ub4dc\uc640 \ucd9c\ub825 \ub370\uc774\ud130 \ub178\ub4dc \uc0ac\uc774\uc758 \ub9c1\ud06c\ub97c \ub9cc\ub4ed\ub2c8\ub2e4.   #     # \ucd08\uae30 \ub370\uc774\ud130\uc138\ud2b8 --> \ub370\uc774\ud130\uc138\ud2b8 \uc804\ucc98\ub9ac --> \ucc98\ub9ac\ub41c \ub370\uc774\ud130\uc138\ud2b8  task_preprocess_dataset = Config.configure_task(id=\"preprocess_dataset\",                                                  input=[initial_dataset,date_cfg],                                                  function=preprocess_dataset,                                                  output=preprocessed_dataset)    # \ucc98\ub9ac\ub41c \ub370\uc774\ud130\uc138\ud2b8 --> \ud559\uc2b5 \ub370\uc774\ud130 \uc0dd\uc131 --> \ud559\uc2b5\ub370\uc774\ud130\uc138\ud2b8, \ud14c\uc2a4\ud2b8\ub370\uc774\ud130\uc138\ud2b8  task_create_train_test = Config.configure_task(id=\"create_train_and_test_data\",                                                 input=preprocessed_dataset,                                                 function=create_train_test_data,                                                 output=[train_dataset, test_dataset])      # \ud559\uc2b5 \ub370\uc774\ud130\uc138\ud2b8 --> \ud559\uc2b5 \ubaa8\ub378 \ub370\uc774\ud130 \uc0dd\uc131 --> \ud559\uc2b5\ub41c \ubaa8\ub378  task_train_model = Config.configure_task(id=\"train_model\",                                           input=train_dataset,                                           function=train_model,                                           output=[trained_model,feature_importance_cfg])                                       # \ud559\uc2b5 \ub370\uc774\ud130\uc138\ud2b8 --> \ud559\uc2b5 \ubaa8\ub378 \ub370\uc774\ud130 \uc0dd\uc131 --> \ud559\uc2b5\ub41c \ubaa8\ub378  task_train_model_baseline = Config.configure_task(id=\"train_model_baseline\",                                                    input=train_dataset,                                                    function=train_model_baseline,                                                    output=[trained_model_baseline,feature_importance_cfg])    # \ud14c\uc2a4\ud2b8 \ub370\uc774\ud130\uc138\ud2b8 --> \uc608\uce21 --> \uc608\uce21 \ub370\uc774\ud130 \uc138\ud2b8  task_forecast = Config.configure_task(id=\"predict_the_test_data\",                                        input=[test_dataset, trained_model],                                        function=forecast,                                        output=forecast_dataset)    # \ud14c\uc2a4\ud2b8 \ub370\uc774\ud130\uc138\ud2b8 --> \uc608\uce21 --> \uc608\uce21 \ub370\uc774\ud130 \uc138\ud2b8  task_forecast_baseline = Config.configure_task(id=\"predict_of_baseline\",                             input=[test_dataset, trained_model_baseline],                             function=forecast_baseline,                             output=forecast_dataset)    task_roc = Config.configure_task(id=\"task_roc\",                             input=[forecast_dataset, test_dataset],                             function=roc_from_scratch,                             output=[roc_data,score_auc])    task_roc_baseline = Config.configure_task(id=\"task_roc_baseline\",                             input=[forecast_dataset, test_dataset],                             function=roc_from_scratch,                             output=[roc_data,score_auc])    task_create_metrics = Config.configure_task(id=\"task_create_metrics\",                                              input=[forecast_dataset,test_dataset],                                              function=create_metrics,                                              output=metrics)    task_create_results = Config.configure_task(id=\"task_create_results\",                                              input=[forecast_dataset,test_dataset],                                              function=create_results,                                              output=results)        ##############################################################################################################################  # \ud30c\uc774\ud504\ub77c\uc778 \ubc0f \uc2dc\ub098\ub9ac\uc624 \uc0dd\uc131  ##############################################################################################################################    # \ud30c\uc774\ud504\ub77c\uc778 \ubc0f \uc2dc\ub098\ub9ac\uc624 \uad6c\uc131  pipeline_preprocessing = Config.configure_pipeline(id=\"pipeline_preprocessing\", task_configs=[task_preprocess_dataset,                                                                                                task_create_train_test])    pipeline_train_baseline = Config.configure_pipeline(id=\"pipeline_train_baseline\", task_configs=[task_train_model_baseline])  pipeline_train_model = Config.configure_pipeline(id=\"pipeline_train_model\", task_configs=[task_train_model])    pipeline_model = Config.configure_pipeline(id=\"pipeline_model\", task_configs=[task_forecast,                                                                                task_roc,                                                                                task_create_metrics,                                                                                task_create_results])    pipeline_baseline = Config.configure_pipeline(id=\"pipeline_baseline\", task_configs=[task_forecast_baseline,                                                                                      task_roc_baseline,                                                                                      task_create_metrics,                                                                                      task_create_results])    # \uc2dc\ub098\ub9ac\uc624\ub294 \ud30c\uc774\ud504\ub77c\uc778\uc744 \uc2e4\ud589\ud569\ub2c8\ub2e4.  scenario_cfg = Config.configure_scenario(id=\"churn_classification\",                                           pipeline_configs=[pipeline_preprocessing,                                                              pipeline_train_baseline, pipeline_train_model,                                                             pipeline_model,pipeline_baseline],                                           frequency=Frequency.WEEKLY)     "}
{"text": "from sklearn.linear_model import LogisticRegression  from sklearn.ensemble import RandomForestClassifier  from sklearn.model_selection import train_test_split  from sklearn.metrics import roc_auc_score    import datetime as dt    import pandas as pd  import numpy as np    ##############################################################################################################################  # \uc791\uc5c5\uc5d0\uc11c \uc0ac\uc6a9\ud558\ub294 \ud568\uc218  ##############################################################################################################################    def preprocess_dataset(initial_dataset: pd.DataFrame, date: dt.datetime=\"None\"):      \"\"\"\uc774 \ud568\uc218\ub294 \ubaa8\ub378\uc5d0\uc11c \uc0ac\uc6a9\ud560 \ub370\uc774\ud130\uc14b\uc744 \uc0ac\uc804 \ucc98\ub9ac\ud569\ub2c8\ub2e4.        Args:          initial_dataset (pd.DataFrame): \ub370\uc774\ud130\ub97c \ucc98\uc74c \uc77d\uc744 \ub54c\uc758 \uc6d0\uc2dc \ud615\uc2dd        Returns:          pd.DataFrame: \ubd84\ub958\ub97c \uc704\ud574 \uc0ac\uc804 \ucc98\ub9ac\ub41c \ub370\uc774\ud130 \uc138\ud2b8      \"\"\"      print(\"\\n     \ub370\uc774\ud130\uc138\ud2b8 \uc804\ucc98\ub9ac \uc911...\")            #\ub0a0\uc9dc\uc758 \ub370\uc774\ud130 \ud504\ub808\uc784\uc744 \ud544\ud130\ub9c1\ud569\ub2c8\ub2e4.      if date != \"None\":          initial_dataset['Date'] = pd.to_datetime(initial_dataset['Date'])          processed_dataset = initial_dataset[initial_dataset['Date'] <= date]          print(len(processed_dataset))      else:          processed_dataset = initial_dataset                processed_dataset = processed_dataset[['CreditScore','Geography','Gender','Age','Tenure','Balance','NumOfProducts','HasCrCard','IsActiveMember','EstimatedSalary','Exited']]                  processed_dataset = pd.get_dummies(processed_dataset)        if 'Gender_Female' in processed_dataset.columns:          processed_dataset.drop('Gender_Female',axis=1,inplace=True)                processed_dataset = processed_dataset.apply(pd.to_numeric)            columns_to_select = ['CreditScore', 'Age', 'Tenure', 'Balance', 'NumOfProducts', 'HasCrCard',                           'IsActiveMember', 'EstimatedSalary',  'Geography_France', 'Geography_Germany',                           'Geography_Spain',  'Gender_Male','Exited']            processed_dataset = processed_dataset[[col for col in columns_to_select if col in processed_dataset.columns]]        print(\"     \uc804\ucc98\ub9ac \uc644\ub8cc!\\n\")      return processed_dataset      def create_train_test_data(preprocessed_dataset: pd.DataFrame):      \"\"\"\uc774 \ud568\uc218\ub294 \ub370\uc774\ud130 \uc138\ud2b8\ub97c \ubd84\ud560\ud558\uc5ec \uae30\ucc28 \ub370\uc774\ud130\ub97c \uc0dd\uc131\ud569\ub2c8\ub2e4.        Args:          preprocessed_dataset (pd.DataFrame): \uc804\ucc98\ub9ac\ub41c \ub370\uc774\ud130 \uc138\ud2b8        Returns:          pd.DataFrame: \ud6c8\ub828 \ub370\uc774\ud130 \uc138\ud2b8      \"\"\"      print(\"\\n     Creating the training and testing dataset...\")            X_train, X_test, y_train, y_test = train_test_split(preprocessed_dataset.iloc[:,:-1],preprocessed_dataset.iloc[:,-1],test_size=0.2,random_state=42)            train_data = pd.concat([X_train,y_train],axis=1)      test_data = pd.concat([X_test,y_test],axis=1)      print(\"     \uc0dd\uc131 \uc644\ub8cc!\")      return train_data, test_data      def train_model_baseline(train_dataset: pd.DataFrame):      \"\"\"\ub85c\uc9c0\uc2a4\ud2f1 \ud68c\uadc0 \ubaa8\ub378\uc744 \ud6c8\ub828\uc2dc\ud0a4\ub294 \ud568\uc218        Args:          train_dataset (pd.DataFrame): \ud559\uc2b5 \ub370\uc774\ud130\uc138\ud2b8        Returns:          model (LogisticRegression): \ud53c\ud305\ub41c \ubaa8\ub378      \"\"\"      print(\"     \ubaa8\ub378 \ud559\uc2b5 \uc911...\\n\")      X,y = train_dataset.iloc[:,:-1],train_dataset.iloc[:,-1]      model_fitted = LogisticRegression().fit(X,y)      print(\"\\n    \",model_fitted,\" \ud559\uc2b5\ub418\uc5c8\uc2b5\ub2c8\ub2e4!\")            importance_dict = {'Features' : X.columns, 'Importance':model_fitted.coef_[0]}      importance = pd.DataFrame(importance_dict).sort_values(by='Importance',ascending=True)      return model_fitted, importance    def train_model(train_dataset: pd.DataFrame):      \"\"\"\ub85c\uc9c0\uc2a4\ud2f1 \ud68c\uadc0 \ubaa8\ub378\uc744 \ud6c8\ub828\uc2dc\ud0a4\ub294 \ud568\uc218        Args:          train_dataset (pd.DataFrame): \ud559\uc2b5 \ub370\uc774\ud130        Returns:          model (RandomForest): \ud53c\ud305\ub41c \ubaa8\ub378      \"\"\"      print(\"     \ubaa8\ub378 \ud559\uc2b5 \uc911...\\n\")      X,y = train_dataset.iloc[:,:-1],train_dataset.iloc[:,-1]      model_fitted = RandomForestClassifier().fit(X,y)      print(\"\\n    \",model_fitted,\" \ud559\uc2b5\ub418\uc5c8\uc2b5\ub2c8\ub2e4!\")            importance_dict = {'Features' : X.columns, 'Importance':model_fitted.feature_importances_}      importance = pd.DataFrame(importance_dict).sort_values(by='Importance',ascending=True)      return model_fitted, importance    def forecast(test_dataset: pd.DataFrame, trained_model: RandomForestClassifier):      \"\"\"\ud14c\uc2a4\ud2b8 \ub370\uc774\ud130 \uc138\ud2b8\ub97c \uc608\uce21\ud558\ub294 \uae30\ub2a5        Args:          test_dataset (pd.DataFrame): \ud14c\uc2a4\ud2b8 \ub370\uc774\ud130 \uc138\ud2b8          trained_model (LogisticRegression): \ud53c\ud305\ub41c \ubaa8\ub378        Returns:          forecast (pd.DataFrame): \uc608\uce21 \ub370\uc774\ud130 \uc138\ud2b8      \"\"\"      print(\"     \ud14c\uc2a4\ud2b8 \ub370\uc774\ud130 \uc138\ud2b8 \uc608\uce21 \uc911...\")      X,y = test_dataset.iloc[:,:-1],test_dataset.iloc[:,-1]      #predictions = trained_model.predict(X)      predictions = trained_model.predict_proba(X)[:, 1]      print(\"     \uc608\uce21 \uc644\ub8cc!\")      return predictions      def forecast_baseline(test_dataset: pd.DataFrame, trained_model: LogisticRegression):      \"\"\"\ud14c\uc2a4\ud2b8 \ub370\uc774\ud130 \uc138\ud2b8\ub97c \uc608\uce21\ud558\ub294 \uae30\ub2a5        Args:          test_dataset (pd.DataFrame): \ud14c\uc2a4\ud2b8 \ub370\uc774\ud130 \uc138\ud2b8          trained_model (LogisticRegression): \ud53c\ud305\ub41c \ubaa8\ub378        Returns:          forecast (pd.DataFrame): \uc608\uce21 \ub370\uc774\ud130 \uc138\ud2b8      \"\"\"      print(\"     \ud14c\uc2a4\ud2b8 \ub370\uc774\ud130 \uc138\ud2b8 \uc608\uce21 \uc911...\")      X,y = test_dataset.iloc[:,:-1],test_dataset.iloc[:,-1]      predictions = trained_model.predict_proba(X)[:, 1]      print(\"     \uc608\uce21 \uc644\ub8cc!\")      return predictions    def roc_from_scratch(probabilities, test_dataset, partitions=100):      print(\"     ROC \uace1\uc120\uc758 \uacc4\uc0b0...\")      y_test = test_dataset.iloc[:,-1]            roc = np.array([])      for i in range(partitions + 1):          threshold_vector = np.greater_equal(probabilities, i / partitions).astype(int)          tpr, fpr = true_false_positive(threshold_vector, y_test)          roc = np.append(roc, [fpr, tpr])            roc_np = roc.reshape(-1, 2)      roc_data = pd.DataFrame({\"False positive rate\": roc_np[:, 0], \"True positive rate\": roc_np[:, 1]})      print(\"     \uacc4\uc0b0 \uc644\ub8cc\")      print(\"     \uc2a4\ucf54\uc5b4\ub9c1\uc911...\")        score_auc = roc_auc_score(y_test, probabilities)      print(\"     \uc2a4\ucf54\uc5b4\ub9c1 \uc644\ub8cc\\n\")        return roc_data, score_auc      def true_false_positive(threshold_vector:np.array, y_test:np.array):      \"\"\"\ucc38\uc591\uc131\ub960\uacfc \uac70\uc9d3\uc591\uc131\ub960\uc744 \uacc4\uc0b0\ud558\ub294 \ud568\uc218            Args:          threshold_vector (np.array): \ud14c\uc2a4\ud2b8 \ub370\uc774\ud130 \uc138\ud2b8          y_test (np.array): \ud53c\ud305\ub41c \ubaa8\ub378        Returns:          tpr (pd.DataFrame): \uc608\uce21\ub41c \ub370\uc774\ud130 \uc138\ud2b8          fpr (pd.DataFrame): \uc608\uce21\ub41c \ub370\uc774\ud130 \uc138\ud2b8      \"\"\"            true_positive = np.equal(threshold_vector, 1) & np.equal(y_test, 1)      true_negative = np.equal(threshold_vector, 0) & np.equal(y_test, 0)      false_positive = np.equal(threshold_vector, 1) & np.equal(y_test, 0)      false_negative = np.equal(threshold_vector, 0) & np.equal(y_test, 1)        tpr = true_positive.sum() / (true_positive.sum() + false_negative.sum())      fpr = false_positive.sum() / (false_positive.sum() + true_negative.sum())        return tpr, fpr    def create_metrics(predictions:np.array, test_dataset:np.array):      print(\"     \uba54\ud2b8\ub9ad \uc0dd\uc131 \uc911...\")      threshold = 0.5      threshold_vector = np.greater_equal(predictions, threshold).astype(int)            y_test = test_dataset.iloc[:,-1]            true_positive = (np.equal(threshold_vector, 1) & np.equal(y_test, 1)).sum()      true_negative = (np.equal(threshold_vector, 0) & np.equal(y_test, 0)).sum()      false_positive = (np.equal(threshold_vector, 1) & np.equal(y_test, 0)).sum()      false_negative = (np.equal(threshold_vector, 0) & np.equal(y_test, 1)).sum()          f1_score = np.around(2*true_positive/(2*true_positive+false_positive+false_negative), decimals=2)      accuracy = np.around((true_positive+true_negative)/(true_positive+true_negative+false_positive+false_negative), decimals=2)      dict_ftpn = {\"tp\": true_positive, \"tn\": true_negative, \"fp\": false_positive, \"fn\": false_negative}                  number_of_good_predictions = true_positive + true_negative      number_of_false_predictions = false_positive + false_negative            metrics = {\"f1_score\": f1_score,                 \"accuracy\": accuracy,                 \"dict_ftpn\": dict_ftpn,                 'number_of_predictions': len(predictions),                 'number_of_good_predictions':number_of_good_predictions,                 'number_of_false_predictions':number_of_false_predictions}            print(\"     \uba54\ud2b8\ub9ad \uc0dd\uc131 \uc644\ub8cc!\")      return metrics          def create_results(forecast_values,test_dataset):      forecast_series_proba = pd.Series(np.around(forecast_values,decimals=2), index=test_dataset.index, name='Probability')      forecast_series = pd.Series((forecast_values>0.5).astype(int), index=test_dataset.index, name='Forecast')      true_series = pd.Series(test_dataset.iloc[:,-1], name=\"Historical\",index=test_dataset.index)      index_series = pd.Series(range(len(true_series)), index=test_dataset.index, name=\"Id\")            results = pd.concat([index_series, forecast_series_proba, forecast_series, true_series], axis=1)      return results "}
{"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": "import pandas as pd  import numpy as np      dv_graph_selector = ['Histogram','Scatter']  dv_graph_selected = dv_graph_selector[0]    # \ud788\uc2a4\ud1a0\uadf8\ub7a8 \ub300\ud654 \uc0c1\uc790  dv_width_histo = \"100%\"  dv_height_histo = 600    dv_dict_overlay = {'barmode':'overlay', \"margin\":{\"t\":20}}    dv_select_x_ = ['CREDITSCORE', 'AGE', 'TENURE', 'BALANCE', 'NUMOFPRODUCTS', 'HASCRCARD', 'ISACTIVEMEMBER', 'ESTIMATEDSALARY', 'GEOGRAPHY_FRANCE', 'GEOGRAPHY_GERMANY', 'GEOGRAPHY_SPAIN', 'GENDER_MALE']      def creation_scatter_dataset(test_dataset:pd.DataFrame):      \"\"\"\uc774 \ud568\uc218\ub294 \uc0b0\uc810\ub3c4\uc5d0 \ub300\ud55c \ub370\uc774\ud130\uc14b\uc744 \uc0dd\uc131\ud569\ub2c8\ub2e4. \ubaa8\ub4e0 \uc5f4(Exited \uc81c\uc678)\uc5d0 \ub300\ud574 \uc591\uc218 \ubc0f \uc74c\uc218 \ubc84\uc804\uc774 \uc788\uc2b5\ub2c8\ub2e4.      \uc591\uc218 \uc5f4\uc740 Exited\uac00 0\uc77c \ub54c NaN\uc744 \uac00\uc9c0\uba70 \uc74c\uc218 \uc5f4\uc740 Exited\uac00 1\uc77c \ub54c NaN\uc744 \uac16\uc2b5\ub2c8\ub2e4.        Args:          test_dataset (pd.DataFrame): \ud14c\uc2a4\ud2b8 \ub370\uc774\ud130 \uc138\ud2b8                Returns:          pd.DataFrame: \ub370\uc774\ud130\ud504\ub808\uc784      \"\"\"      scatter_dataset = test_dataset.copy()        for column in scatter_dataset.columns:          if column != 'EXITED' :              column_neg = str(column)+'_neg'              column_pos = str(column)+'_pos'                            scatter_dataset[column_neg] = scatter_dataset[column]              scatter_dataset[column_pos] = scatter_dataset[column]                            scatter_dataset.loc[(scatter_dataset['EXITED'] == 1),column_neg] = np.NaN              scatter_dataset.loc[(scatter_dataset['EXITED'] == 0),column_pos] = np.NaN            return scatter_dataset      def creation_of_dialog_scatter(column, state=None):      \"\"\"\uc774 \ucf54\ub4dc\ub294 \uc0b0\uc810\ub3c4\uc5d0 \uc0ac\uc6a9\ub418\ub294 Markdown\uc744 \uc0dd\uc131\ud569\ub2c8\ub2e4. \ubd80\ubd84(\ub2e4\uc2dc \ub85c\ub4dc\ud560 \uc218 \uc788\ub294 \ubbf8\ub2c8 \ud398\uc774\uc9c0)\uc744 \ubcc0\uacbd\ud558\ub294 \ub370 \uc0ac\uc6a9\ub429\ub2c8\ub2e4.       \uc120\ud0dd\uae30\uac00 \uc0dd\uc131\ub418\uace0 \uadf8\ub798\ud504\uc758 x \ubc0f y\ub294 \uc5ec\uae30\uc5d0\uc11c \ubcc0\uacbd\ud558\uc5ec \uacb0\uc815\ub429\ub2c8\ub2e4.       \uc18d\uc131\uc758 \uc0ac\uc804\ub3c4 \uc0ac\uc6a9\ud558\ub294 \uc5f4\uc5d0 \ub530\ub77c \ubcc0\uacbd\ub429\ub2c8\ub2e4.      \"\"\"      if column == 'AGE' or column == 'CREDITSCORE' and state is not None:          state.dv_dict_overlay = {'barmode':'overlay',\"margin\":{\"t\":20}}      elif state is not None:          state.dv_dict_overlay = {\"margin\":{\"t\":20}}                md = \"\"\"  <|layout|columns= 1 1 1|columns[mobile]=1|  <|  Type of graph \\n \\n <|{dv_graph_selected}|selector|lov={dv_graph_selector}|dropdown|>  |>    <|  Select **x** \\n \\n <|{x_selected}|selector|lov={select_x}|dropdown=True|>  |>    <|  Select **y** \\n \\n <|{y_selected}|selector|lov={select_y}|dropdown=True|>  |>  |>    <|part|render={x_selected=='\"\"\"+column+\"\"\"'}|  <|{scatter_dataset}|chart|x=\"\"\"+column+\"\"\"|y[1]={y_selected+'_pos'}|y[2]={y_selected+'_neg'}|color[1]=red|color[2]=green|name[1]=Exited|name[2]=Stayed|height={dv_height_histo}|width={dv_width_histo}|mode=markers|type=scatter|layout={dv_dict_overlay}|>  |>  \"\"\"      return md        def creation_histo_full(test_dataset:pd.DataFrame):      \"\"\"\uc774 \ud568\uc218\ub294 \ud788\uc2a4\ud1a0\uadf8\ub7a8 \ud50c\ub86f\uc5d0 \ub300\ud55c \ub370\uc774\ud130 \uc138\ud2b8\ub97c \uc0dd\uc131\ud569\ub2c8\ub2e4. \ubaa8\ub4e0 \uc5f4(Exited \uc81c\uc678)\uc5d0 \ub300\ud574 \uc591\uc218 \ubc0f \uc74c\uc218 \ubc84\uc804\uc774 \uc788\uc2b5\ub2c8\ub2e4.      Exited\uac00 0\uc77c \ub54c \uc591\uc218 \uc5f4\uc5d0\ub294 NaN\uc774 \uc788\uace0 Exited\uac00 1\uc77c \ub54c \uc74c\uc218 \uc5f4\uc5d0\ub294 NaN\uc774 \uc788\uc2b5\ub2c8\ub2e4.         Args:          test_dataset (pd.DataFrame): \ud14c\uc2a4\ud2b8 \ub370\uc774\ud130\uc138\ud2b8        Returns:          pd.DataFrame: \ud788\uc2a4\ud1a0\uadf8\ub7a8\uc744 \ud45c\uc2dc\ud558\ub294 \ub370 \uc0ac\uc6a9\ub418\ub294 \ub370\uc774\ud130 \ud504\ub808\uc784      \"\"\"      histo_full = test_dataset.copy()      # \uac01 \ud074\ub798\uc2a4\uc5d0 \ub300\ud574 \ub3d9\uc77c\ud55c \uc218\uc758 \ud3ec\uc778\ud2b8\ub97c \uac16\ub3c4\ub85d \uacb0\uc815\uc801 \uc624\ubc84\uc0d8\ud50c\ub9c1\uc744 \uc0dd\uc131\ud569\ub2c8\ub2e4.      histo_1 = histo_full.loc[histo_full['EXITED'] == 1]                frames = [histo_full,histo_1,histo_1,histo_1]            histo_full = pd.concat(frames, sort=False)            for column in histo_full.columns:          column_neg = str(column)+'_neg'          histo_full[column_neg] = histo_full[column]          histo_full.loc[(histo_full['EXITED'] == 1),column_neg] = np.NaN          histo_full.loc[(histo_full['EXITED'] == 0),column] = np.NaN                return histo_full      def creation_of_dialog_histogram(column, state=None):      \"\"\"\uc774 \ucf54\ub4dc\ub294 \ud788\uc2a4\ud1a0\uadf8\ub7a8 \ud50c\ub86f\uc5d0 \uc0ac\uc6a9\ub418\ub294 \ub9c8\ud06c\ub2e4\uc6b4\uc744 \uc0dd\uc131\ud569\ub2c8\ub2e4. \ubd80\ubd84(\ub2e4\uc2dc \ub85c\ub4dc\ud560 \uc218 \uc788\ub294 \ubbf8\ub2c8 \ud398\uc774\uc9c0)\uc744 \ubcc0\uacbd\ud558\ub294 \ub370 \uc0ac\uc6a9\ub429\ub2c8\ub2e4.       \uc120\ud0dd\uae30\uac00 \uc0dd\uc131\ub418\uace0 \uadf8\ub798\ud504\uc758 x\ub294 \uc5ec\uae30\uc5d0\uc11c \ubcc0\uacbd\ud558\uc5ec \uacb0\uc815\ub429\ub2c8\ub2e4.       \uc18d\uc131\uc758 \uc0ac\uc804\ub3c4 \uc0ac\uc6a9\ud558\ub294 \uc5f4\uc5d0 \ub530\ub77c \ubcc0\uacbd\ub429\ub2c8\ub2e4.      \"\"\"      if column == 'AGE' or column == 'CREDITSCORE' and state is not None:          state.dv_dict_overlay = {'barmode':'overlay',\"margin\":{\"t\":20}}      elif state is not None:          state.dv_dict_overlay = {\"margin\":{\"t\":20}}                md = \"\"\"  <|layout|columns= 1 1 1|columns[mobile]=1|  <|  Select type of graph : \\n \\n <|{dv_graph_selected}|selector|lov={dv_graph_selector}|dropdown|>  |>    <|  Select **x**: \\n \\n <|{x_selected}|selector|lov={select_x}|dropdown=True|>  |>  |>      <|{histo_full[['\"\"\"+column+\"\"\"','\"\"\"+column+\"\"\"_neg','EXITED']]}|chart|type=histogram|x[1]=\"\"\"+column+\"\"\"|x[2]=\"\"\"+column+\"\"\"_neg|y=EXITED|label=EXITED|color[1]=red|color[2]=green|name[1]=Exited|name[2]=Stayed|height={dv_height_histo}|width={dv_width_histo}|layout={dv_dict_overlay}|class_name=histogram|>  \"\"\"      return md    dv_data_visualization_md = \"\"\"  # \ub370\uc774\ud130 \uc2dc\uac01\ud654    <|part|render={dv_graph_selected == 'Histogram'}|partial={partial_histo}|>    <|part|render={dv_graph_selected == 'Scatter'}|partial={partial_scatter}|>    \"\"\"   "}
{"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": "import pandas as pd  import numpy as np      mm_select_x_ = ['CREDITSCORE', 'AGE', 'TENURE', 'BALANCE', 'NUMOFPRODUCTS', 'HASCRCARD', 'ISACTIVEMEMBER', 'ESTIMATEDSALARY', 'GEOGRAPHY_FRANCE', 'GEOGRAPHY_GERMANY', 'GEOGRAPHY_SPAIN', 'GENDER_MALE']    mm_graph_selector_scenario = ['Metrics', 'Features', 'Histogram','Scatter']  mm_graph_selected_scenario = mm_graph_selector_scenario[0]    mm_algorithm_selector = ['Baseline','ML']  mm_algorithm_selected = mm_algorithm_selector[0]    mm_pie_color_dict_2 ={\"piecolorway\":[\"#00D08A\",\"#FE913C\"]}  mm_pie_color_dict_4 = {\"piecolorway\":[\"#00D08A\",\"#81F1A0\",\"#F3C178\",\"#FE913C\"]}    mm_height_histo = 530      mm_margin_features = {'margin': {'l': 150, 'r': 50, 'b': 50, 't': 20}}    def creation_scatter_dataset_pred(test_dataset:pd.DataFrame, forecast_series:pd.Series):      \"\"\"\uc774 \ud568\uc218\ub294 \uc608\uce21\uc744 \uc704\ud55c \uc0b0\uc810\ub3c4\uc5d0 \ub300\ud55c \ub370\uc774\ud130 \uc138\ud2b8\ub97c \uc0dd\uc131\ud569\ub2c8\ub2e4. \ubaa8\ub4e0 \uc5f4(EXITED \uc81c\uc678)\uc5d0 \ub300\ud574 \uc591\uc218 \ubc0f \uc74c\uc218 \ubc84\uc804\uc774 \uc788\uc2b5\ub2c8\ub2e4.      EXITED\ub294 \uc608\uce21\uc774 \uc88b\uc740\uc9c0 \ub098\uc05c\uc9c0\ub97c \ub098\ud0c0\ub0b4\ub294 \ubc14\uc774\ub108\ub9ac\uc785\ub2c8\ub2e4.      \uc591\uc218 \uc5f4\uc740 Exited\uac00 0\uc77c \ub54c NaN\uc744 \uac00\uc9c0\uba70 \uc74c\uc218 \uc5f4\uc740 Exited\uac00 1\uc77c \ub54c NaN\uc744 \uac16\uc2b5\ub2c8\ub2e4.         Args:          test_dataset (pd.DataFrame): \ud14c\uc2a4\ud2b8 \ub370\uc774\ud130 \uc138\ud2b8          forecast_series (pd.DataFrame): \uc608\uce21 \ub370\uc774\ud130 \uc138\ud2b8        Returns:          pd.DataFrame: \ud788\uc2a4\ud1a0\uadf8\ub7a8\uc744 \ud45c\uc2dc\ud558\ub294 \ub370 \uc0ac\uc6a9\ub418\ub294 \ub370\uc774\ud130 \ud504\ub808\uc784      \"\"\"            scatter_dataset = test_dataset.copy()      scatter_dataset['EXITED'] =  (scatter_dataset['EXITED']!=forecast_series.to_numpy()).astype(int)        for column in scatter_dataset.columns:          if column != 'EXITED' :              column_neg = str(column)+'_neg'              column_pos = str(column)+'_pos'                            scatter_dataset[column_neg] = scatter_dataset[column]              scatter_dataset[column_pos] = scatter_dataset[column]                            scatter_dataset.loc[(scatter_dataset['EXITED'] == 1),column_neg] = np.NaN              scatter_dataset.loc[(scatter_dataset['EXITED'] == 0),column_pos] = np.NaN            return scatter_dataset      def creation_of_dialog_scatter_pred(column, state=None):      \"\"\"\uc774 \ucf54\ub4dc\ub294 \uc608\uce21\uc744 \uc704\ud55c \uc0b0\uc810\ub3c4\uc5d0 \uc0ac\uc6a9\ub418\ub294 \ub9c8\ud06c\ub2e4\uc6b4\uc744 \uc0dd\uc131\ud569\ub2c8\ub2e4. \ubd80\ubd84(\ub2e4\uc2dc \ub85c\ub4dc\ud560 \uc218 \uc788\ub294 \ubbf8\ub2c8 \ud398\uc774\uc9c0)\uc744 \ubcc0\uacbd\ud558\ub294 \ub370 \uc0ac\uc6a9\ub429\ub2c8\ub2e4.       \uc120\ud0dd\uae30\uac00 \uc0dd\uc131\ub418\uace0 \uadf8\ub798\ud504\uc758 x \ubc0f y\ub294 \uc5ec\uae30\uc5d0\uc11c \ubcc0\uacbd\ud558\uc5ec \uacb0\uc815\ub429\ub2c8\ub2e4.       \uc18d\uc131\uc758 \uc0ac\uc804\ub3c4 \uc0ac\uc6a9\ud558\ub294 \uc5f4\uc5d0 \ub530\ub77c \ubcc0\uacbd\ub429\ub2c8\ub2e4.      \"\"\"      if column == 'AGE' or column == 'CREDITSCORE' and state is not None:          state.dv_dict_overlay = {'barmode':'overlay',\"margin\":{\"t\":20}}      elif state is not None:          state.dv_dict_overlay = {\"margin\":{\"t\":20}}                md = \"\"\"  <|layout|columns= 1 1|columns[mobile]=1|  <|  Select **x** \\n \\n <|{x_selected}|selector|lov={select_x}|dropdown|>  |>    <|  Select **y** \\n \\n <|{y_selected}|selector|lov={select_y}|dropdown|>  |>  |>    <|{scatter_dataset_pred}|chart|x=\"\"\"+column+\"\"\"|y[1]={y_selected+'_pos'}|y[2]={y_selected+'_neg'}|color[1]=red|color[2]=green|name[1]=Bad prediction|name[2]=Good prediction|height={mm_height_histo}|width={dv_width_histo}|mode=markers|type=scatter|layout={dv_dict_overlay}|>    \"\"\"      return md      def creation_histo_full_pred(test_dataset:pd.DataFrame,forecast_series:pd.Series):      \"\"\"\uc774 \ud568\uc218\ub294 \uc608\uce21\uc5d0 \ub300\ud55c \ud788\uc2a4\ud1a0\uadf8\ub7a8 \ud50c\ub86f\uc5d0 \ub300\ud55c \ub370\uc774\ud130 \uc138\ud2b8\ub97c \uc0dd\uc131\ud569\ub2c8\ub2e4. \ubaa8\ub4e0 \uc5f4(PREDICTION \uc81c\uc678)\uc5d0 \ub300\ud574 \uc591\uc218 \ubc0f \uc74c\uc218 \ubc84\uc804\uc774 \uc788\uc2b5\ub2c8\ub2e4.      PREDICTION\uc740 \uc608\uce21\uc774 \uc88b\uc740\uc9c0 \ub098\uc05c\uc9c0\ub97c \ub098\ud0c0\ub0b4\ub294 \uc774\uc9c4\ubc95\uc785\ub2c8\ub2e4.      PREDICTION\uc774 0\uc77c \ub54c \uc591\uc218 \uc5f4\uc5d0\ub294 NaN\uc774 \uc788\uace0 PREDICTION\uc774 1\uc77c \ub54c \uc74c\uc218 \uc5f4\uc5d0\ub294 NaN\uc774 \uc788\uc2b5\ub2c8\ub2e4.         Args:          test_dataset (pd.DataFrame): \ud14c\uc2a4\ud2b8 \ub370\uc774\ud130 \uc138\ud2b8          Forecast_series (pd.DataFrame): \uc608\uce21 \ub370\uc774\ud130 \uc138\ud2b8        Returns:          pd.DataFrame: \ud788\uc2a4\ud1a0\uadf8\ub7a8\uc744 \ud45c\uc2dc\ud558\ub294 \ub370 \uc0ac\uc6a9\ub418\ub294 \ub370\uc774\ud130 \ud504\ub808\uc784      \"\"\"      histo_full = test_dataset.copy()      histo_full['EXITED'] =  (histo_full['EXITED']!=forecast_series.to_numpy()).astype(int)      histo_full.columns = histo_full.columns.str.replace('EXITED', 'PREDICTION')            for column in histo_full.columns:          column_neg = str(column)+'_neg'          histo_full[column_neg] = histo_full[column]          histo_full.loc[(histo_full['PREDICTION'] == 1),column_neg] = np.NaN          histo_full.loc[(histo_full['PREDICTION'] == 0),column] = np.NaN                return histo_full      metrics_md = \"\"\"  <br/>  <|layout|columns=1 1 1|columns[mobile]=1|    <|  <|{accuracy}|indicator|value={accuracy}|min=0|max=1|width=200px|>  <center>  **Model accuracy**  </center>  <|{pie_plotly}|chart|x=values|label=labels|title=Accuracy of predictions model|height={height_plotly}|width=100%|type=pie|layout={mm_pie_color_dict_2}|>  |>    <|  <|{score_auc}|indicator|value={score_auc}|min=0|max=1|width=200px|>  <center>  **Model AUC**  </center>  <|{pie_confusion_matrix}|chart|x=values|label=labels|title=Confusion Matrix|height={height_plotly}|width=100%|type=pie|layout={mm_pie_color_dict_4}|>  |>    <|  <|{f1_score}|indicator|value={f1_score}|min=0|max=1|width=200px|>  <center>  **Model F1-score**  </center>  <|{distrib_class}|chart|x=values|label=labels|title=Distribution between Exited and Stayed|height={height_plotly}|width=100%|type=pie|layout={mm_pie_color_dict_2}|>  |>    |>  \"\"\"      features_md = \"\"\"  <|{features_table}|chart|type=bar|y=Features|x=Importance|orientation=h|layout={mm_margin_features}|>  \"\"\"    def creation_of_dialog_histogram_pred(column, state=None):      \"\"\"\uc774 \ucf54\ub4dc\ub294 \uc0b0\uc810\ub3c4\uc5d0 \uc0ac\uc6a9\ub41c \ub9c8\ud06c\ub2e4\uc6b4\uc744 \uc0dd\uc131\ud569\ub2c8\ub2e4. \ubd80\ubd84(\ub2e4\uc2dc \ub85c\ub4dc\ud560 \uc218 \uc788\ub294 \ubbf8\ub2c8 \ud398\uc774\uc9c0)\uc744 \ubcc0\uacbd\ud558\ub294 \ub370 \uc0ac\uc6a9\ub429\ub2c8\ub2e4.       \uc120\ud0dd\uc790\uac00 \uc0dd\uc131\ub418\uace0 \uc5ec\uae30\uc5d0\uc11c \ubcc0\uacbd\ud558\uc5ec \uadf8\ub798\ud504\uc758 x\uac00 \uacb0\uc815\ub429\ub2c8\ub2e4.       \uc18d\uc131\uc758 \uc0ac\uc804\ub3c4 \uc0ac\uc6a9\ud558\ub294 \uc5f4\uc5d0 \ub530\ub77c \ubcc0\uacbd\ub429\ub2c8\ub2e4.      \"\"\"      if column == 'AGE' or column == 'CREDITSCORE' and state is not None:          state.dv_dict_overlay = {'barmode':'overlay',\"margin\":{\"t\":20}}      elif state is not None:          state.dv_dict_overlay = {\"margin\":{\"t\":20}}                md = \"\"\"  <|  Select **x** \\n \\n <|{x_selected}|selector|lov={select_x}|dropdown=True|>  |>    <|{histo_full_pred[['\"\"\"+column+\"\"\"','\"\"\"+column+\"\"\"_neg','PREDICTION']]}|chart|type=histogram|x[1]=\"\"\"+column+\"\"\"|x[2]=\"\"\"+column+\"\"\"_neg|y=PREDICTION|label=PREDICTION|color[1]=red|color[2]=green|name[1]=Bad prediction|name[2]=Good prediction|height={mm_height_histo}|width={dv_width_histo}|layout={dv_dict_overlay}|class_name=histogram|>    \"\"\"      return md      mm_model_manager_md = \"\"\"  # \ubaa8\ub378 \ub9e4\ub2c8\uc800    <|layout|columns=1 1 1 1|columns[mobile]=1|  Algorithm  <|{mm_algorithm_selected}|selector|lov={mm_algorithm_selector}|dropdown=True|>    Type of graph  <|{mm_graph_selected_scenario}|selector|lov={mm_graph_selector_scenario}|dropdown=True|>    <br/>  <br/>  <center>  <|show roc|button|on_action=show_roc_fct|>  </center>    <br/>  <br/>  <center>  **Number of predictions: ** *<|{number_of_predictions}|>*  </center>  |>    <|part|render={mm_graph_selected_scenario == 'Metrics'}|  \"\"\"+metrics_md+\"\"\"  |>    <|part|render={mm_graph_selected_scenario == 'Features'}|  \"\"\"+features_md+\"\"\"  |>    <|part|render={mm_graph_selected_scenario == 'Scatter'}|partial={partial_scatter_pred}|>    <|part|render={mm_graph_selected_scenario == 'Histogram'}|partial={partial_histo_pred}|>    \"\"\" "}
{"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 pandas as pd  import numpy as np  from ultis.dataloader import DataLoader  from helper.svd_helper import sgd, predict_svd_pair  from helper.knn_helper import predict_pair, compute_similarity_matrix    VALID_ALGORITHM = [\"kNN\", \"MF\"]      def preprocess_data(      train_data: pd.DataFrame, test_data: pd.DataFrame, movie_name: pd.DataFrame  ):      \"\"\"Preprocess data from Pd.DataFrame.        Args:          train_data (pd.DataFrame): Train data load from \"csv\" file.          test_data (pd.DataFrame): Test data load from \"csv\" file.          movie_name (pd.DataFrame): The name of movies to recommend load from  \"csv\" file.        Returns:          train_set (numpy.array): Preprocessed training data.          test_set (numpy.array): Preprocessed testing data.          true_testset_movies_id (numpydarray): When convert, the movie_ids are reseting index, list all actual movies_id.      \"\"\"      loader = DataLoader()      true_testset_movies_id = test_data.i_id.to_numpy()      train_set, test_set = loader.load_csv2ndarray(          train_data=train_data,          test_data=test_data,          columns=[\"u_id\", \"i_id\", \"rating\", \"timestamp\"],      )      return train_set, test_set, true_testset_movies_id      def fit(      X,      sim_measure=\"pcc\",      n_factors=100,      n_epochs=50,      learning_rate=0.01,      algorithm=\"kNN\",  ):      \"\"\"Train the recommendation model.        Args:          X (numpyarray): Training data.          sim_measure (str, optional):  Similarity measure function. Defaults to \"pcc\".          n_factors (int, optional): Number of latent factors. Defaults to 100.          n_epochs (int, optional): Number of SGD iterations. Defaults to 50.          learning_rate (float, optional): The common learning rate. Defaults to 0.01.          algorithm (str, optional): The algorithm used to make recommendations. Possible values are \"kNN\" or \"MF. Defaults to \"kNN\".        Returns:          S (numpyarray): Compute the similarity between all pairs of users.          x_rated (numpyarray): All users who rated each item are stored in list.          x_list (numpyarray): All user id in training set.          y_list (numpyarray): All movie id in training set.          global_mean (float): Mean ratings in training set.          pu (numpyarray): Users latent factor matrix.          qi (numpyarray): Items latent factor matrix.          bu (numpyarray): Users biases vector.          bi (numpyarray): Items biases vector.      \"\"\"      if algorithm not in VALID_ALGORITHM:          raise SystemExit(              f\"{algorithm} is not a valid algorithm. Possible values are {VALID_ALGORITHM}.\\n\")        global_mean = np.mean(X[:, 2])      if algorithm == \"kNN\":          S, x_rated, x_list, y_list = compute_similarity_matrix(              X, sim_measure          )          pu, qi, bu, bi = [], [], [], []        elif algorithm == \"MF\":            users_list = np.unique(X[:, 0])          items_list = np.unique(X[:, 1])          n_user = users_list.shape[0]          n_item = items_list.shape[0]            # Initialize pu, qi, bu, bi          qi = np.random.normal(0, 0.1, (n_item, n_factors))          pu = np.random.normal(0, 0.1, (n_user, n_factors))          bu = np.zeros(n_user)          bi = np.zeros(n_item)            lr_pu, lr_qi, lr_bu, lr_bi, reg_pu, reg_qi, reg_bu, reg_bi = (              learning_rate, learning_rate, learning_rate, learning_rate, learning_rate, learning_rate, learning_rate, learning_rate,)          pu, qi, bu, bi, _ = 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,          )          S, x_rated, x_list, y_list = [], [], [], []      else:          S, x_rated, x_list, y_list, pu, qi, bu, bi = (              0, 0, 0, 0, 0, 0, 0, 0,)        return S, x_rated, x_list, y_list, global_mean, pu, qi, bu, bi      def predict(      test_set_origin,      x_id, x_rated, S, k, min_k, x_list, y_list,      global_mean, true_testset_movies_id,      bu, bi, pu, qi, algorithm=\"MF\",  ):      \"\"\"Predict the ratings to movies.        Args:          test_set_origin (numpyarray): Storing all user/item pairs we want to predict the ratings.          x_id (int): The user_id we want to recommend to him.          x_rated (numpyarray): All users who rated each item are stored in list.          S (numpyarray): Compute the similarity between all pairs of users.          k (int): Number of neighbors use in prediction.          min_k (int): The minimum number of neighbors to take into account for aggregation. If there are not enough neighbors, the neighbor aggregation is set to zero          x_list (numpyarray): All user id in training set.          y_list (numpyarray): All movie id in training set.          global_mean (float): Mean ratings in training set.          true_testset_movies_id (numpyarray): List all actual movie id.          bu (numpyarray): Users biases vector.          bi (numpyarray): Items biases vector.          pu (numpyarray): Users latent factor matrix.          qi (numpyarray): Items latent factor matrix.          algorithm (str, optional): The algorithm used to make recommendations. Possible values are \"kNN\" or \"MF\". Defaults to \"MF\".        Returns:          predictions (numpyarray): Storing all predictions of the given user/item pairs. The first column is user id, the second column is item id, the thirh colums is the actual movie id, the forth column is the observed rating, and the fifth column is the predicted rating.      \"\"\"      if algorithm not in VALID_ALGORITHM:          raise SystemExit(              f\"{algorithm} is not a valid algorithm. Possible values are {VALID_ALGORITHM}.\\n\")      test_items = []      test_set = np.zeros(          (test_set_origin.shape[0], test_set_origin.shape[1] + 1))      test_set[:, :3] = test_set_origin      test_set[:, 3] = true_testset_movies_id.T      test_set[:, [0, 1]] = test_set[:, [1, 0]]        for index in range(test_set.shape[0]):          if test_set[index][1] == x_id:              test_items.append(test_set[index])      test_items = np.array(test_items)      n_pairs = test_items.shape[0]        predictions = np.zeros((n_pairs, test_items.shape[1] + 1))      predictions[:, :4] = test_items        if algorithm == \"MF\":          for pair in range(n_pairs):              predictions[pair, 4] = predict_svd_pair(                  test_items[pair, 0].astype(int),                  test_items[pair, 1].astype(int),                  global_mean,                  bu, bi, pu, qi,              )        elif algorithm == \"kNN\":          for pair in range(n_pairs):              predictions[pair, 4] = predict_pair(                  test_items[pair, 0].astype(int),                  test_items[pair, 1].astype(int),                  x_rated, S, k, min_k,                  x_list, y_list,                  global_mean,              )        np.clip(predictions[:, 4], 0.5, 5, out=predictions[:, 4])      return predictions "}
{"text": "import numpy as np  from numba import njit      def compute_similarity_matrix(train_set, sim_measure=\"pcc\"):      x_rated, _, n_x, _, x_list, y_list = list_ur_ir(train_set)      if sim_measure == \"pcc\":          print(\"Computing similarity matrix as pcc...\")          S = pcc(n_x, x_rated, min_support=1)      elif sim_measure == \"cosine\":          print(\"Computing similarity matrix as cosine...\")          S = cosine(n_x, x_rated, min_support=1)      else:          S = 0      return S, x_rated, x_list, y_list      def fit_train_set(train_set):      X = train_set.copy()      # Swap user_id column to movie_id column if using iiCF      X[:, [0, 1]] = X[:, [1, 0]]        x_list = np.unique(X[:, 0])  # For uuCF, x -> user      y_list = np.unique(X[:, 1])  # For uuCF, y -> item      n_x = len(x_list)      n_y = len(y_list)      return n_x, n_y, X, x_list, y_list      def list_ur_ir(train_set):      n_x, n_y, X, x_list, y_list = fit_train_set(train_set)      x_rated = [          [] for _ in range(n_y)      ]  # List where element `i` is ndarray of `(x, rating)` where `x` is all x that rated y, and the ratings.      y_ratedby = [          [] for _ in range(n_x)      ]  # List where element `i` is ndarray of `(y, rating)` where `y` is all y that rated by x, and the ratings.        for xid, yid, r in X:          x_rated[int(yid)].append([xid, r])          y_ratedby[int(xid)].append([yid, r])        for yid in range(n_y):          x_rated[yid] = np.array(x_rated[yid])      for xid in range(n_x):          y_ratedby[xid] = np.array(y_ratedby[xid])      return x_rated, y_ratedby, n_x, n_y, x_list, y_list      def pcc(n_x, yr, min_support=1):      \"\"\"Compute the Pearson coefficient correlation between all pairs of users (or items).      Only **common** users (or items) are taken into account.      \"\"\"      prods = np.zeros((n_x, n_x), np.double)      freq = np.zeros((n_x, n_x), np.int)      sqi = np.zeros((n_x, n_x), np.double)      sqj = np.zeros((n_x, n_x), np.double)      si = np.zeros((n_x, n_x), np.double)      sj = np.zeros((n_x, n_x), np.double)        for y_ratings in yr:          prods, freq, sqi, sqj, si, sj = run_pearson_params(              prods, freq, sqi, sqj, si, sj, y_ratings          )        sim = calculate_pearson_similarity(          prods, freq, sqi, sqj, si, sj, n_x, min_support)        return sim      @njit  def run_pearson_params(prods, freq, sqi, sqj, si, sj, y_ratings):      for xi, ri in y_ratings:          xi = int(xi)          for xj, rj in y_ratings:              xj = int(xj)              freq[xi, xj] += 1              prods[xi, xj] += ri * rj              sqi[xi, xj] += ri**2              sqj[xi, xj] += rj**2              si[xi, xj] += ri              sj[xi, xj] += rj        return prods, freq, sqi, sqj, si, sj      @njit  def calculate_pearson_similarity(prods, freq, sqi, sqj, si, sj, n_x, min_sprt):      sim = np.zeros((n_x, n_x), np.double)        for xi in range(n_x):          sim[xi, xi] = 1          for xj in range(xi + 1, n_x):              if freq[xi, xj] < min_sprt:                  sim[xi, xj] = 0              else:                  n = freq[xi, xj]                  num = n * prods[xi, xj] - si[xi, xj] * sj[xi, xj]                  denum = np.sqrt(                      (n * sqi[xi, xj] - si[xi, xj] ** 2)                      * (n * sqj[xi, xj] - sj[xi, xj] ** 2)                  )                  if denum == 0:                      sim[xi, xj] = 0                  else:                      sim[xi, xj] = num / denum                sim[xj, xi] = sim[xi, xj]        return sim      def predict_pair(x_id, y_id, x_rated, S, k, min_k, x_list, y_list, global_mean):      x_known, y_known = False, False      if x_id in x_list:          x_known = True      if y_id in y_list:          y_known = True        if not (x_known and y_known):          # if uuCF:          #     print(f\"Can not predict rating of user {x_id} for item {y_id}.\")          # else:          #     print(f\"Can not predict rating of user {y_id} for item {x_id}.\")          return global_mean        return _predict(x_id, y_id, x_rated[y_id], S, k, min_k)      def _predict(x_id, y_id, x_rated, S, k, k_min):      k_neighbors = np.zeros((k, 2))      k_neighbors[:, 1] = -1  # All similarity degree is default to -1        for x2, rating in x_rated:          if int(x2) == x_id:              continue  # Bo qua item dang xet          sim = S[int(x2), x_id]          argmin = np.argmin(k_neighbors[:, 1])          if sim > k_neighbors[argmin, 1]:              k_neighbors[argmin] = np.array((sim, rating))        # Compute weighted average      sum_sim = sum_ratings = actual_k = 0      for (sim, r) in k_neighbors:          if sim > 0:              sum_sim += sim              sum_ratings += sim * r              actual_k += 1        if actual_k < k_min:          sum_ratings = 0        if sum_sim:          est = sum_ratings / sum_sim            return est      return 0      def cosine(n_x, yr, min_support=1):      \"\"\"Compute the cosine similarity between all pairs of users (or items).      Only **common** users (or items) are taken into account.      \"\"\"      prods = np.zeros((n_x, n_x), np.double)      freq = np.zeros((n_x, n_x), np.int)      sqi = np.zeros((n_x, n_x), np.double)      sqj = np.zeros((n_x, n_x), np.double)        for y_ratings in yr:          prods, freq, sqi, sqj = run_cosine_params(              prods, freq, sqi, sqj, y_ratings)        sim = calculate_cosine_similarity(prods, freq, sqi, sqj, n_x, min_support)        return sim      @njit  def run_cosine_params(prods, freq, sqi, sqj, y_ratings):      for xi, ri in y_ratings:          xi = int(xi)          for xj, rj in y_ratings:              xj = int(xj)              freq[xi, xj] += 1              prods[xi, xj] += ri * rj              sqi[xi, xj] += ri**2              sqj[xi, xj] += rj**2        return prods, freq, sqi, sqj      @njit  def calculate_cosine_similarity(prods, freq, sqi, sqj, n_x, min_sprt):      sim = np.zeros((n_x, n_x), np.double)        for xi in range(n_x):          sim[xi, xi] = 1          for xj in range(xi + 1, n_x):              if freq[xi, xj] < min_sprt:                  sim[xi, xj] = 0              else:                  denum = np.sqrt(sqi[xi, xj] * sqj[xi, xj])                  sim[xi, xj] = prods[xi, xj] / denum                sim[xj, xi] = sim[xi, xj]        return sim      @njit  def calculate_precision_recall(user_ratings, k, threshold):      \"\"\"Calculate the precision and recall at k metric for the user based on his/her obversed rating and his/her predicted rating.        Args:          user_ratings (ndarray): An array contains the predicted rating in the first column and the obversed rating in the second column.          k (int): the k metric.          threshold (float): relevant threshold.        Returns:          (precision, recall): the precision and recall score for the user.      \"\"\"      # Sort user ratings by estimated value      # user_ratings = user_ratings[user_ratings[:, 0].argsort()][::-1]        # Number of relevant items      n_rel = 0      for _, true_r in user_ratings:          if true_r >= threshold:              n_rel += 1        # Number of recommended items in top k      n_rec_k = 0      for est, _ in user_ratings[:k]:          if est >= threshold:              n_rec_k += 1        # Number of relevant and recommended items in top k      n_rel_and_rec_k = 0      for (est, true_r) in user_ratings[:k]:          if true_r >= threshold and est >= threshold:              n_rel_and_rec_k += 1        # Precision@K: Proportion of recommended items that are relevant      # When n_rec_k is 0, Precision is undefined. We here set it to 0.      if n_rec_k != 0:          precision = n_rel_and_rec_k / n_rec_k      else:          precision = 0        # Recall@K: Proportion of relevant items that are recommended      # When n_rel is 0, Recall is undefined. We here set it to 0.      if n_rel != 0:          recall = n_rel_and_rec_k / n_rel      else:          recall = 0        return precision, recall "}
{"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": "# \ub370\uc774\ud130\ub97c \ucc98\ub9ac\ud558\uae30 \uc704\ud55c \ud30c\uc774\uc36c\uc758 \uae30\ubcf8 \ud328\ud0a4\uc9c0  from login.login import *  import pandas as pd    # \ud0c0\uc774\ud53c \ucf54\uc5b4 import  import taipy as tp    # \ub0b4 \ud30c\uc774\uc36c \ucf54\ub4dc\uc758 \ubc31\uc5d4\ub4dc \uac00\uc838\uc624\uae30 | \uc2dc\ub098\ub9ac\uc624\ub97c \uc0dd\uc131\ud558\ub824\uba74 \uc6d0\ubcf8 \ud30c\uc774\ud504\ub77c\uc778_cfg \ubc0f \uc2dc\ub098\ub9ac\uc624_cfg\uac00 \ud544\uc694\ud569\ub2c8\ub2e4.  # fixed_variables_default\ub294 \uace0\uc815 \ubcc0\uc218\uc758 \uae30\ubcf8\uac12\uc73c\ub85c \uc0ac\uc6a9\ub429\ub2c8\ub2e4.  from config.config import fixed_variables_default, scenario_cfg, pipeline_cfg  from taipy.core.config.config import Config      # Taipy \ud504\ub860\ud2b8\uc5d4\ub4dc\uc5d0 \uc720\uc6a9\ud55c \uae30\ub2a5 \uac00\uc838\uc624\uae30  from taipy.gui import Gui, Markdown, notify, Icon    # \ub0b4 \ud30c\uc774\uc36c \ucf54\ub4dc\uc758 \ud504\ub860\ud2b8\uc5d4\ub4dc \uac00\uc838\uc624\uae30 | \ud398\uc774\uc9c0 \uac00\uc838\uc624\uae30: compare_scenario_md \ud398\uc774\uc9c0, \uc2dc\ub098\ub9ac\uc624_\ub9e4\ub2c8\uc800_md \ud398\uc774\uc9c0, \ub370\uc774\ud130\ubca0\uc774\uc2a4_md \ud398\uc774\uc9c0  # *\ub294 \ub54c\ub54c\ub85c \uc774 \ucf54\ub4dc\uc758 \ud568\uc218 \ubc0f/\ub610\ub294 \ubcc0\uc218\uac00 \ud544\uc694\ud558\uae30 \ub54c\ubb38\uc5d0 \uc0ac\uc6a9\ub429\ub2c8\ub2e4.  #   from pages.compare_cycles_md import *  from pages.compare_scenario_md import *  from pages.databases_md import *  from pages.data_visualization_md import *    # \uc784\uc2dc \ud30c\uc77c\uc744 \uc0dd\uc131\ud558\uae30 \uc704\ud574 import  import pathlib      # \uc774 \uacbd\ub85c\ub294 Datasouces \ud398\uc774\uc9c0\uc5d0\uc11c \ud14c\uc774\ube14\uc744 \ub2e4\uc6b4\ub85c\ub4dc\ud560 \uc218 \uc788\ub294 \uc784\uc2dc \ud30c\uc77c\uc744 \ub9cc\ub4dc\ub294 \ub370 \uc0ac\uc6a9\ub429\ub2c8\ub2e4.  #   tempdir = pathlib.Path(\".tmp\")  tempdir.mkdir(exist_ok=True)  PATH_TO_TABLE = str(tempdir / \"table.csv\")    Config.configure_global_app(clean_entities_enabled=True)  tp.clean_all_entities()    cc_create_scenarios_for_cycle()    from pages.scenario_manager_md import *      ###############################################################################  # \ub85c\uadf8\uc778  ###############################################################################      def on_change_user_selector(state):      global user_selector      if state.selected_user == 'Create new user':          state.login = ''          state.dialog_new_account = True      elif state.selected_user in [user[0] for user in user_selector]:          state.login = state.selected_user            if state.selected_user in state.user_in_session:              state.dialog_user = False                reinitialize_state_after_login(state)          else:              state.dialog_login = True        else:          notify(state, \"Warning\", \"Unexpected error\")      def reinitialize_state_after_login(state):      scenarios = [s for s in tp.get_scenarios(      ) if 'user' in s.properties and state.login == s.properties['user']]      state.scenario_counter = len(scenarios)      state.cs_show_comparaison = False      state.password = ''      update_scenario_selector(state, scenarios)        if state.dialog_new_account:          state.selected_scenario = None          notify(state, 'info', 'Creating a new session')          state.dialog_new_account = False      else:          if state.scenario_counter != 0:              state.selected_scenario = state.scenario_selector[0][0]            notify(state, 'info', 'Restoring your session')      def validate_login(state, id, action, payload):      global user_selector, users        # if the button pressed is \"Cancel\"      if payload['args'][0] != 1:          state.dialog_login = False          state.dialog_new_account = False      else:          if state.dialog_new_account:              if state.login in [user[0] for user in user_selector]:                  notify(state, 'error', 'This user already exists')              elif state.login == '':                  notify(state, \"Warning\", \"Please enter a valid login\")              elif state.login != '' and len(state.password) > 0:                  state.dialog_login = False                  state.dialog_new_account = False                  state.dialog_user = False                    users[state.login] = {}                  users[state.login][\"password\"] = encode(state.password)                  users[state.login][\"last_visit\"] = str(dt.datetime.now())                    json.dump(users, open('login/login.json', 'w'))                  reinitialize_state_after_login(state)                    state.user_selector = [                      (state.login,                       Icon(                           'images/user.png',                           state.login))] + state.user_selector                  user_selector = state.user_selector                  state.selected_user = state.login                    state.user_in_session += state.selected_user          elif state.login in [user[0] for user in user_selector]:              if test_password(users, state.login, state.password):                  state.dialog_login = False                  state.dialog_new_account = False                  state.dialog_user = False                  state.user_in_session += state.selected_user                    reinitialize_state_after_login(state)              else:                  notify(state, \"Warning\", \"Wrong password\")            else:              notify(state, \"Warning\", \"Unexpected error\")      ###############################################################################  # main_md  ###############################################################################    # \uba54\uc778 \ub9c8\ud06c\ub2e4\uc6b4 \ud398\uc774\uc9c0\uc785\ub2c8\ub2e4. \uc5ec\uae30\uc5d0 \uba54\uc778 \ud398\uc774\uc9c0\uc5d0 \ud3ec\ud568\ub41c \ub2e4\ub978 \ud398\uc774\uc9c0\uac00 \uc788\uc2b5\ub2c8\ub2e4.  # \uc2dc\ub098\ub9ac\uc624_\ub9e4\ub2c8\uc800_md, \ube44\uad50_\uc2dc\ub098\ub9ac\uc624_md, \ub370\uc774\ud130\ubca0\uc774\uc2a4_md\ub294 \ud398\uc774\uc9c0 \ubcc0\uc218\uc5d0 \ub530\ub77c \ubcf4\uc774\uac8c \ub429\ub2c8\ub2e4.  # \uc774\uac83\uc774 'render' \ub9e4\uac1c\ubcc0\uc218\uc758 \ubaa9\uc801\uc785\ub2c8\ub2e4.  menu_lov = [      (\"Data Visualization\",       Icon(           'images/chart_menu.svg',           'Data Visualization')),      (\"Scenario Manager\",       Icon(           'images/Scenario.svg',           'Scenario Manager')),      (\"Compare Scenarios\",       Icon(           'images/compare.svg',           'Compare Scenarios')),      (\"Compare Cycles\",       Icon(           'images/Cycle.svg',           'Compare Cycles')),      ('Databases',       Icon(           'images/Datanode.svg',           'Databases'))]    main_md = login_md + \"\"\"    <|menu|label=Menu|lov={menu_lov}|on_action=menu_fct|id=menu_id|>    <|part|render={page == 'Data Visualization'}|  \"\"\" + da_data_visualisation_md + \"\"\"  |>    <|part|render={page == 'Scenario Manager'}|  \"\"\" + sm_scenario_manager_md + \"\"\"  |>    <|part|render={page == 'Compare Scenarios'}|  \"\"\" + cs_compare_scenario_md + \"\"\"  |>    <|part|render={page == 'Compare Cycles'}|  \"\"\" + cc_compare_cycles_md + \"\"\"  |>    <|part|render={page == 'Databases'}|  \"\"\" + da_databases_md + \"\"\"  |>    \"\"\"      ###############################################################################  # \uc2dc\ub098\ub9ac\uc624 \uc0dd\uc131/\uc81c\ucd9c/\ucc98\ub9ac\ub97c \uc704\ud55c \uc911\uc694\ud55c \uae30\ub2a5  ###############################################################################    def update_scenario_selector(state, scenarios: list):      \"\"\"      \uc774 \uae30\ub2a5\uc740 \uc2dc\ub098\ub9ac\uc624 \uc120\ud0dd\uae30\ub97c \uc5c5\ub370\uc774\ud2b8\ud569\ub2c8\ub2e4.       \uc0c8 \uc2dc\ub098\ub9ac\uc624\ub97c \ub9cc\ub4e4 \ub54c \uc0ac\uc6a9\ub429\ub2c8\ub2e4.       \uc2dc\ub098\ub9ac\uc624\uac00 \uc0dd\uc131\ub418\uba74 \uc774 \ubaa9\ub85d\uc5d0 (id,name)\uc744 \ucd94\uac00\ud569\ub2c8\ub2e4.        Args:          scenarios (list): a list of tuples (scenario,properties)      \"\"\"        state.scenario_selector = [(s.id, s.name) if not s.is_primary else (          s.id, Icon('images/main.svg', s.name)) for s in scenarios]      state.scenario_counter = len(state.scenario_selector)      state.scenario_selector_two = state.scenario_selector.copy()        sm_tree_dict[state.sm_selected_year][state.sm_selected_month] = state.scenario_selector      def make_primary(state):      tp.set_primary(tp.get(state.selected_scenario))      scenarios = [s for s in tp.get_scenarios(      ) if 'user' in s.properties and state.login == s.properties['user']]      update_scenario_selector(state, scenarios)      state.selected_scenario_is_primary = True      def delete_scenario_fct(state):      if tp.get(state.selected_scenario).is_primary:          notify(              state,              \"warning\",              \"You can't delete the primary scenario of the month\")      else:          tp.delete(state.selected_scenario)          scenarios = [s for s in tp.get_scenarios(          ) if 'user' in s.properties and state.login == s.properties['user']]          update_scenario_selector(state, scenarios)            if state.scenario_counter != 0:              state.selected_scenario = state.scenario_selector[0][0]      def create_new_scenario(state):      \"\"\"      \uc774 \uae30\ub2a5\uc740 cenario_manager_md \ud398\uc774\uc9c0\uc5d0\uc11c '\ub9cc\ub4e4\uae30' \ubc84\ud2bc\uc744 \ub20c\ub800\uc744 \ub54c \uc0ac\uc6a9\ud569\ub2c8\ub2e4.       \uc790\uc138\ud55c \ub0b4\uc6a9\uc740 \uc2dc\ub098\ub9ac\uc624_\ub9e4\ub2c8\uc800_md \ud398\uc774\uc9c0\ub97c \ucc38\uc870\ud558\uc138\uc694.       \ub2e4\ub978 \uc2dc\ub098\ub9ac\uc624\ub97c \uad6c\uc131\ud558\uace0 \uc791\uc131\ud558\uc5ec \uc81c\ucd9c\ud569\ub2c8\ub2e4.        Args:          state (_type_): the state object of Taipy      \"\"\"        # \uc2dc\ub098\ub9ac\uc624 \uce74\uc6b4\ud130 \uc5c5\ub370\uc774\ud2b8      state.scenario_counter += 1        print(\"Creating scenario...\")      name = \"Scenario \" + dt.datetime.now().strftime('%d-%b-%Y') + \" Nb : \" + \\          str(state.scenario_counter)      scenario = tp.create_scenario(scenario_cfg, name=name)      scenario.properties['user'] = state.login        # \ubaa8\ub4e0 \uc2dc\ub098\ub9ac\uc624\uc640 \ud574\ub2f9 \uc18d\uc131\uc744 \uac00\uc838\uc635\ub2c8\ub2e4.      print(\"Getting properties...\")      scenarios = [s for s in tp.get_scenarios(      ) if 'user' in s.properties and state.login == s.properties['user']]        # \uc120\ud0dd\ud55c \uc2dc\ub098\ub9ac\uc624\ub97c \ubcc0\uacbd\ud569\ub2c8\ub2e4. \uc0c8 \uc2dc\ub098\ub9ac\uc624\ub294 \uc120\ud0dd\ud55c \uc2dc\ub098\ub9ac\uc624\uc785\ub2c8\ub2e4.      #       state.selected_scenario = scenario.id        # \uc2dc\ub098\ub9ac\uc624 \uc120\ud0dd\uae30\ub97c \uc5c5\ub370\uc774\ud2b8\ud569\ub2c8\ub2e4.      print(\"Updating scenario selector...\")      update_scenario_selector(state, scenarios)        # \uc774 \uc2dc\ub098\ub9ac\uc624\ub97c \uc81c\ucd9c      print(\"Submitting it...\")      submit_scenario(state)      def catch_error_in_submit(state):      \"\"\"      \uc774 \ud568\uc218\ub294 \uc2dc\ub098\ub9ac\uc624\ub97c \uc81c\ucd9c\ud560 \ub54c \ubc1c\uc0dd\ud560 \uc218 \uc788\ub294 \uc624\ub958\ub97c \uc7a1\ub294 \ub370 \uc0ac\uc6a9\ub429\ub2c8\ub2e4.       \uc624\ub958\uac00 \ud3ec\ucc29\ub418\uba74 \uc54c\ub9bc\uc774 \ud45c\uc2dc\ub418\uace0 \uc624\ub958\ub97c \ubc29\uc9c0\ud558\uae30 \uc704\ud574 \ubcc0\uc218\uac00 \ubcc0\uacbd\ub429\ub2c8\ub2e4.       \uc624\ub958\ub294 \uace0\uc815 \ubcc0\uc218\uac00 \uc798\ubabb \uc124\uc815\ub418\uba74 \uc2e4\ud589 \ubd88\uac00\ub2a5\ud558\uac70\ub098       \ubb34\ud55c\ud55c \ubb38\uc81c\uac00 \ubc1c\uc0dd\ud560 \uc218 \uc788\ub294 Cplex \ubaa8\ub378\uc758 \uc194\ub8e8\uc158\uc5d0\uc11c \ubc1c\uc0dd\ud569\ub2c8\ub2e4.        Args:          state (_type_): the state object of Taipy      \"\"\"        # \ucd08\uae30 \uc0dd\uc0b0\ub7c9\uc774 \ucd5c\ub300 \uc0dd\uc0b0 \ub2a5\ub825\ubcf4\ub2e4 \ub192\uc740 \uacbd\uc6b0      if state.fixed_variables[\"Initial_Production_FPA\"] > state.fixed_variables[\"Max_Capacity_FPA\"]:          state.fixed_variables[\"Initial_Production_FPA\"] = state.fixed_variables[\"Max_Capacity_FPA\"]          notify(              state,              \"warning\",              \"Value of initial production FPA is greater than max production A\")        # \ucd08\uae30 \uc0dd\uc0b0\ub7c9\uc774 \ucd5c\ub300 \uc0dd\uc0b0 \ub2a5\ub825\ubcf4\ub2e4 \ub192\uc740 \uacbd\uc6b0      if state.fixed_variables[\"Initial_Production_FPB\"] > state.fixed_variables[\"Max_Capacity_FPB\"]:          state.fixed_variables[\"Initial_Production_FPB\"] = state.fixed_variables[\"Max_Capacity_FPB\"]          notify(              state,              \"warning\",              \"Value of initial production FPB is greater than max production B\")        # \ucd08\uae30 \uc7ac\uace0\uac00 \ucd5c\ub300 \uc0dd\uc0b0 \ub2a5\ub825\ubcf4\ub2e4 \ub192\uc740 \uacbd\uc6b0      if state.fixed_variables[\"Initial_Stock_RPone\"] > state.fixed_variables[\"Max_Stock_RPone\"]:          state.fixed_variables[\"Initial_Stock_RPone\"] = state.fixed_variables[\"Max_Stock_RPone\"]          notify(              state,              \"warning\",              \"Value of initial stock RP1 is greater than max stock 1\")        # \ucd08\uae30 \uc7ac\uace0\uac00 \ucd5c\ub300 \uc0dd\uc0b0 \ub2a5\ub825\ubcf4\ub2e4 \ub192\uc740 \uacbd\uc6b0      if state.fixed_variables[\"Initial_Stock_RPtwo\"] > state.fixed_variables[\"Max_Stock_RPtwo\"]:          state.fixed_variables[\"Initial_Stock_RPtwo\"] = state.fixed_variables[\"Max_Stock_RPtwo\"]          notify(              state,              \"warning\",              \"Value of initial stock RP2 is greater than max stock 2\")        # \ucd08\uae30 \uc0dd\uc0b0\uc774 \ucd5c\ub300 \uc0dd\uc0b0 \ub2a5\ub825\ubcf4\ub2e4 \ub192\uc740 \uacbd\uc6b0      #       if state.fixed_variables[\"Initial_Production_FPA\"] + \\              state.fixed_variables[\"Initial_Production_FPB\"] > state.fixed_variables[\"Max_Capacity_of_FPA_and_FPB\"]:                            state.fixed_variables[\"Initial_Production_FPA\"] = int(state.fixed_variables[\"Max_Capacity_of_FPA_and_FPB\"] / 2)          state.fixed_variables[\"Initial_Production_FPB\"] = int(state.fixed_variables[\"Max_Capacity_of_FPA_and_FPB\"] / 2)                    notify(              state,              \"warning\",              \"Value of initial productions is greater than the max capacities\")      def submit_scenario(state):      \"\"\"      \uc774 \uae30\ub2a5\uc740 \uc120\ud0dd\ud55c \uc2dc\ub098\ub9ac\uc624\ub97c \uc81c\ucd9c\ud569\ub2c8\ub2e4. '\uc81c\ucd9c' \ubc84\ud2bc\uc744 \ub204\ub974\uac70\ub098       \uc0c8 \uc2dc\ub098\ub9ac\uc624\ub97c \ub9cc\ub4e4 \ub54c \uc0ac\uc6a9\ub429\ub2c8\ub2e4. \uc624\ub958\uac00 \uc788\ub294\uc9c0 \ud655\uc778\ud55c \ub2e4\uc74c \ubb38\uc81c\uc758 \ub9e4\uac1c\ubcc0\uc218\ub97c \ubcc0\uacbd\ud558\uace0       \uc2dc\ub098\ub9ac\uc624\ub97c \uc81c\ucd9c\ud569\ub2c8\ub2e4. \ub9c8\uc9c0\ub9c9\uc73c\ub85c \uc5c5\ub370\uc774\ud2b8\ud558\ub824\ub294 \ubaa8\ub4e0 \ubcc0\uc218\ub97c \uc5c5\ub370\uc774\ud2b8\ud569\ub2c8\ub2e4.        Args:          state (_type_): the state object of Taipy        Returns:          _type_: _description_      \"\"\"        detect_inactive_session(state)        # \uc2dc\ub098\ub9ac\uc624\uc5d0 \uc81c\uacf5\ub420 \ub9e4\uac1c\ubcc0\uc218\uc5d0 \uc624\ub958\uac00 \uc788\ub294\uc9c0 \ud655\uc778\ud569\ub2c8\ub2e4.      #       catch_error_in_submit(state)        # \uc2dc\ub098\ub9ac\uc624 \uac00\uc838\uc624\uae30      scenario = tp.get(state.selected_scenario)        # \uc62c\ubc14\ub978 \ub9e4\uac1c\ubcc0\uc218\ub85c \uc2dc\ub098\ub9ac\uc624 \uc124\uc815      scenario.fixed_variables.write(state.fixed_variables._dict)        # \uc2dc\ub098\ub9ac\uc624 \uc2e4\ud589      tp.submit(scenario)        # \uc5c5\ub370\uc774\ud2b8\ud558\ub824\ub294 \ubaa8\ub4e0 \ubcc0\uc218\ub97c \uc5c5\ub370\uc774\ud2b8\ud569\ub2c8\ub2e4(ch_results, pie_results \ubc0f \uce21\uc815\ud56d\ubaa9)      #       update_variables(state)      def update_variables(state):      \"\"\"\uc774 \ud568\uc218\ub294 submit_scenario \ub610\ub294 selected_scenario\uac00 \ubcc0\uacbd\ub420 \ub54c\ub9cc \uc0ac\uc6a9\ub429\ub2c8\ub2e4. \uc5c5\ub370\uc774\ud2b8\ud558\ub824\ub294 \ubaa8\ub4e0 \uc720\uc6a9\ud55c \ubcc0\uc218\ub97c \uc5c5\ub370\uc774\ud2b8\ud569\ub2c8\ub2e4.        Args:          state (_type_): the state object of Taipy      \"\"\"      # \uc120\ud0dd\ud55c \uc2dc\ub098\ub9ac\uc624 \uac00\uc838\uc624\uae30      scenario = tp.get(state.selected_scenario)        # \uacb0\uacfc \uc77d\uae30      state.ch_results = scenario.pipelines['pipeline'].results.read()      state.pie_results = pd.DataFrame(          {              \"values\": state.ch_results.sum(axis=0),              \"labels\": list(state.ch_results.columns)          })        state.sum_costs = state.ch_results['Total Cost'].sum()        bool_costs_of_stock = [c for c in state.ch_results.columns                             if 'Cost' in c and 'Total' not in c and 'Stock' in c]      state.sum_costs_of_stock = int(state.ch_results[bool_costs_of_stock].sum(axis=1)\\                                                                          .sum(axis=0))        bool_costs_of_BO = [c for c in state.ch_results.columns                          if 'Cost' in c and 'Total' not in c and 'BO' in c]      state.sum_costs_of_BO = int(state.ch_results[bool_costs_of_BO].sum(axis=1)\\                                                                    .sum(axis=0))      def create_chart(ch_results: pd.DataFrame, var: str):      \"\"\"\ub370\uc774\ud130\ubca0\uc774\uc2a4\" \ud398\uc774\uc9c0\uc5d0\uc11c \ubcfc \uc218 \uc788\ub294 \ucc28\ud2b8 \ud14c\uc774\ube14\uc744 \uc0dd\uc131/\uc5c5\ub370\uc774\ud2b8\ud558\ub294 \ud568\uc218\uc785\ub2c8\ub2e4. \uc774      \ud568\uc218\ub294 \"on_change\" \ud568\uc218\uc5d0\uc11c \uc120\ud0dd\ud55c \uadf8\ub798\ud504\uac00 \ubcc0\uacbd\ub420 \ub54c \ucc28\ud2b8\ub97c \ubcc0\uacbd\ud558\ub294 \ub370 \uc0ac\uc6a9\ub429\ub2c8\ub2e4.        Args:          ch_results (pd.DataFrame): the results database that comes from the state          var (str): the string that has to be found in the columns that are going to be used to create the chart table        Returns:          pd.DataFrame: the chart with the proper columns      \"\"\"      if var == 'Cost':          columns = ['index'] + [col for col in ch_results.columns if var in col]      else:          columns = [              'index'] + [col for col in ch_results.columns if var in col and 'Cost' not in col]        chart = ch_results[columns]      return chart      def on_change(state, var_name, var_value):      \"\"\"\uc774 \ud568\uc218\ub294 \uc0c1\ud0dc \ubcc0\uc218\uc758 \ubcc0\uacbd\uc774 \uc644\ub8cc\ub420 \ub54c \ud638\ucd9c\ub429\ub2c8\ub2e4.       \ubcc0\uacbd \uc0ac\ud56d\uc774 \ud655\uc778\ub418\uba74 \ubcc0\uacbd\ub41c \ubcc0\uc218\uc5d0 \ub530\ub77c \uc791\uc5c5\uc744 \uc0dd\uc131\ud560 \uc218 \uc788\uc2b5\ub2c8\ub2e4.        Args:          state (State): the state object of Taipy          var_name (str): the changed variable name          var_value (obj): the changed variable value      \"\"\"      # \ubcc0\uacbd\ub41c \ubcc0\uc218\uac00 \uc120\ud0dd\ud55c \uc2dc\ub098\ub9ac\uc624\uc778 \uacbd\uc6b0      if var_name == \"selected_scenario\" and var_value is not None:          scenario = tp.get(state.selected_scenario)            state.selected_scenario_is_primary = scenario.is_primary            if scenario.results.is_ready_for_reading:              # \uc2dc\ub098\ub9ac\uc624\uac00 \ubcc0\uacbd\ub418\uba74 \uc2ac\ub77c\uc774\ub354\ub97c \uc62c\ubc14\ub978 \uac12\uc73c\ub85c \uc124\uc815\ud569\ub2c8\ub2e4.              #               fixed_temp = tp.get(state.selected_scenario).fixed_variables.read()              state_fixed_variables = state.fixed_variables._dict.copy()              for key in state.fixed_variables.keys():                  state_fixed_variables[key] = fixed_temp[key]              state.fixed_variables = state_fixed_variables              # I update all the other useful variables              update_variables(state)        if var_name == \"dialog_user\" or var_name == \"dialog_login\" or var_name == \"dialog_new_account\" or var_name == \"user_selected\":          with open('login/login.json', \"r\") as f:              state.users = json.load(f)          state.user_selector = [(user,Icon('images/user.png', user))                                  for user in state.users.keys()]                    state.user_selector += [('Create new user', Icon('images/new_account.png', 'Create new user'))]        # \uadf8\ub798\ud504\uac00 \uc120\ud0dd\ub418\uac70\ub098 \uc2dc\ub098\ub9ac\uc624\uac00 \ubcc0\uacbd\ub418\uace0 '\ub370\uc774\ud130\ubca0\uc774\uc2a4' \ud398\uc774\uc9c0\uc5d0 \uc788\ub294 \uacbd\uc6b0      # \ub610\ub294 \ub370\uc774\ud130\ubca0\uc774\uc2a4 \ud398\uc774\uc9c0\ub85c \uc774\ub3d9\ud558\uba74 \ucc28\ud2b8 \ud14c\uc774\ube14\uc744 \uc5c5\ub370\uc774\ud2b8\ud574\uc57c \ud569\ub2c8\ub2e4.      if (var_name == 'sm_graph_selected' or var_name == \"selected_scenario\" and state.page =='Databases')\\          or (var_name == 'page' and var_value == 'Databases'):            str_to_select_chart = None            if state.sm_graph_selected == 'Costs':              str_to_select_chart = 'Cost'              state.cost_data = create_chart(state.ch_results, str_to_select_chart)                        elif state.sm_graph_selected == 'Purchases':              str_to_select_chart = 'Purchase'              state.purchase_data = create_chart(state.ch_results, str_to_select_chart)                        elif state.sm_graph_selected == 'Productions':              str_to_select_chart = 'Production'              state.production_data = create_chart(state.ch_results, str_to_select_chart)                        elif state.sm_graph_selected == 'Stocks':              str_to_select_chart = 'Stock'              state.stock_data = create_chart(state.ch_results, str_to_select_chart)                        elif state.sm_graph_selected == 'Back Order':              str_to_select_chart = 'BO'              state.bo_data = create_chart(state.ch_results, str_to_select_chart)                        elif state.sm_graph_selected == 'Product FPA':              str_to_select_chart = 'FPA'              state.fpa_data = create_chart(state.ch_results, str_to_select_chart)                        elif state.sm_graph_selected == 'Product FPB':              str_to_select_chart = 'FPB'              state.fpb_data = create_chart(state.ch_results, str_to_select_chart)                        elif state.sm_graph_selected == 'Product RP1':              str_to_select_chart = 'RP1'              state.rp1_data = create_chart(state.ch_results, str_to_select_chart)                        elif state.sm_graph_selected == 'Product RP2':              str_to_select_chart = 'RP2'              state.rp2_data = create_chart(state.ch_results, str_to_select_chart)            state.chart = create_chart(state.ch_results, str_to_select_chart)          state.partial_table.update_content(state, da_create_display_table_md(str_to_select_chart.lower() + '_data'))              # '\ub370\uc774\ud130\ubca0\uc774\uc2a4' \ud398\uc774\uc9c0\uc5d0 \uc788\ub294 \uacbd\uc6b0 \uc784\uc2dc csv \ud30c\uc77c\uc744 \ub9cc\ub4e4\uc5b4\uc57c \ud569\ub2c8\ub2e4.          #           if state.page == 'Databases':              state.d_chart_csv_path = PATH_TO_TABLE              state.chart.to_csv(state.d_chart_csv_path, sep=',')      # \ucd08\uae30 \ud398\uc774\uc9c0\ub294 \"\uc2dc\ub098\ub9ac\uc624 \uad00\ub9ac\uc790\" \ud398\uc774\uc9c0\uc785\ub2c8\ub2e4.  page = \"Data Visualization\"      def menu_fct(state, var_name: str, fct, var_value):      \"\"\"Functions that is called when there is a change in the menu control        Args:          state (_type_): the state object of Taipy          var_name (str): the changed variable name          var_value (_type_): the changed variable value      \"\"\"        # \uc62c\ubc14\ub978 \ud398\uc774\uc9c0\ub97c \ub80c\ub354\ub9c1\ud558\uae30 \uc704\ud574 state.page \ubcc0\uc218\uc758 \uac12\uc744 \ubcc0\uacbd\ud558\uc2ed\uc2dc\uc624.      #       try:          state.page = var_value['args'][0]      except BaseException:          print(\"Warning : No args were found\")        # 'Databases' \ud398\uc774\uc9c0\uc5d0\uc11c\ub9cc \uc120\ud0dd\ud560 \uc218 \uc788\ub294 sm_graph_selected\uc758 'All' \uc635\uc158\uc5d0 \ub300\ud55c \ubcf4\uc548      #       if state.page != 'Databases' and state.sm_graph_selected == 'All':          state.sm_graph_selected = 'Costs'      ##########################################################################  # \uc0c1\ud0dc \ubc0f \ucd08\uae30 \uac12 \uc0dd\uc131  ##########################################################################  gui = Gui(page=Markdown(main_md), css_file='main')  partial_table = gui.add_partial(da_display_table_md)    # \ud14c\uc774\ube14\uc758 \ub108\ube44\uc640 \ub192\uc774 \uac12  width_table = \"100%\"  height_table = \"100%\"    # \ucc28\ud2b8\uc758 \ub108\ube44\uc640 \ub192\uc774 \uac12  width_chart = \"100%\"  height_chart = \"60vh\"      def initialize_variables():      # \ucc28\ud2b8\uc758 \ucd08\uae30\uac12      global scenario, pie_results, sum_costs, sum_costs_of_stock, sum_costs_of_BO, scenario_counter,\\          cost_data, stock_data, purchase_data, production_data, fpa_data, fpb_data, bo_data, rp1_data, rp2_data, chart, ch_results,\\          chart, scenario_selector, selected_scenario, selected_scenario_is_primary, scenario_selector_two, selected_scenario_two,\\          fixed_variables        fixed_variables = fixed_variables_default        scenario = None      pie_results = pd.DataFrame(          {              \"values\": [1] * len(list(ch_results.columns)),              \"labels\": list(ch_results.columns)          }, index=list(ch_results.columns)          )            sum_costs = 0      sum_costs_of_stock = 0      sum_costs_of_BO = 0      sum_costs_of_BO = 0      scenario_counter = 0        cost_data = create_chart(ch_results, 'Cost')      purchase_data = create_chart(ch_results, 'Purchase')      production_data = create_chart(ch_results, 'Production')      stock_data = create_chart(ch_results, 'Stock')      bo_data = create_chart(ch_results, 'BO')      fpa_data = create_chart(ch_results, 'FPA')      fpb_data = create_chart(ch_results, 'FPB')      rp1_data = create_chart(ch_results, 'RP1')      rp2_data = create_chart(ch_results, 'RP2')        chart = ch_results[['index',                          'Purchase RP1 Cost',                          'Stock RP1 Cost',                          'Stock RP2 Cost',                          'Purchase RP2 Cost',                          'Stock FPA Cost',                          'Stock FPB Cost',                          'BO FPA Cost',                          'BO FPB Cost',                          'Total Cost']]          # \ud398\uc774\uc9c0\uc5d0 \ud45c\uc2dc\ub420 \uc120\ud0dd\uae30      scenario_selector = []      selected_scenario = None        selected_scenario_is_primary = False        scenario_selector_two = scenario_selector.copy()      selected_scenario_two = None      initialize_variables()    pd.read_csv('data/time_series_demand copy.csv').to_csv('data/time_series_demand.csv')    if __name__ == \"__main__\":      gui.run(title=\"Production planning\",      \t\thost='0.0.0.0',      \t\tport=os.environ.get('PORT', '5050'),      \t\tdark_mode=False,              use_reloader=False)  else:      app = gui.run(title=\"Production planning\",                    dark_mode=False,                    run_server=False) "}
{"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 pandas as pd  import numpy as np  from pulp import *      # \uc774 \ucf54\ub4dc\ub294 \uc774\ub7ec\ud55c \uae30\ub2a5\uc774 \ud544\uc694\ud55c \uc791\uc5c5\uc744 \uc0dd\uc131\ud558\ub294 config.py\uc5d0\uc11c \uc0ac\uc6a9\ub429\ub2c8\ub2e4.  # \uc774 \ud568\uc218\ub294 \uc804\ud615\uc801\uc778 \ud30c\uc774\uc36c \ud568\uc218\uc785\ub2c8\ub2e4(Taipy\ub294 \uc5c6\uc2b5\ub2c8\ub2e4)    ###############################################################################  # \uae30\ub2a5  ###############################################################################      def create_model(demand: pd.DataFrame, fixed_variables: dict):      \"\"\"\uc774 \ud568\uc218\ub294 \ubaa8\ub378\uc744 \uc0dd\uc131\ud569\ub2c8\ub2e4. \ubb38\uc81c\uc758 \ubaa8\ub4e0 \ubcc0\uc218\uc640 \uc81c\uc57d\uc744 \uc0dd\uc131\ud569\ub2c8\ub2e4.      \ub610\ud55c \ubaa9\uc801 \ud568\uc218\ub97c \uc0dd\uc131\ud569\ub2c8\ub2e4.        Args:          demand (pd.DataFrame): \uc218\uc694 \ub370\uc774\ud130 \ud504\ub808\uc784          fixed_variables (dict): \uace0\uc815\ub41c \ubcc0\uc218 \uc0ac\uc804        Returns:          dict: (\uc0dd\uc131\ub41c \ubaa8\ub378\uc774 \uc788\ub294) \ubaa8\ub378 \uc815\ubcf4      \"\"\"      print(\"\ubaa8\ub378 \uc0dd\uc131 \uc911...\")        monthly_demand_FPA = demand[\"Demand_A\"]      monthly_demand_FPB = demand[\"Demand_B\"]        nb_periods = len(monthly_demand_FPA)        # \ubaa8\ub378 \uc0dd\uc131      prob = LpProblem(\"Production_Planning\", LpMinimize)            # \ubcc0\uc218 \uc0dd\uc131      # \uc81c\ud488 A\uc758 \uacbd\uc6b0      monthly_production_FPA = [          LpVariable(f\"Monthly_Production_FPA_{m}\", 0) for m in range(nb_periods)      ]      monthly_stock_FPA = [          LpVariable(f\"Monthly_Stock_FPA_{m}\", 0) for m in range(nb_periods)      ]        monthly_back_order_FPA = [          LpVariable(f\"Monthly_Back_Order_FPA_{m}\", 0) for m in range(nb_periods)      ]        # \uc81c\ud488 B\uc758 \uacbd\uc6b0      monthly_production_FPB = [          LpVariable(f\"Monthly_Production_FPB_{m}\", 0) for m in range(nb_periods)      ]      monthly_stock_FPB = [          LpVariable(f\"Monthly_Stock_FPB_{m}\", 0) for m in range(nb_periods)      ]      monthly_back_order_FPB = [          LpVariable(f\"Monthly_Back_Order_FPB_{m}\", 0) for m in range(nb_periods)      ]        # \uc81c\ud488 1\uc758 \uacbd\uc6b0      monthly_purchase_RPone = [          LpVariable(f\"Monthly_Purchase_RPone_{m}\", 0) for m in range(nb_periods)      ]      monthly_stock_RPone = [          LpVariable(f\"Monthly_Stock_RPone_{m}\", 0) for m in range(nb_periods)      ]      monthly_stock_not_used_RPone = [          LpVariable(f\"Monthly_Stock_not_used_RPone{m}\", 0) for m in range(nb_periods)      ]      monthly_stock_RPone_for_FPA = [          LpVariable(f\"Monthly_Stock_RPone_for_FPA{m}\", 0) for m in range(nb_periods)      ]      monthly_stock_RPone_for_FPB = [          LpVariable(f\"Monthly_Stock_RPone_for_FPB{m}\", 0) for m in range(nb_periods)      ]        # \uc81c\ud488 2\uc758 \uacbd\uc6b0       monthly_purchase_RPtwo = [          LpVariable(f\"Monthly_Purchase_RPtwo{m}\", 0) for m in range(nb_periods)      ]      monthly_stock_RPtwo = [          LpVariable(f\"Monthly_Stock_RP{m}two\", 0) for m in range(nb_periods)      ]      monthly_stock_not_used_RPtwo = [          LpVariable(f\"Monthly_Stock_not_used_RPtwo{m}\", 0) for m in range(nb_periods)      ]      monthly_stock_RPtwo_for_FPA = [          LpVariable(f\"Monthly_Stock_RPtwo_for_FPA{m}\", 0) for m in range(nb_periods)      ]      monthly_stock_RPtwo_for_FPB = [          LpVariable(f\"Monthly_Stock_RPtwo_for_FPB{m}\", 0) for m in range(nb_periods)      ]        # \uc81c\uc57d \uc870\uac74 \uc0dd\uc131        # \uc81c\ud488 A\uc5d0 \ub300\ud55c Kirchoff\uc758 \ubc95\uce59      for m in range(1, nb_periods):          prob += (              monthly_production_FPA[m]              - monthly_back_order_FPA[m - 1]              + monthly_stock_FPA[m - 1]              == monthly_demand_FPA[m] + monthly_stock_FPA[m] - monthly_back_order_FPA[m]          )      # \uc81c\ud488 B\uc5d0 \ub300\ud55c Kirchoff\uc758 \ubc95\uce59      for m in range(1, nb_periods):          prob += (              monthly_production_FPB[m]              - monthly_back_order_FPB[m - 1]              + monthly_stock_FPB[m - 1]              == monthly_demand_FPB[m] + monthly_stock_FPB[m] - monthly_back_order_FPB[m]          )        # \uc81c\ud488 1\uc5d0 \ub300\ud55c Kirchoff\uc758 \ubc95\uce59      for m in range(1, nb_periods):          prob += (              monthly_purchase_RPone[m - 1] + monthly_stock_not_used_RPone[m - 1]              == monthly_stock_RPone[m]          )      # \uc5c6\uc74c \ubb38\uc81c\uc5d0 \ub300\ud55c MS \uc218\uc815      prob += monthly_purchase_RPone[nb_periods - 1] == 0        for m in range(1, nb_periods):          prob += (              monthly_purchase_RPtwo[m - 1] + monthly_stock_not_used_RPtwo[m - 1]              == monthly_stock_RPtwo[m]          )      # \uc5c6\uc74c \ubb38\uc81c\uc5d0 \ub300\ud55c MS \uc218\uc815      prob += monthly_purchase_RPtwo[nb_periods - 1] == 0        for m in range(nb_periods):          prob += monthly_production_FPA[m] <= fixed_variables[\"Max_Capacity_FPA\"]        prob += monthly_production_FPA[0] == fixed_variables[\"Initial_Production_FPA\"]        prob += monthly_back_order_FPA[0] == fixed_variables[\"Initial_Back_Order_FPA\"]        prob += monthly_stock_FPA[0] == fixed_variables[\"Initial_Stock_FPA\"]        # \uc81c\ud488 A\uc5d0 \ub300\ud55c BOM\uc5d0 \ub300\ud55c \uc81c\uc57d        for m in range(1, nb_periods):          prob += (              monthly_production_FPA[m]              == fixed_variables[\"number_RPone_to_produce_FPA\"]              * monthly_stock_RPone_for_FPA[m - 1]              + fixed_variables[\"number_RPtwo_to_produce_FPA\"]              * monthly_stock_RPtwo_for_FPA[m - 1]          )        for m in range(nb_periods):          prob += (              fixed_variables[\"number_RPone_to_produce_FPA\"]              * monthly_stock_RPone_for_FPA[m]              == fixed_variables[\"number_RPtwo_to_produce_FPA\"]              * monthly_stock_RPtwo_for_FPA[m]          )        # \ubcc0\uc218\uc5d0 \ub300\ud55c \uc81c\uc57d\uc870\uac74: \uc81c\ud488 A\uc758 \ucd5c\ub300\uac12\uacfc \ucd08\uae30\uac12      for m in range(nb_periods):          prob += monthly_production_FPB[m] <= fixed_variables[\"Max_Capacity_FPB\"]      prob += monthly_production_FPB[0] == fixed_variables[\"Initial_Production_FPB\"]        prob += monthly_back_order_FPB[0] == fixed_variables[\"Initial_Back_Order_FPB\"]      prob += monthly_stock_FPB[0] == fixed_variables[\"Initial_Stock_FPB\"]        # \uc81c\ud488 B\uc5d0 \ub300\ud55c BOM\uc5d0 \ub300\ud55c \uc81c\uc57d        for m in range(1, nb_periods):          prob += (              monthly_production_FPB[m]              == fixed_variables[\"number_RPone_to_produce_FPB\"]              * monthly_stock_RPone_for_FPB[m - 1]              + fixed_variables[\"number_RPtwo_to_produce_FPB\"]              * monthly_stock_RPtwo_for_FPB[m - 1]          )        for m in range(nb_periods):          prob += (              fixed_variables[\"number_RPone_to_produce_FPB\"]              * monthly_stock_RPone_for_FPB[m]              == fixed_variables[\"number_RPtwo_to_produce_FPB\"]              * monthly_stock_RPtwo_for_FPB[m]          )        for m in range(nb_periods):          prob += monthly_stock_RPone[m] <= fixed_variables[\"Max_Stock_RPone\"]        prob += monthly_stock_RPone[0] == fixed_variables[\"Initial_Stock_RPone\"]        prob += monthly_purchase_RPone[0] == fixed_variables[\"Initial_Purchase_RPone\"]        for m in range(nb_periods):          prob += monthly_stock_RPone[m] == (              monthly_stock_not_used_RPone[m]              + monthly_stock_RPone_for_FPA[m]              + monthly_stock_RPone_for_FPB[m]          )      # \ubcc0\uc218\uc5d0 \ub300\ud55c \uc81c\uc57d \uc870\uac74: \uc81c\ud488 1\uc758 \ucd5c\ub300\uac12 \ubc0f \ucd08\uae30\uac12        for m in range(nb_periods):          prob += monthly_stock_RPtwo[m] <= fixed_variables[\"Max_Stock_RPtwo\"]        prob += monthly_stock_RPtwo[0] == fixed_variables[\"Initial_Stock_RPtwo\"]        prob += monthly_purchase_RPtwo[0] == fixed_variables[\"Initial_Purchase_RPtwo\"]      # \uc81c\ud488 1\uc758 \uc7ac\uace0\ub97c \uc815\uc758\ud558\ub294 \uc81c\uc57d \uc870\uac74            for m in range(nb_periods):          prob += monthly_stock_RPtwo[m] == (              monthly_stock_not_used_RPtwo[m]              + monthly_stock_RPtwo_for_FPA[m]              + monthly_stock_RPtwo_for_FPB[m]          )      # \ubcc0\uc218\uc5d0 \ub300\ud55c \uc81c\uc57d \uc870\uac74: \uc81c\ud488 A \ubc0f B\uc758 \ucd5c\ub300 \uac12(\ub204\uc801)        for m in range(nb_periods):          prob += (              monthly_production_FPA[m] + monthly_demand_FPB[m]              <= fixed_variables[\"Max_Capacity_of_FPA_and_FPB\"]          )        # \ubaa9\uc801 \ud568\uc218 \uc124\uc815      prob += lpSum(          fixed_variables[\"Weight_of_Back_Order\"]          / 100          * (              fixed_variables[\"cost_FPA_Back_Order\"] * monthly_back_order_FPA[m]              + fixed_variables[\"cost_FPB_Back_Order\"] * monthly_back_order_FPB[m]          )          + fixed_variables[\"Weight_of_Stock\"]          / 100          * (              fixed_variables[\"cost_FPA_Stock\"] * monthly_stock_FPA[m]              + fixed_variables[\"cost_FPB_Stock\"] * monthly_stock_FPB[m]              + fixed_variables[\"cost_RPone_Stock\"] * monthly_stock_RPone[m]              + fixed_variables[\"cost_RPtwo_Stock\"] * monthly_stock_RPtwo[m]          )          for m in range(nb_periods)      )        # \ud544\uc694\ud55c \ubaa8\ub4e0 \uc815\ubcf4\ub97c \uc0ac\uc804\uc5d0 \ub2f4\uae30      model_info = {          \"model_created\": prob,          \"model_solved\": None,          \"Monthly_Production_FPA\": monthly_production_FPA,          \"Monthly_Stock_FPA\": monthly_stock_FPA,          \"Monthly_Back_Order_FPA\": monthly_back_order_FPA,          \"Monthly_Production_FPB\": monthly_production_FPB,          \"Monthly_Stock_FPB\": monthly_stock_FPB,          \"Monthly_Back_Order_FPB\": monthly_back_order_FPB,          \"Monthly_Stock_RPone\": monthly_stock_RPone,          \"Monthly_Stock_RPtwo\": monthly_stock_RPtwo,          \"Monthly_Purchase_RPone\": monthly_purchase_RPone,          \"Monthly_Purchase_RPtwo\": monthly_purchase_RPtwo,      }        print(\"Model created\")      return model_info      def solve_model(model_info: dict):      \"\"\"\uc774 \ud568\uc218\ub294 \ubaa8\ub378\uc744 \ud480\uace0 \uc0ac\uc804\uc5d0 \uc788\ub294 \ubaa8\ub4e0 \uc194\ub8e8\uc158\uc744 \ubc18\ud658\ud569\ub2c8\ub2e4.        Args:          model_info (dict): create_model \ud568\uc218\uc5d0 \uc758\ud574 \uc804\ub2ec\ub41c model_info        Returns:          dict: \ud574\uacb0\ub41c \ubaa8\ub378 \ubc0f \uc194\ub8e8\uc158      \"\"\"      print(\"\ubaa8\ub378 \ud480\uae30...\")      prob = model_info[\"model_created\"]        nb_periods = len(model_info[\"Monthly_Production_FPA\"])        # \ubaa8\ub378 \ud480\uae30      m_solved = prob.solve()        # \uc62c\ubc14\ub978 \ubcc0\uc218\uc5d0\uc11c \uc194\ub8e8\uc158 \uc5bb\uae30      # \uc81c\ud488 A\uc758 \uacbd\uc6b0      prod_sol_FPA = [          value(model_info[\"Monthly_Production_FPA\"][p]) for p in range(nb_periods)      ]      stock_sol_FPA = [          value(model_info[\"Monthly_Stock_FPA\"][p]) for p in range(nb_periods)      ]      bos_sol_FPA = [          value(model_info[\"Monthly_Back_Order_FPA\"][p]) for p in range(nb_periods)      ]        # \uc81c\ud488 B\uc758 \uacbd\uc6b0      prod_sol_FPB = [          value(model_info[\"Monthly_Production_FPB\"][p]) for p in range(nb_periods)      ]      stock_sol_FPB = [          value(model_info[\"Monthly_Stock_FPB\"][p]) for p in range(nb_periods)      ]      bos_sol_FPB = [          value(model_info[\"Monthly_Back_Order_FPB\"][p]) for p in range(nb_periods)      ]        # \uc81c\ud488 1\uc758 \uacbd\uc6b0      stock_RPone_sol = [          value(model_info[\"Monthly_Stock_RPone\"][p]) for p in range(nb_periods)      ]      stock_RPtwo_sol = [          value(model_info[\"Monthly_Stock_RPtwo\"][p]) for p in range(nb_periods)      ]        # \uc81c\ud488 2\uc758 \uacbd\uc6b0      purchase_RPone_sol = [          value(model_info[\"Monthly_Purchase_RPone\"][p]) for p in range(nb_periods)      ]      purchase_RPtwo_sol = [          value(model_info[\"Monthly_Purchase_RPtwo\"][p]) for p in range(nb_periods)      ]        # \uc0ac\uc804\uc5d0 \ub123\uae30      model_info = {          \"model_created\": prob,          \"model_solved\": m_solved,          \"Monthly_Production_FPA\": prod_sol_FPA,          \"Monthly_Stock_FPA\": stock_sol_FPA,          \"Monthly_Back_Order_FPA\": bos_sol_FPA,          \"Monthly_Production_FPB\": prod_sol_FPB,          \"Monthly_Stock_FPB\": stock_sol_FPB,          \"Monthly_Back_Order_FPB\": bos_sol_FPB,          \"Monthly_Stock_RPone\": stock_RPone_sol,          \"Monthly_Purchase_RPone\": purchase_RPone_sol,          \"Monthly_Stock_RPtwo\": stock_RPtwo_sol,          \"Monthly_Purchase_RPtwo\": purchase_RPtwo_sol,      }      print(\"Model solved\")      return model_info      def create_results(model_info: dict, fixed_variables: dict, demand: pd.DataFrame):      \"\"\"\uc774 \ud568\uc218\ub294 \ubaa8\ub378\uc758 \uacb0\uacfc\ub97c \uc0dd\uc131\ud569\ub2c8\ub2e4. \uacb0\uacfc \ub370\uc774\ud130 \ud504\ub808\uc784\uc740 \ubaa8\ub4e0 \uc720\uc6a9\ud55c \uc815\ubcf4\uc758 \uc5f0\uacb0\uc785\ub2c8\ub2e4.        Args:          model_info (dict): solve_model \ud568\uc218\uc5d0 \uc758\ud574 \uc0dd\uc131\ub41c \uc0ac\uc804          fixed_variables (dict): \ubb38\uc81c\uc758 \uace0\uc815 \ubcc0\uc218          demand (pd.DataFrame): A\uc640 B\uc5d0 \ub300\ud55c \uc218\uc694        Returns:          pd.DataFrame: \uc194\ub8e8\uc158\uc5d0 \ub300\ud55c \ubaa8\ub4e0 \uc720\uc6a9\ud55c \uc815\ubcf4\ub97c \uc218\uc9d1\ud558\ub294 \ub370\uc774\ud130 \ud504\ub808\uc784      \"\"\"      print(\"\uacb0\uacfc \uc0dd\uc131 \uc911...\")        # A\uc640 B\uc5d0 \ub300\ud55c \uc218\uc694 \uc5bb\uae30      demand_series_FPA = demand[\"Demand_A\"]      demand_series_FPB = demand[\"Demand_B\"]        nb_periods = len(demand_series_FPA)        # \ub2e4\ub978 \ube44\uc6a9\uc744 \uacc4\uc0b0      cost_FPBO_FPA = fixed_variables[\"cost_FPA_Back_Order\"] * np.array(          model_info[\"Monthly_Back_Order_FPA\"]      )      cost_stock_FPA = fixed_variables[\"cost_FPA_Stock\"] * np.array(          model_info[\"Monthly_Stock_FPA\"]      )      cost_FPBO_FPB = fixed_variables[\"cost_FPB_Back_Order\"] * np.array(          model_info[\"Monthly_Back_Order_FPB\"]      )      cost_stock_FPB = fixed_variables[\"cost_FPB_Stock\"] * np.array(          model_info[\"Monthly_Stock_FPB\"]      )      cost_stock_RPone = fixed_variables[\"cost_RPone_Stock\"] * np.array(          model_info[\"Monthly_Stock_RPone\"]      )      cost_stock_RPtwo = fixed_variables[\"cost_RPtwo_Stock\"] * np.array(          model_info[\"Monthly_Stock_RPtwo\"]      )      cost_product_RPone = fixed_variables[\"cost_RPone_Purchase\"] * np.array(          model_info[\"Monthly_Purchase_RPone\"]      )      cost_product_RPtwo = fixed_variables[\"cost_RPtwo_Purchase\"] * np.array(          model_info[\"Monthly_Purchase_RPtwo\"]      )        # \ucd1d \ube44\uc6a9(\ube44\uc6a9\uc758 \ud569\uacc4)      total_cost = (          cost_FPBO_FPA          + cost_stock_FPA          + cost_FPBO_FPB          + cost_stock_FPB          + cost_stock_RPone          + cost_product_RPone          + cost_product_RPtwo          + cost_stock_RPtwo      )        # \ub370\uc774\ud130 \ud504\ub808\uc784\uc744 \uc0dd\uc131\ud558\ub294 \ub370 \uc0ac\uc6a9\ud560 \uc0ac\uc804 \uc0dd\uc131      dict_for_dataframe = {          \"Monthly Production FPA\": model_info[\"Monthly_Production_FPA\"],          \"Monthly Stock FPA\": model_info[\"Monthly_Stock_FPA\"],          \"Monthly BO FPA\": model_info[\"Monthly_Back_Order_FPA\"],          \"Max Capacity FPA\": [fixed_variables[\"Max_Capacity_FPA\"]] * nb_periods,          \"Monthly Production FPB\": model_info[\"Monthly_Production_FPB\"],          \"Monthly Stock FPB\": model_info[\"Monthly_Stock_FPB\"],          \"Monthly BO FPB\": model_info[\"Monthly_Back_Order_FPB\"],          \"Max Capacity FPB\": [fixed_variables[\"Max_Capacity_FPB\"]] * nb_periods,          \"Monthly Stock RP1\": model_info[\"Monthly_Stock_RPone\"],          \"Monthly Stock RP2\": model_info[\"Monthly_Stock_RPtwo\"],          \"Monthly Purchase RP1\": model_info[\"Monthly_Purchase_RPone\"],          \"Monthly Purchase RP2\": model_info[\"Monthly_Purchase_RPtwo\"],          \"Demand FPA\": demand_series_FPA,          \"Demand FPB\": demand_series_FPB,          \"Stock FPA Cost\": cost_stock_FPA,          \"Stock FPB Cost\": cost_stock_FPB,          \"Stock RP1 Cost\": cost_stock_RPone,          \"Stock RP2 Cost\": cost_stock_RPtwo,          \"Purchase RP1 Cost\": cost_product_RPone,          \"Purchase RP2 Cost\": cost_product_RPtwo,          \"BO FPA Cost\": cost_FPBO_FPA,          \"BO FPB Cost\": cost_FPBO_FPB,          \"Total Cost\": total_cost,          \"index\": range(nb_periods),      }        results = pd.DataFrame(dict_for_dataframe).round()      print(\"Results created\")        # \ubaa8\ub378\uc774 \uc0dd\uc131\ub418\ub294 \ubc29\uc2dd \ub54c\ubb38\uc5d0 \ub9c8\uc9c0\ub9c9 \ub450 \uad00\ucc30\uc744 \uc9c0\uc6c1\ub2c8\ub2e4.       # \uac12\uc5d0\ub294 \uc758\ubbf8\uac00 \uc5c6\uc2b5\ub2c8\ub2e4.      return results[:-2] "}
{"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 pages.annex_scenario_manager.chart_md import ch_chart_md, ch_choice_chart, ch_show_pie, ch_layout_dict, ch_results  from pages.annex_scenario_manager.parameters_md import pa_parameters_md, pa_param_selector, pa_param_selected, pa_choice_product_param, pa_product_param    from taipy.gui.gui_actions import notify  from taipy.gui import Icon  import taipy as tp    import datetime as dt        def remove_scenario_from_tree(scenario, sm_tree_dict: dict):      \"\"\"\uc774 \ud568\uc218\ub294 \ud2b8\ub9ac\uc5d0\uc11c \uc2dc\ub098\ub9ac\uc624\ub97c \ucc3e\uc544 \uc81c\uac70\ud569\ub2c8\ub2e4.        Args:          scenario (Scenario): the scenario to be deleted from the tree          sm_tree_dict (dict): the tree dict from which the scenario has to be deleted from        Returns:          tree: the tree without the scenario      \"\"\"      # \uc2dc\ub098\ub9ac\uc624\uac00 \ud3ec\ud568\ub418\uc9c0 \uc54a\uc740 \uacbd\uc6b0 \uc0ad\uc81c\ub418\ub294 \uc8fc\uae30 \ud0a4\uc785\ub2c8\ub2e4.      #       cycle_keys_to_pop = []        # We explore our 2-level tree      for cycle, scenarios_ in sm_tree_dict.items():          for scenario_id, scenario_name in scenarios_:              if scenario_id == scenario.id:                  # \uac19\uc740 id\ub97c \uac00\uc9c4 \uc2dc\ub098\ub9ac\uc624\ub97c \ud2b8\ub9ac\uc5d0\uc11c \uc81c\uac70                  sm_tree_dict[cycle].remove((scenario_id, scenario_name))                    # \ube44\uc5b4 \uc788\ub294 \uacbd\uc6b0 \uc0ad\uc81c\ud560 \uc8fc\uae30\uc5d0 \uc8fc\uae30\ub97c \ucd94\uac00\ud569\ub2c8\ub2e4.                  if len(sm_tree_dict[cycle]) == 0:                      cycle_keys_to_pop += [cycle]                  print(\"------------- Scenario found and deleted -------------\")                  break        # \ube48 \uc8fc\uae30 \uc81c\uac70      for cycle in cycle_keys_to_pop:          sm_tree_dict.pop(cycle)      return sm_tree_dict    sm_tree_dict = {}    def create_sm_tree_dict(scenarios, sm_tree_dict: dict = None):      \"\"\"\uc774 \uae30\ub2a5\uc740 \uc2dc\ub098\ub9ac\uc624 \ubaa9\ub85d\uc5d0\uc11c \ud2b8\ub9ac \uc0ac\uc804\uc744 \uc0dd\uc131\ud569\ub2c8\ub2e4. \ud2b8\ub9ac \uc218\uc900\uc740 \ub2e4\uc74c\uacfc \uac19\uc2b5\ub2c8\ub2e4.      \uc5f0\ub3c4/\uc6d4/\uc2dc\ub098\ub9ac\uc624            Args:          scenarios (list): \uc2dc\ub098\ub9ac\uc624 \ubaa9\ub85d          sm_tree_dict (dict, optional): \ubaa8\ub4e0 \uc2dc\ub098\ub9ac\uc624\ub97c \uc218\uc9d1\ud558\ub294 \ud2b8\ub9ac. \uae30\ubcf8\uac12\uc740 \uc5c6\uc74c\uc785\ub2c8\ub2e4.        Returns:          tree: t\uc2dc\ub098\ub9ac\uc624\ub97c \ubd84\ub958\ud558\uae30 \uc704\ud574 \uc0dd\uc131\ub41c \ud2b8\ub9ac      \"\"\"      print(\"\ud2b8\ub9ac \ub515\uc154\ub108\ub9ac \uc0dd\uc131 \uc911...\")      if sm_tree_dict is None:          # \uc544\uc9c1 \ucd08\uae30\ud654\ub418\uc9c0 \uc54a\uc740 \uacbd\uc6b0 \ud2b8\ub9ac \ub515\uc154\ub108\ub9ac\ub97c \ucd08\uae30\ud654\ud569\ub2c8\ub2e4.          sm_tree_dict = {}        # \ubaa9\ub85d\uc5d0 \uc788\ub294 \ubaa8\ub4e0 \uc2dc\ub098\ub9ac\uc624 \ucd94\uac00      for scenario in scenarios:          # \uc8fc\uae30\uc758 \uc774\ub984\uc744 \ub9cc\ub4ed\ub2c8\ub2e4.          date = scenario.creation_date          year = f\"{date.strftime('%Y')}\"          period = f\"{date.strftime('%b')}\"            # \uc544\uc9c1 \ucd94\uac00\ub418\uc9c0 \uc54a\uc740 \uacbd\uc6b0 \uc8fc\uae30\ub97c \ucd94\uac00\ud569\ub2c8\ub2e4.          if year not in sm_tree_dict:              sm_tree_dict[year] = {}          if period not in sm_tree_dict[year]:              sm_tree_dict[year][period] = []            # \uc2dc\ub098\ub9ac\uc624 ID\uc640 \uc2dc\ub098\ub9ac\uc624 \uc774\ub984\uc73c\ub85c \uc0c8 \ud56d\ubaa9 \ucd94\uac00          scenario_name = (              Icon(                  'images/main.svg',                  scenario.name) if scenario.is_primary else scenario.name)          sm_tree_dict[year][period] += [(scenario.id, scenario_name)]        return sm_tree_dict        def create_time_selectors():      \"\"\"\uc774 \uae30\ub2a5\uc740 GUI\uc5d0 \ud45c\uc2dc\ub420 \uc2dc\uac04 \uc120\ud0dd\uae30\ub97c \uc0dd\uc131\ud558\uace0 \ubaa8\ub4e0 \uc2dc\ub098\ub9ac\uc624\ub97c \uc218\uc9d1\ud558\ub294 \ud2b8\ub9ac \ub515\uc154\ub108\ub9ac\ub3c4 \uc0dd\uc131\ud569\ub2c8\ub2e4.              Returns:          dict: \ubaa8\ub4e0 \uc2dc\ub098\ub9ac\uc624\ub97c \uc218\uc9d1\ud558\ub294 \ud2b8\ub9ac \ub515\uc154\ub108\ub9ac          list: \uc5f0\ub3c4 \ubaa9\ub85d          list: \uc6d4 \ubaa9\ub85d      \"\"\"      all_scenarios = tp.get_scenarios()      all_scenarios_ordered = sorted(          all_scenarios,          key=lambda x: x.creation_date.timestamp())        sm_tree_dict = create_sm_tree_dict(all_scenarios_ordered)        if sm_current_year not in list(sm_tree_dict.keys()):          sm_tree_dict[sm_current_year] = {}      if sm_current_month not in sm_tree_dict[sm_current_year]:          sm_tree_dict[sm_current_year][sm_current_month] = []        sm_year_selector = list(sm_tree_dict.keys())      sm_month_selector = list(sm_tree_dict[sm_selected_year].keys())        return sm_tree_dict, sm_year_selector, sm_month_selector      def change_sm_month_selector(state):      \"\"\"\uc774 \ud568\uc218\ub294 \uc0ac\uc6a9\uc790\uac00 \uc5f0\ub3c4 \uc120\ud0dd\uae30\ub97c \ubcc0\uacbd\ud560 \ub54c \ud638\ucd9c\ub429\ub2c8\ub2e4.       \uc6d4 \uc120\ud0dd\uae30\uc5d0 \ub300\ud574 GUI\uc5d0 \ud45c\uc2dc\ub41c \uc120\ud0dd\uae30\ub97c \uc5c5\ub370\uc774\ud2b8\ud558\uace0 \uc2dc\ub098\ub9ac\uc624 \uc120\ud0dd\uae30\uc5d0 \ub300\ud574 \ub3d9\uc77c\ud55c \uae30\ub2a5\uc744 \ud638\ucd9c\ud569\ub2c8\ub2e4.              Args:          state (State): \ubaa8\ub4e0 GUI \ubcc0\uc218      \"\"\"      state.sm_month_selector = list(          state.sm_tree_dict[state.sm_selected_year].keys())        if state.sm_selected_month not in state.sm_month_selector:          state.sm_selected_month = state.sm_month_selector[0]        change_scenario_selector(state)      def change_scenario_selector(state):      \"\"\"\uc774 \ud568\uc218\ub294 \uc0ac\uc6a9\uc790\uac00 \uc6d4 \uc120\ud0dd\uc790\ub97c \ubcc0\uacbd\ud560 \ub54c \ud638\ucd9c\ub429\ub2c8\ub2e4. \uc2dc\ub098\ub9ac\uc624 \uc120\ud0dd\uae30\uc5d0 \ub300\ud55c GUI\uc5d0 \ud45c\uc2dc\ub41c \uc120\ud0dd\uae30\ub97c \uc5c5\ub370\uc774\ud2b8\ud569\ub2c8\ub2e4.                   Args:          state (State): \ubaa8\ub4e0 GUI \ubcc0\uc218      \"\"\"      state.scenario_selector = list(          state.sm_tree_dict[state.sm_selected_year][state.sm_selected_month])      state.scenario_selector_two = state.scenario_selector.copy()      if len(state.scenario_selector) > 0:          state.selected_scenario = state.scenario_selector[0][0]        if (state.sm_selected_month != sm_current_month or state.sm_selected_year !=              sm_current_year) and state.sm_show_config_scenario:          notify(state, \"info\", \"This scenario is historical, you can't modify it\")          state.sm_show_config_scenario = False      sm_scenario_manager_md = \"\"\"  # \uc2dc\ub098\ub9ac\uc624 \ub9e4\ub2c8\uc800    <|layout|columns=8 4 4 3|columns[mobile]=1|  <layout_scenario|  <|layout|columns=1 1 3|columns[mobile]=1|  <|  Year    <|{sm_selected_year}|selector|lov={sm_year_selector}|dropdown|width=100%|on_change=change_sm_month_selector|>  |>    <|  Month    <|{sm_selected_month}|selector|lov={sm_month_selector}|dropdown|width=100%|on_change=change_scenario_selector|>  |>    <|  Scenario    <|{selected_scenario}|selector|lov={scenario_selector}|dropdown|value_by_id|width=18rem|>  |>  |>  |layout_scenario>    <graph|  **Graph**  <br/>  <|{sm_graph_selected}|selector|lov={sm_graph_selector}|dropdown|>  |graph>    <toggle_chart|  <center>  Pie/Line chart  <|{ch_show_pie}|toggle|lov={ch_choice_chart}|value_by_id|active={not 'Product ' in sm_graph_selected}|>  </center>  |toggle_chart>    <button_configure_scenario|  <br/>  <br/>  <|{sm_show_config_scenario_name}|button|on_action=show_config_scenario_action|active={sm_selected_month == sm_current_month and sm_selected_year == sm_current_year}|>  |button_configure_scenario>  |>    <|part|render={sm_show_config_scenario}|  \"\"\" + pa_parameters_md + \"\"\"  |>    <|part|render={not(sm_show_config_scenario)}|  \"\"\" + ch_chart_md + \"\"\"  |>  \"\"\"    # \uc2dc\ub098\ub9ac\uc624 \uad6c\uc131 \ubc84\ud2bc  sm_show_config_scenario_name = \"Hide configuration\"  sm_show_config_scenario = True      def show_config_scenario_action(state):      state.sm_show_config_scenario = not state.sm_show_config_scenario      state.sm_show_config_scenario_name = \"Hide configuration\" if state.sm_show_config_scenario else \"Configure scenario\"      sm_current_month = dt.date.today().strftime('%b')  sm_current_year = dt.date.today().strftime('%Y')    sm_selected_year = sm_current_year  sm_selected_month = sm_current_month    sm_tree_dict, sm_year_selector, sm_month_selector = create_time_selectors()    # \ud45c\uc2dc\ud560 \uadf8\ub798\ud504 \uc120\ud0dd  sm_graph_selector = [      'Costs',      'Purchases',      'Productions',      'Stocks',      'Back Order',      'Product RP1',      'Product RP2',      'Product FPA',      'Product FPB']  sm_graph_selected = sm_graph_selector[0] "}
{"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": "import taipy as tp  import pandas as pd      cs_compare_scenario_md = \"\"\"  # \uc2dc\ub098\ub9ac\uc624 \ube44\uad50    <|layout|columns=3 3 1|columns[mobile]=1|    <layout_scenario|  **Scenario 1**    <|layout|columns=1 1 3|columns[mobile]=1|  <|  Year    <|{sm_selected_year}|selector|lov={sm_year_selector}|dropdown|width=100%|on_change=change_sm_month_selector|>  |>    <|  Month    <|{sm_selected_month}|selector|lov={sm_month_selector}|dropdown|width=100%|on_change=change_scenario_selector|>  |>    <|  Scenario    <|{selected_scenario}|selector|lov={scenario_selector}|dropdown|value_by_id|width=18rem|>  |>  |>  |layout_scenario>        <layout_scenario|  **Scenario 2**    <|layout|columns=1 1 3|columns[mobile]=1|  <|  Year    <|{sm_selected_year}|selector|lov={sm_year_selector}|dropdown|width=100%|on_change=change_sm_month_selector|>  |>    <|  Month    <|{sm_selected_month}|selector|lov={sm_month_selector}|dropdown|width=100%|on_change=change_scenario_selector|>  |>    <|  Scenario    <|{selected_scenario_two}|selector|lov={scenario_selector_two}|dropdown|value_by_id|width=18rem|>  |>  |>  |layout_scenario>      <br/>  <br/>  <br/>  <center>  <|Compare scenario|button|on_action=compare_scenarios|active={len(scenario_selector)>1}|>  </center>  |>    <|part|render={cs_show_comparaison and len(scenario_selector)>=2}|  <|layout|columns=1 1 1|columns[mobile]=1|  <|  **Representation**    <|{cs_compar_graph_selected}|selector|lov={cs_compar_graph_selector}|dropdown=|value_by_id|>  |>    <br/>  <br/>  <center>  **Total cost of scenario 1:** *<|{str(int(sum_costs/1000))+' K'}|>*  </center>    <br/>  <br/>  <center>  **Total cost of scenario 2:** *<|{str(int(cs_sum_costs_two/1000))+' K'}|>*  </center>  |>        <|part|render={cs_compar_graph_selected=='Metrics'}|  <br/>  <br/>  <|layout|columns=1 1|columns[mobile]=1|  <|{cs_comparaison_metrics_df[cs_comparaison_metrics_df['Metrics']=='BO Cost']}|chart|type=bar|x=Metrics|y[1]=Scenario 1: BO Cost|y[2]=Scenario 2: BO Cost|color[2]=#2b93db|width={width_chart}|height={cs_height_bar_chart}|layout={ch_layout_dict}|>    <|{cs_comparaison_metrics_df[cs_comparaison_metrics_df['Metrics']=='Stock Cost']}|chart|type=bar|x=Metrics|y[1]=Scenario 1: Stock Cost|y[2]=Scenario 2: Stock Cost|color[1]=#ff7f0e|color[2]=#ff9a41|width={width_chart}|height={cs_height_bar_chart}|layout={ch_layout_dict}|>  |>  |>    <|part|render={cs_compar_graph_selected=='Costs'}|  <|{cs_comparaison_df}|chart|x=index|y[1]=Scenario 1 Cost|y[2]=Scenario 2 Cost|color[2]=#1f77b4|line[2]=dash|width={width_chart}|height={height_chart}|layout={ch_layout_dict}|>  |>  <|part|render={cs_compar_graph_selected=='Purchases'}|  <|{cs_comparaison_df}|chart|x=index|y[1]=Scenario 1 Purchase|y[2]=Scenario 2 Purchase|color[2]=#1f77b4|line[2]=dash|width={width_chart}|height={height_chart}|layout={ch_layout_dict}|>  |>  <|part|render={cs_compar_graph_selected=='Productions'}|  <|{cs_comparaison_df}|chart|x=index|y[1]=Scenario 1 Production|y[2]=Scenario 2 Production|color[2]=#1f77b4|line[2]=dash|width={width_chart}|height={height_chart}|layout={ch_layout_dict}|>  |>  <|part|render={cs_compar_graph_selected=='Stocks'}|  <|{cs_comparaison_df}|chart|x=index|y[1]=Scenario 1 Stock|y[2]=Scenario 2 Stock|color[2]=#1f77b4|line[2]=dash|width={width_chart}|height={height_chart}|layout={ch_layout_dict}|>  |>  <|part|render={cs_compar_graph_selected=='Back Order'}|  <|{cs_comparaison_df}|chart|x=index|y[1]=Scenario 1 BO|y[2]=Scenario 2 BO|color[2]=#1f77b4|line[2]=dash|width={width_chart}|height={height_chart}|layout={ch_layout_dict}|>  |>  |>    \"\"\"      def compare_scenarios(state):      \"\"\"\uc774 \uae30\ub2a5\uc740 \uc0ac\uc6a9\uc790\uac00 \ub2e4\ub978 \uba54\ud2b8\ub9ad\uc5d0\uc11c \uc120\ud0dd\ud55c \ub450 \uac00\uc9c0 \uc2dc\ub098\ub9ac\uc624\ub97c \ube44\uad50\ud558\uace0 \ube44\uad50 \uadf8\ub798\ud504\uc5d0 \ub300\ud55c \ub370\uc774\ud130 \ud504\ub808\uc784\uc744 \ucc44\uc6c1\ub2c8\ub2e4.        Args:          state (State): \ubaa8\ub4e0 GUI \ubcc0\uc218      \"\"\"      state.cs_show_comparaison = True            # \uc0ac\uc6a9\uc790\uac00 \uc120\ud0dd\ud55c \ub450 \uac00\uc9c0 \uc2dc\ub098\ub9ac\uc624 \uac00\uc838\uc624\uae30      results_1 = tp.get(state.selected_scenario).pipelines['pipeline'].results.read()      results_2 = tp.get(state.selected_scenario_two).pipelines['pipeline'].results.read()      state.cs_sum_costs_two = results_2['Total Cost'].sum()        # \ub450 \uc2dc\ub098\ub9ac\uc624\uc758 \ubd80\ubd84 \ube44\uc6a9 \uacc4\uc0b0      bool_costs_of_stock = [c for c in results_2.columns                             if 'Cost' in c and 'Total' not in c and 'Stock' in c]            state.cs_sum_costs_of_stock_two = int(results_2[bool_costs_of_stock].sum(axis=1)\\                                                                          .sum(axis=0))        bool_costs_of_BO = [c for c in results_2.columns                          if 'Cost' in c and 'Total' not in c and 'BO' in c]      state.cs_sum_costs_of_BO_two = int(results_2[bool_costs_of_BO].sum(axis=1)\\                                                                    .sum(axis=0))        # \ube44\uad50 \uadf8\ub798\ud504\uc758 \ub370\uc774\ud130 \ud504\ub808\uc784\uc744 \ucc44\uc6c1\ub2c8\ub2e4.      new_result_1 = pd.DataFrame({\"index\": results_1.index})      new_result_2 = pd.DataFrame({\"index\": results_2.index})        columns_to_merge = ['Cost', 'Purchase', 'Production', 'Stock', 'BO']      for col in columns_to_merge:          if col == 'Cost':              bool_col_1 = [c for c in results_1.columns                            if col in c and 'Total' not in c]              bool_col_2 = [c for c in results_2.columns                            if col in c and 'Total' not in c]          else:              bool_col_1 = [c for c in results_1.columns                            if col in c and 'Total' not in c and 'Cost' not in c]              bool_col_2 = [c for c in results_2.columns                            if col in c and 'Total' not in c and 'Cost' not in c]            new_result_1[col] = results_1[bool_col_1].sum(axis=1)          new_result_2[col] = results_2[bool_col_2].sum(axis=1)        new_result_1.columns = ['Scenario 1 ' + column if column != 'index' else 'index'                              for column in new_result_1.columns]      new_result_2.columns = ['Scenario 2 ' + column if column !='index' else 'index'                              for column in new_result_2.columns]        state.cs_comparaison_metrics_df = pd.DataFrame(          {              \"Metrics\": [ \"Stock Cost\", \"BO Cost\"],              \"Scenario 1: Stock Cost\": [state.sum_costs_of_stock, None],              \"Scenario 2: Stock Cost\": [state.cs_sum_costs_of_stock_two, None],              \"Scenario 1: BO Cost\": [None, state.sum_costs_of_BO],              \"Scenario 2: BO Cost\": [None, state.cs_sum_costs_of_BO_two]          })        state.cs_comparaison_df = pd.merge(new_result_1, new_result_2, on=\"index\", how=\"inner\")      print(\"Comparaison done\")      pass      cs_height_bar_chart = \"80%\"    cs_show_comparaison = False    cs_compar_graph_selector = [      'Metrics',      'Costs',      'Purchases',      'Productions',      'Stocks',      'Back Order']  cs_compar_graph_selected = cs_compar_graph_selector[0]    cs_comparaison_df = pd.DataFrame({'index': [0],                                    'Scenario 1 Cost': [0],                                    'Scenario 1 Purchase': [0],                                    'Scenario 1 Production': [0],                                    'Scenario 1 Stock': [0],                                    'Scenario 1 BO': [0],                                    'Scenario 2 Cost': [0],                                    'Scenario 2 Purchase': [0],                                    'Scenario 2 Production': [0],                                    'Scenario 2 Stock': [0],                                    'Scenario 2 BO': [0]})    cs_comparaison_metrics_df = pd.DataFrame({\"Metrics\": [\"Stock Cost\", \"BO Cost\"],                                            \"Scenario 1: Stock Cost\": [0, 0],                                            \"Scenario 2: Stock Cost\": [0, 0],                                            \"Scenario 1: BO Cost\": [0, 0],                                            \"Scenario 2: BO Cost\": [0, 0]})    cs_sum_costs_of_stock_two = 0  cs_sum_costs_of_BO_two = 0  cs_sum_costs_two = 0 "}
{"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": "\u0000\u0005\u0016\u0007\u0000\u0002\u0000\u0000Mac OS X        \u0000\u0002\u0000\u0000\u0000\t\u0000\u0000\u00002\u0000\u0000\u000e\u00b0\u0000\u0000\u0000\u0002\u0000\u0000\u000e\u00e2\u0000\u0000\u0001\u001e\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000ATTR\u00ff\u00ff\u00ff[\u0000\u0000\u000e\u00e2\u0000\u0000\u0000\u0098\u0000\u0000\u0000\u000b\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0001\u0000\u0000\u0000\u0098\u0000\u0000\u0000\u000b\u0000\u0000\u0015com.apple.provenance\u0000\u0001\u0002\u0000\u00d9\u001b\u0099\u00deFw\u00ef\u00a5\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0001\u0000\u0000\u0000\u0001\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u001eThis resource fork intentionally left blank   \u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0001\u0000\u0000\u0000\u0001\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u001e\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u001c\u0000\u001e\u00ff\u00ff"}
{"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    import pandas as pd    from config.config import df_wine_production, df_wine_with_geometry    selected_year = \"average\"  year_list = [      \"average\",      \"08/09\",      \"09/10\",      \"10/11\",      \"11/12\",      \"12/13\",      \"13/14\",      \"14/15\",      \"15/16\",      \"16/17\",      \"17/18\",      \"18/19\",  ]    area_type_list = [\"AOC\", \"Region\"]  selected_area = area_type_list[0]      def get_df_map_color(      year: str, color: str, df_wine_with_geometry: pd.DataFrame = df_wine_with_geometry  ) -> pd.DataFrame:      \"\"\"Create a DataFrame for map coloring based on wine production data.        This function takes a specific year and wine color, and extracts relevant information      from the original wine production DataFrame (`df_wine_with_geometry`). It creates a DataFrame      suitable for map coloring, including information about regions, latitude, longitude, production,      size, and text (a field to display the hover in the map).        Args:          year (str): The selected year for wine production data.          color (str): The selected wine color (e.g., 'RED AND ROSE', 'WHITE').          df_wine_with_geometry (pd.DataFrame, optional): DataFrame containing wine production and          geographical information. Defaults to the global variable `df_wine_with_geometry`.        Returns:          df_map_color (pd.DataFrame): A DataFrame with information for map coloring.      \"\"\"        df_geometry_color = df_wine_with_geometry[          df_wine_with_geometry[\"wine_type\"] == color      ].copy()        df_map_color = df_geometry_color[[\"Region\", \"latitude\", \"longitude\"]]        # Production is divided by 10 to show million Liters      df_map_color[\"Production\"] = df_geometry_color[year] / 10        # this is only to display and acceptable size of the dots on the map, dividing by 5 is arbitrary:      df_map_color[\"size\"] = df_map_color[\"Production\"] / 5      df_map_color[\"text\"] = (          df_map_color[\"Region\"] + \": \" + df_map_color[\"Production\"].astype(str) + \" Ml\"      )        print(df_map_color.head())      return df_map_color      def get_df_wine_year_and_area(      year: str, area_type: str, df_wine_production: pd.DataFrame = df_wine_production  ) -> pd.DataFrame:      \"\"\"Create a DataFrame for wine production based on a specific year and area type.        This function takes a specific year and area type, and extracts relevant information      from the original wine production DataFrame (`df_wine_production`). It creates a DataFrame      suitable for displaying wine production data for a specified year and area type.        Args:          year (str): The selected year for wine production data.          area_type (str): The selected area type (e.g., 'AOC', 'Region').          df_wine_production (pd.DataFrame, optional): DataFrame containing wine production data.          Defaults to the global variable `df_wine_production`.        Returns:          df_wine_year (pd.DataFrame): A DataFrame with information for displaying wine production data.      \"\"\"        df_wine_year = df_wine_production[[area_type, \"wine_type\"]].copy()        # Production is divided by 10 to show million Liters      df_wine_year[\"Production\"] = df_wine_production[year] / 10      df_wine_year = df_wine_year.reset_index(drop=True)      df_wine_year = df_wine_year.rename(columns={area_type: \"Region\"})        df_wine_year = df_wine_year.groupby([\"Region\", \"wine_type\"]).sum()      df_wine_year = df_wine_year.reset_index()      df_wine_year = df_wine_year.sort_values(by=[\"Production\"])        # Add a column to display a cleaner and shorter label in the bar chart      df_wine_year[\"Wine Region\"] = (          (df_wine_year[\"Region\"].str.replace(r\"[a-zA-Z]/ \", \"\", regex=True))          .str.replace(r\" \\(.+\", \"\", regex=True)          .str.replace(r\" including.+\", \"\", regex=True)      )        return df_wine_year      df_wine_year = get_df_wine_year_and_area(selected_year, selected_area)  df_map_red = get_df_map_color(selected_year, \"RED AND ROSE\")  df_map_white = get_df_map_color(selected_year, \"WHITE\")    # Variables for the labels:  total_production = df_wine_year[\"Production\"].sum()  red_rose_production = df_wine_year[df_wine_year[\"wine_type\"] == \"RED AND ROSE\"][      \"Production\"  ].sum()  white_production = df_wine_year[df_wine_year[\"wine_type\"] == \"WHITE\"][      \"Production\"  ].sum()      def on_change(state: Any) -> None:      \"\"\"Update state based on a change in selected year and area type.        This function takes the current state (`state`) and updates relevant attributes based on a      change in the selected year and area type. It calculates total production, production for red      and white wines, and updates map DataFrames for red and white wines.        Args:          state (Any): The current state object.        Returns:          None      \"\"\"        print(\"Chosen year: \", state.selected_year)      print(\"Choose region type: \", state.selected_area)      state.df_wine_year = get_df_wine_year_and_area(          state.selected_year, state.selected_area      )      # Update the labels:      state.total_production = state.df_wine_year[\"Production\"].sum()      state.red_rose_production = state.df_wine_year[          df_wine_year[\"wine_type\"] == \"RED AND ROSE\"      ][\"Production\"].sum()      state.white_production = state.df_wine_year[df_wine_year[\"wine_type\"] == \"WHITE\"][          \"Production\"      ].sum()        # Update map dataframes:      state.df_map_red = get_df_map_color(state.selected_year, \"RED AND ROSE\")      state.df_map_white = get_df_map_color(state.selected_year, \"WHITE\")      ##############################################################################################################  ##                                      Chart properties:                                                   ##  ##############################################################################################################    bar_chart_layout = {      \"yaxis\": {\"range\": [0, 600]},      \"xaxis\": {\"automargin\": True},      \"xlabel\": \"None\",  }    property_barchart_red_rose = {      \"type\": \"bar\",      \"x\": \"Wine Region\",      \"y[1]\": \"Production\",      \"color[1]\": \"#900020\",      \"title\": \"Production of Red wines by Region (Million Liters)\",  }    property_barchart_white = {      \"type\": \"bar\",      \"x\": \"Wine Region\",      \"y[1]\": \"Production\",      \"color[1]\": \"#E0C095\",      \"title\": f\"Production of White wines by Region (Million Liters)\",  }    ##############################################################################################################  ##                                      For the map:                                                        ##  ##############################################################################################################  marker_map_white = {      \"color\": \"Production\",      \"size\": \"size\",      \"showscale\": True,      \"colorscale\": \"Viridis\",  # No better colormap found  }    marker_map_red = {      \"color\": \"Production\",      \"size\": \"size\",      \"showscale\": True,      \"colorscale\": \"RdBu\",  }    layout_map_red = {      \"title\": \"Production of red wines, per Region - Million Liters\",      \"dragmode\": \"zoom\",      \"mapbox\": {          # \"style\": \"stamen-toner\",          \"style\": \"open-street-map\",          \"center\": {\"lat\": 46, \"lon\": 1.9},          \"zoom\": 5,      },  }    layout_map_white = {      \"title\": \"Production of white wines, per Region - Million Liters\",      \"dragmode\": \"zoom\",      \"mapbox\": {          # \"style\": \"stamen-toner\",          \"style\": \"open-street-map\",          \"center\": {\"lat\": 46, \"lon\": 1.9},          \"zoom\": 5,      },  }    options_map = {      \"unselected\": {\"marker\": {\"opacity\": 0.8}},      \"hovertemplate\": \"<b>%{text}</b>\" + \"<extra></extra>\",  }    ##############################################################################################################  ##                                      Taipy Code:                                                         ##  ##############################################################################################################    all_regions_md = \"\"\"    <|{selected_year}|selector|lov={year_list}|on_change=on_change|dropdown|label=Choose Year|>    # AOC Wine production | **<|{selected_year}|text|raw|> Campaign**{: .color-primary} | All Regions    <|layout|columns=1 1 1|    <|card card-bg|  ## **Total:**{: .color-primary}  \\n  ### <|{f'{int(total_production / 10) } Million Liters'}|>  |>  <|card card-bg|  ## **Red / Ros\u00e9:**{: .color-primary}  \\n  ###<|{f'{int(red_rose_production / 10) } Million Liters'}|>  |>  <|card card-bg|  ## **White:**{: .color-primary}  \\n  ###<|{f'{int(white_production / 10) } Million Liters'}|>  |>  |>      ## Production **by <|{selected_area}|text|raw|>**{: .color-primary}    <|{selected_area}|toggle|lov={area_type_list}|on_change=on_change|>    <|layout|columns=1 1|  <|{df_wine_year[df_wine_year[\"wine_type\"] == \"RED AND ROSE\"]}|chart|properties={property_barchart_red_rose}|layout={bar_chart_layout}|height=800px|>    <|{df_wine_year[df_wine_year[\"wine_type\"] == \"WHITE\"]}|chart|properties={property_barchart_white}|layout={bar_chart_layout}|height=800px|>  |>    ## Production Maps, **<|{selected_year}|text|raw|>**{: .color-primary}:    <|layout|columns=1 1|  <|{df_map_red}|chart|type=scattermapbox|lat=latitude|lon=longitude|marker={marker_map_red}|layout={layout_map_red}|text=text|mode=markers|height=600px|options={options_map}|>    <|{df_map_white}|chart|type=scattermapbox|lat=latitude|lon=longitude|marker={marker_map_white}|layout={layout_map_white}|text=text|mode=markers|height=600px|options={options_map}|>  |>    ## Data for all the regions:  <|{df_wine_production}|table|height=400px|width=100%|filter[AOC]=True|filter[Region]=True|filter[wine_type]=True|>  \"\"\" "}
{"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": "import json      def add_line(source, line, step):        line = line.replace('Getting Started with Taipy Core', 'Getting Started with Taipy Core on Notebooks')      line = line.replace('(../src/', '(https://docs.taipy.io/en/latest/getting_started/src/')      line = line.replace('(time_series.csv)', '(https://docs.taipy.io/en/latest/getting_started/src/time_series.csv)') #!!!!!      line = line.replace('(time_series_2.csv)', '(https://docs.taipy.io/en/latest/getting_started/src/time_series_2.csv)')      line = line.replace('!!! example \"Configuration\"','')      line = line.replace('=== \"Python configuration\"','')              if line.startswith('!['):          if step != 'index':              line = line.replace('(', '(https://raw.githubusercontent.com/Avaiga/taipy-getting-started-core/develop/' + step + '/')          else:              line = line.replace('(', '(https://raw.githubusercontent.com/Avaiga/taipy-getting-started-core/develop/')            # 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','Using Notebooks, you **may want to restart the kernel** after a run of Taipy Core\\n']      })        execution_count += 1      return notebook, execution_count      def create_steps(notebook, execution_count):      steps = ['step_0' + str(i) for i in range(1, 9)]      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[:8] == \"        \" or len(line)<=1) and for_studio == 2:                  line=line[8:]                 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.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": "from unittest import mock    from src.taipy.config import Config  from src.taipy.config._config import _Config  from src.taipy.config._config_comparator._comparator_result import _ComparatorResult  from src.taipy.config.global_app.global_app_config import GlobalAppConfig  from tests.config.utils.section_for_tests import SectionForTest  from tests.config.utils.unique_section_for_tests import UniqueSectionForTest      class TestConfigComparator:      unique_section_1 = UniqueSectionForTest(attribute=\"unique_attribute_1\", prop=\"unique_prop_1\")      unique_section_1b = UniqueSectionForTest(attribute=\"unique_attribute_1\", prop=\"unique_prop_1b\")      section_1 = SectionForTest(\"section_1\", attribute=\"attribute_1\", prop=\"prop_1\")      section_2 = SectionForTest(\"section_2\", attribute=2, prop=\"prop_2\")      section_2b = SectionForTest(\"section_2\", attribute=\"attribute_2\", prop=\"prop_2b\")      section_3 = SectionForTest(\"section_3\", attribute=[1, 2, 3, 4], prop=[\"prop_1\"])      section_3b = SectionForTest(\"section_3\", attribute=[1, 2], prop=[\"prop_1\", \"prop_2\", \"prop_3\"])      section_3c = SectionForTest(\"section_3\", attribute=[2, 1], prop=[\"prop_3\", \"prop_1\", \"prop_2\"])        def test_comparator_compare_method_call(self):          _config_1 = _Config._default_config()          _config_2 = _Config._default_config()            with mock.patch(              \"src.taipy.config._config_comparator._config_comparator._ConfigComparator._find_conflict_config\"          ) as mck:              Config._comparator._find_conflict_config(_config_1, _config_2)              mck.assert_called_once_with(_config_1, _config_2)        def test_comparator_without_diff(self):          _config_1 = _Config._default_config()          _config_2 = _Config._default_config()            config_diff = Config._comparator._find_conflict_config(_config_1, _config_2)          assert isinstance(config_diff, _ComparatorResult)          assert config_diff == {}        def test_comparator_with_updated_global_config(self):          _config_1 = _Config._default_config()          _config_1._global_config = GlobalAppConfig(foo=\"bar\")            _config_2 = _Config._default_config()          _config_2._global_config = GlobalAppConfig(foo=\"baz\", bar=\"foo\")            config_diff = Config._comparator._find_conflict_config(_config_1, _config_2)            assert config_diff.get(\"unconflicted_sections\") is None          assert config_diff.get(\"conflicted_sections\") is not None            conflicted_config_diff = config_diff[\"conflicted_sections\"]          assert len(conflicted_config_diff[\"modified_items\"]) == 1          assert conflicted_config_diff[\"modified_items\"][0] == (              (\"Global Configuration\", \"foo\", None),              (\"bar\", \"baz\"),          )          assert len(conflicted_config_diff[\"added_items\"]) == 1          assert conflicted_config_diff[\"added_items\"][0] == (              (\"Global Configuration\", \"bar\", None),              \"foo\",          )        def test_comparator_with_new_section(self):          _config_1 = _Config._default_config()            # The first \"section_name\" is added to the Config          _config_2 = _Config._default_config()          _config_2._sections[SectionForTest.name] = {\"section_1\": self.section_1}          config_diff = Config._comparator._find_conflict_config(_config_1, _config_2)            conflicted_config_diff = config_diff[\"conflicted_sections\"]          assert len(conflicted_config_diff[\"added_items\"]) == 1          assert conflicted_config_diff[\"added_items\"][0] == (              (\"section_name\", None, None),              {\"section_1\": {\"attribute\": \"attribute_1\", \"prop\": \"prop_1\"}},          )          assert conflicted_config_diff.get(\"modified_items\") is None          assert conflicted_config_diff.get(\"removed_items\") is None            # A new \"section_name\" is added to the Config          _config_3 = _Config._default_config()          _config_3._sections[SectionForTest.name] = {\"section_1\": self.section_1, \"section_2\": self.section_2}          config_diff = Config._comparator._find_conflict_config(_config_2, _config_3)            conflicted_config_diff = config_diff[\"conflicted_sections\"]          assert len(conflicted_config_diff[\"added_items\"]) == 1          assert conflicted_config_diff[\"added_items\"][0] == (              (\"section_name\", \"section_2\", None),              {\"attribute\": \"2:int\", \"prop\": \"prop_2\"},          )          assert conflicted_config_diff.get(\"modified_items\") is None          assert conflicted_config_diff.get(\"removed_items\") is None        def test_comparator_with_removed_section(self):          _config_1 = _Config._default_config()            # All \"section_name\" sections are removed from the Config          _config_2 = _Config._default_config()          _config_2._sections[SectionForTest.name] = {\"section_1\": self.section_1}          config_diff = Config._comparator._find_conflict_config(_config_2, _config_1)            conflicted_config_diff = config_diff[\"conflicted_sections\"]          assert len(conflicted_config_diff[\"removed_items\"]) == 1          assert conflicted_config_diff[\"removed_items\"][0] == (              (\"section_name\", None, None),              {\"section_1\": {\"attribute\": \"attribute_1\", \"prop\": \"prop_1\"}},          )          assert conflicted_config_diff.get(\"modified_items\") is None          assert conflicted_config_diff.get(\"added_items\") is None            # Section \"section_1\" is removed from the Config          _config_3 = _Config._default_config()          _config_3._sections[SectionForTest.name] = {\"section_1\": self.section_1, \"section_2\": self.section_2}          config_diff = Config._comparator._find_conflict_config(_config_3, _config_2)            conflicted_config_diff = config_diff[\"conflicted_sections\"]          assert len(conflicted_config_diff[\"removed_items\"]) == 1          assert conflicted_config_diff[\"removed_items\"][0] == (              (\"section_name\", \"section_2\", None),              {\"attribute\": \"2:int\", \"prop\": \"prop_2\"},          )          assert conflicted_config_diff.get(\"modified_items\") is None          assert conflicted_config_diff.get(\"added_items\") is None        def test_comparator_with_modified_section(self):          _config_1 = _Config._default_config()          _config_1._sections[SectionForTest.name] = {\"section_2\": self.section_2}            # All \"section_name\" sections are removed from the Config          _config_2 = _Config._default_config()          _config_2._sections[SectionForTest.name] = {\"section_2\": self.section_2b}          config_diff = Config._comparator._find_conflict_config(_config_1, _config_2)            conflicted_config_diff = config_diff[\"conflicted_sections\"]          assert len(conflicted_config_diff[\"modified_items\"]) == 2          assert conflicted_config_diff[\"modified_items\"][0] == (              (\"section_name\", \"section_2\", \"attribute\"),              (\"2:int\", \"attribute_2\"),          )          assert conflicted_config_diff[\"modified_items\"][1] == (              (\"section_name\", \"section_2\", \"prop\"),              (\"prop_2\", \"prop_2b\"),          )          assert conflicted_config_diff.get(\"removed_items\") is None          assert conflicted_config_diff.get(\"added_items\") is None        def test_comparator_with_modified_list_attribute(self):          _config_1 = _Config._default_config()          _config_1._sections[SectionForTest.name] = {\"section_3\": self.section_3}            # All \"section_name\" sections are removed from the Config          _config_2 = _Config._default_config()          _config_2._sections[SectionForTest.name] = {\"section_3\": self.section_3b}          config_diff = Config._comparator._find_conflict_config(_config_1, _config_2)            conflicted_config_diff = config_diff[\"conflicted_sections\"]          assert len(conflicted_config_diff[\"modified_items\"]) == 2          assert conflicted_config_diff[\"modified_items\"][0] == (              (\"section_name\", \"section_3\", \"prop\"),              ([\"prop_1\"], [\"prop_1\", \"prop_2\", \"prop_3\"]),          )          assert conflicted_config_diff[\"modified_items\"][1] == (              (\"section_name\", \"section_3\", \"attribute\"),              ([\"1:int\", \"2:int\", \"3:int\", \"4:int\"], [\"1:int\", \"2:int\"]),          )          assert conflicted_config_diff.get(\"removed_items\") is None          assert conflicted_config_diff.get(\"added_items\") is None        def test_comparator_with_different_order_list_attributes(self):          _config_1 = _Config._default_config()          _config_1._unique_sections          _config_1._sections[SectionForTest.name] = {\"section_3\": self.section_3b}            # Create _config_2 with different order of list attributes          _config_2 = _Config._default_config()          _config_2._sections[SectionForTest.name] = {\"section_3\": self.section_3c}          config_diff = Config._comparator._find_conflict_config(_config_1, _config_2)            # There should be no difference since the order of list attributes is ignored          assert config_diff == {}        def test_comparator_with_new_unique_section(self):          _config_1 = _Config._default_config()            _config_2 = _Config._default_config()          _config_2._unique_sections[UniqueSectionForTest.name] = self.unique_section_1          config_diff = Config._comparator._find_conflict_config(_config_1, _config_2)            conflicted_config_diff = config_diff[\"conflicted_sections\"]          assert len(conflicted_config_diff[\"added_items\"]) == 1          assert conflicted_config_diff[\"added_items\"][0] == (              (\"unique_section_name\", None, None),              {\"attribute\": \"unique_attribute_1\", \"prop\": \"unique_prop_1\"},          )          assert conflicted_config_diff.get(\"modified_items\") is None          assert conflicted_config_diff.get(\"removed_items\") is None        def test_comparator_with_removed_unique_section(self):          _config_1 = _Config._default_config()            _config_2 = _Config._default_config()          _config_2._unique_sections[UniqueSectionForTest.name] = self.unique_section_1          config_diff = Config._comparator._find_conflict_config(_config_2, _config_1)            conflicted_config_diff = config_diff[\"conflicted_sections\"]          assert len(conflicted_config_diff[\"removed_items\"]) == 1          assert conflicted_config_diff[\"removed_items\"][0] == (              (\"unique_section_name\", None, None),              {\"attribute\": \"unique_attribute_1\", \"prop\": \"unique_prop_1\"},          )          assert conflicted_config_diff.get(\"modified_items\") is None          assert conflicted_config_diff.get(\"added_items\") is None        def test_comparator_with_modified_unique_section(self):          _config_1 = _Config._default_config()          _config_1._unique_sections[UniqueSectionForTest.name] = self.unique_section_1            # All \"section_name\" sections are removed from the Config          _config_2 = _Config._default_config()          _config_2._unique_sections[UniqueSectionForTest.name] = self.unique_section_1b          config_diff = Config._comparator._find_conflict_config(_config_1, _config_2)            conflicted_config_diff = config_diff[\"conflicted_sections\"]          assert len(conflicted_config_diff[\"modified_items\"]) == 1          assert conflicted_config_diff[\"modified_items\"][0] == (              (\"unique_section_name\", \"prop\", None),              (\"unique_prop_1\", \"unique_prop_1b\"),          )          assert conflicted_config_diff.get(\"removed_items\") is None          assert conflicted_config_diff.get(\"added_items\") is None        def test_unconflicted_section_name_store_statically(self):          Config._comparator._add_unconflicted_section(\"section_name_1\")          assert Config._comparator._unconflicted_sections == {\"section_name_1\"}            Config._comparator._add_unconflicted_section(\"section_name_2\")          assert Config._comparator._unconflicted_sections == {\"section_name_1\", \"section_name_2\"}            Config._comparator._add_unconflicted_section(\"section_name_1\")          assert Config._comparator._unconflicted_sections == {\"section_name_1\", \"section_name_2\"}        def test_unconflicted_diff_is_stored_separated_from_conflicted_ones(self):          _config_1 = _Config._default_config()          _config_1._unique_sections[UniqueSectionForTest.name] = self.unique_section_1          _config_1._sections[SectionForTest.name] = {\"section_2\": self.section_2}            _config_2 = _Config._default_config()          _config_2._unique_sections[UniqueSectionForTest.name] = self.unique_section_1b          _config_2._sections[SectionForTest.name] = {\"section_2\": self.section_2b}            # Compare 2 Configuration          config_diff = Config._comparator._find_conflict_config(_config_1, _config_2)            assert config_diff.get(\"unconflicted_sections\") is None          assert config_diff.get(\"conflicted_sections\") is not None          assert len(config_diff[\"conflicted_sections\"][\"modified_items\"]) == 3            # Ignore any diff of \"section_name\" and compare          Config._comparator._add_unconflicted_section(\"section_name\")          config_diff = Config._comparator._find_conflict_config(_config_1, _config_2)          assert config_diff.get(\"unconflicted_sections\") is not None          assert len(config_diff[\"unconflicted_sections\"][\"modified_items\"]) == 2          assert config_diff.get(\"conflicted_sections\") is not None          assert len(config_diff[\"conflicted_sections\"][\"modified_items\"]) == 1            # Ignore any diff of Global Config and compare          Config._comparator._add_unconflicted_section([\"unique_section_name\"])          config_diff = Config._comparator._find_conflict_config(_config_1, _config_2)          assert config_diff.get(\"unconflicted_sections\") is not None          assert len(config_diff[\"unconflicted_sections\"][\"modified_items\"]) == 3          assert config_diff.get(\"conflicted_sections\") is None        def test_comparator_log_message(self, caplog):          _config_1 = _Config._default_config()          _config_1._unique_sections[UniqueSectionForTest.name] = self.unique_section_1          _config_1._sections[SectionForTest.name] = {\"section_2\": self.section_2}            _config_2 = _Config._default_config()          _config_2._unique_sections[UniqueSectionForTest.name] = self.unique_section_1b          _config_2._sections[SectionForTest.name] = {\"section_2\": self.section_2b}            # Ignore any diff of \"section_name\" and compare          Config._comparator._add_unconflicted_section(\"section_name\")          Config._comparator._find_conflict_config(_config_1, _config_2)            error_messages = caplog.text.strip().split(\"\\n\")          assert len(error_messages) == 5          assert all(              t in error_messages[0]              for t in [                  \"INFO\",                  \"There are non-conflicting changes between the current configuration and the current configuration:\",              ]          )          assert 'section_name \"section_2\" has attribute \"attribute\" modified: 2:int -> attribute_2' in error_messages[1]          assert 'section_name \"section_2\" has attribute \"prop\" modified: prop_2 -> prop_2b' in error_messages[2]          assert all(              t in error_messages[3]              for t in [                  \"ERROR\",                  \"The current configuration conflicts with the current configuration:\",              ]          )          assert 'unique_section_name \"prop\" was modified: unique_prop_1 -> unique_prop_1b' in error_messages[4]            caplog.clear()            Config._comparator._find_conflict_config(_config_1, _config_2, old_version_number=\"1.0\")            error_messages = caplog.text.strip().split(\"\\n\")          assert len(error_messages) == 5          assert all(              t in error_messages[0]              for t in [                  \"INFO\",                  \"There are non-conflicting changes between the configuration for version 1.0 and the current configuration:\",              ]          )          assert all(              t in error_messages[3]              for t in [                  \"ERROR\",                  \"The configuration for version 1.0 conflicts with the current configuration:\",              ]          )            caplog.clear()            Config._comparator._compare(              _config_1,              _config_2,              version_number_1=\"1.0\",              version_number_2=\"2.0\",          )            error_messages = caplog.text.strip().split(\"\\n\")          assert len(error_messages) == 3          assert all(              t in error_messages[0]              for t in [\"INFO\", \"Differences between version 1.0 Configuration and version 2.0 Configuration:\"]          )            caplog.clear() "}
{"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": "import os  from unittest import mock    import pytest    from src.taipy.config.config import Config  from src.taipy.config.exceptions.exceptions import InconsistentEnvVariableError, MissingEnvVariableError  from tests.config.utils.named_temporary_file import NamedTemporaryFile      def test_override_default_configuration_with_code_configuration():      assert not Config.global_config.root_folder == \"foo\"        assert len(Config.unique_sections) == 1      assert Config.unique_sections[\"unique_section_name\"] is not None      assert Config.unique_sections[\"unique_section_name\"].attribute == \"default_attribute\"      assert Config.unique_sections[\"unique_section_name\"].prop is None        assert len(Config.sections) == 1      assert len(Config.sections[\"section_name\"]) == 1      assert Config.sections[\"section_name\"] is not None      assert Config.sections[\"section_name\"][\"default\"].attribute == \"default_attribute\"        Config.configure_global_app(root_folder=\"foo\")      assert Config.global_config.root_folder == \"foo\"        Config.configure_unique_section_for_tests(\"foo\", prop=\"bar\")      assert len(Config.unique_sections) == 1      assert Config.unique_sections[\"unique_section_name\"] is not None      assert Config.unique_sections[\"unique_section_name\"].attribute == \"foo\"      assert Config.unique_sections[\"unique_section_name\"].prop == \"bar\"        Config.configure_section_for_tests(\"my_id\", \"baz\", prop=\"qux\")      assert len(Config.unique_sections) == 1      assert Config.sections[\"section_name\"] is not None      assert Config.sections[\"section_name\"][\"my_id\"].attribute == \"baz\"      assert Config.sections[\"section_name\"][\"my_id\"].prop == \"qux\"      def test_override_default_config_with_code_config_including_env_variable_values():      Config.configure_global_app()      assert Config.global_config.foo is None      Config.configure_global_app(foo=\"bar\")      assert Config.global_config.foo == \"bar\"        with mock.patch.dict(os.environ, {\"FOO\": \"foo\"}):          Config.configure_global_app(foo=\"ENV[FOO]\")          assert Config.global_config.foo == \"foo\"      def test_override_default_configuration_with_file_configuration():      tf = NamedTemporaryFile(          \"\"\"  [TAIPY]  foo = \"bar\"    \"\"\"      )      assert Config.global_config.foo is None        Config.load(tf.filename)        assert Config.global_config.foo == \"bar\"      def test_override_default_config_with_file_config_including_env_variable_values():      tf = NamedTemporaryFile(          \"\"\"  [TAIPY]  foo_attribute = \"ENV[FOO]:int\"  bar_attribute = \"ENV[BAR]:bool\"  \"\"\"      )      assert Config.global_config.foo_attribute is None      assert Config.global_config.bar_attribute is None        with mock.patch.dict(os.environ, {\"FOO\": \"foo\", \"BAR\": \"true\"}):          with pytest.raises(InconsistentEnvVariableError):              Config.load(tf.filename)              Config.global_config.foo_attribute        with mock.patch.dict(os.environ, {\"FOO\": \"5\"}):          with pytest.raises(MissingEnvVariableError):              Config.load(tf.filename)              Config.global_config.bar_attribute        with mock.patch.dict(os.environ, {\"FOO\": \"6\", \"BAR\": \"TRUe\"}):          Config.load(tf.filename)          assert Config.global_config.foo_attribute == 6          assert Config.global_config.bar_attribute      def test_code_configuration_does_not_override_file_configuration():      config_from_filename = NamedTemporaryFile(          \"\"\"  [TAIPY]  foo = 2      \"\"\"      )      Config.override(config_from_filename.filename)        Config.configure_global_app(foo=21)        assert Config.global_config.foo == 2  # From file config      def test_code_configuration_does_not_override_file_configuration_including_env_variable_values():      config_from_filename = NamedTemporaryFile(          \"\"\"  [TAIPY]  foo = 2      \"\"\"      )      Config.override(config_from_filename.filename)        with mock.patch.dict(os.environ, {\"FOO\": \"21\"}):          Config.configure_global_app(foo=\"ENV[FOO]\")          assert Config.global_config.foo == 2  # From file config      def test_file_configuration_overrides_code_configuration():      config_from_filename = NamedTemporaryFile(          \"\"\"  [TAIPY]  foo = 2      \"\"\"      )      Config.configure_global_app(foo=21)      Config.load(config_from_filename.filename)        assert Config.global_config.foo == 2  # From file config      def test_file_configuration_overrides_code_configuration_including_env_variable_values():      config_from_filename = NamedTemporaryFile(          \"\"\"  [TAIPY]  foo = \"ENV[FOO]:int\"      \"\"\"      )      Config.configure_global_app(foo=21)        with mock.patch.dict(os.environ, {\"FOO\": \"2\"}):          Config.load(config_from_filename.filename)          assert Config.global_config.foo == 2  # From file config      def test_override_default_configuration_with_multiple_configurations():      file_config = NamedTemporaryFile(          \"\"\"  [TAIPY]  foo = 10  bar = \"baz\"      \"\"\"      )      # Default config is applied      assert Config.global_config.foo is None      assert Config.global_config.bar is None        # Code config is applied      Config.configure_global_app(foo=\"bar\")      assert Config.global_config.foo == \"bar\"      assert Config.global_config.bar is None        # File config is applied      Config.load(file_config.filename)      assert Config.global_config.foo == 10      assert Config.global_config.bar == \"baz\"      def test_override_default_configuration_with_multiple_configurations_including_environment_variable_values():      file_config = NamedTemporaryFile(          \"\"\"  [TAIPY]  att = \"ENV[BAZ]\"      \"\"\"      )        with mock.patch.dict(os.environ, {\"FOO\": \"bar\", \"BAZ\": \"qux\"}):          # Default config is applied          assert Config.global_config.att is None            # Code config is applied          Config.configure_global_app(att=\"ENV[FOO]\")          assert Config.global_config.att == \"bar\"            # File config is applied          Config.load(file_config.filename)          assert Config.global_config.att == \"qux\" "}
{"text": "import pytest    from src.taipy.config import Config  from src.taipy.config.exceptions.exceptions import ConfigurationUpdateBlocked  from tests.config.utils.section_for_tests import SectionForTest  from tests.config.utils.unique_section_for_tests import UniqueSectionForTest      def test_unique_section_registration_and_usage():      assert Config.unique_sections is not None      assert Config.unique_sections[UniqueSectionForTest.name] is not None      assert Config.unique_sections[UniqueSectionForTest.name].attribute == \"default_attribute\"      assert Config.unique_sections[UniqueSectionForTest.name].prop is None        mySection = Config.configure_unique_section_for_tests(attribute=\"my_attribute\", prop=\"my_prop\")        assert Config.unique_sections is not None      assert Config.unique_sections[UniqueSectionForTest.name] is not None      assert mySection is not None      assert Config.unique_sections[UniqueSectionForTest.name].attribute == \"my_attribute\"      assert mySection.attribute == \"my_attribute\"      assert Config.unique_sections[UniqueSectionForTest.name].prop == \"my_prop\"      assert mySection.prop == \"my_prop\"        myNewSection = Config.configure_unique_section_for_tests(attribute=\"my_new_attribute\", prop=\"my_new_prop\")        assert Config.unique_sections is not None      assert Config.unique_sections[UniqueSectionForTest.name] is not None      assert myNewSection is not None      assert mySection is not None      assert Config.unique_sections[UniqueSectionForTest.name].attribute == \"my_new_attribute\"      assert myNewSection.attribute == \"my_new_attribute\"      assert mySection.attribute == \"my_new_attribute\"      assert Config.unique_sections[UniqueSectionForTest.name].prop == \"my_new_prop\"      assert myNewSection.prop == \"my_new_prop\"      assert mySection.prop == \"my_new_prop\"      def test_sections_exposed_as_attribute():      assert Config.unique_section_name.attribute == \"default_attribute\"      Config.configure_unique_section_for_tests(\"my_attribute\")      assert Config.unique_section_name.attribute == \"my_attribute\"        assert Config.section_name[\"default\"].attribute == \"default_attribute\"      Config.configure_section_for_tests(id=\"my_id\", attribute=\"my_attribute\")      assert Config.section_name[\"my_id\"].attribute == \"my_attribute\"      def test_section_registration_and_usage():      assert Config.sections is not None      assert len(Config.sections) == 1      assert Config.sections[SectionForTest.name] is not None      assert len(Config.sections[SectionForTest.name]) == 1      assert Config.sections[SectionForTest.name][\"default\"] is not None      assert Config.sections[SectionForTest.name][\"default\"].attribute == \"default_attribute\"      assert Config.sections[SectionForTest.name][\"default\"].prop == \"default_prop\"      assert Config.sections[SectionForTest.name][\"default\"].foo is None        myFirstSection = Config.configure_section_for_tests(id=\"first\", attribute=\"my_attribute\", prop=\"my_prop\", foo=\"bar\")      assert Config.sections is not None      assert len(Config.sections) == 1      assert Config.sections[SectionForTest.name] is not None      assert len(Config.sections[SectionForTest.name]) == 2      assert Config.sections[SectionForTest.name][\"default\"] is not None      assert Config.sections[SectionForTest.name][\"default\"].attribute == \"default_attribute\"      assert Config.sections[SectionForTest.name][\"default\"].prop == \"default_prop\"      assert Config.sections[SectionForTest.name][\"default\"].foo is None      assert Config.sections[SectionForTest.name][\"first\"] is not None      assert Config.sections[SectionForTest.name][\"first\"].attribute == \"my_attribute\"      assert Config.sections[SectionForTest.name][\"first\"].prop == \"my_prop\"      assert Config.sections[SectionForTest.name][\"first\"].foo == \"bar\"      assert myFirstSection.attribute == \"my_attribute\"      assert myFirstSection.prop == \"my_prop\"      assert myFirstSection.foo == \"bar\"        myNewSection = Config.configure_section_for_tests(id=\"second\", attribute=\"my_new_attribute\", prop=\"my_new_prop\")      assert Config.sections is not None      assert len(Config.sections) == 1      assert Config.sections[SectionForTest.name] is not None      assert len(Config.sections[SectionForTest.name]) == 3      assert Config.sections[SectionForTest.name][\"default\"] is not None      assert Config.sections[SectionForTest.name][\"default\"].attribute == \"default_attribute\"      assert Config.sections[SectionForTest.name][\"default\"].prop == \"default_prop\"      assert Config.sections[SectionForTest.name][\"default\"].foo is None      assert Config.sections[SectionForTest.name][\"first\"] is not None      assert Config.sections[SectionForTest.name][\"first\"].attribute == \"my_attribute\"      assert Config.sections[SectionForTest.name][\"first\"].prop == \"my_prop\"      assert Config.sections[SectionForTest.name][\"first\"].foo == \"bar\"      assert Config.sections[SectionForTest.name][\"second\"] is not None      assert Config.sections[SectionForTest.name][\"second\"].attribute == \"my_new_attribute\"      assert Config.sections[SectionForTest.name][\"second\"].prop == \"my_new_prop\"      assert Config.sections[SectionForTest.name][\"second\"].foo is None      assert myFirstSection.attribute == \"my_attribute\"      assert myFirstSection.prop == \"my_prop\"      assert myFirstSection.foo == \"bar\"      assert myNewSection.attribute == \"my_new_attribute\"      assert myNewSection.prop == \"my_new_prop\"      assert myNewSection.foo is None        my2ndSection = Config.configure_section_for_tests(id=\"second\", attribute=\"my_2nd_attribute\", prop=\"my_2nd_prop\")      assert Config.sections is not None      assert len(Config.sections) == 1      assert Config.sections[SectionForTest.name] is not None      assert len(Config.sections[SectionForTest.name]) == 3      assert Config.sections[SectionForTest.name][\"default\"] is not None      assert Config.sections[SectionForTest.name][\"default\"].attribute == \"default_attribute\"      assert Config.sections[SectionForTest.name][\"default\"].prop == \"default_prop\"      assert Config.sections[SectionForTest.name][\"default\"].foo is None      assert Config.sections[SectionForTest.name][\"first\"] is not None      assert Config.sections[SectionForTest.name][\"first\"].attribute == \"my_attribute\"      assert Config.sections[SectionForTest.name][\"first\"].prop == \"my_prop\"      assert Config.sections[SectionForTest.name][\"first\"].foo == \"bar\"      assert Config.sections[SectionForTest.name][\"second\"] is not None      assert Config.sections[SectionForTest.name][\"second\"].attribute == \"my_2nd_attribute\"      assert Config.sections[SectionForTest.name][\"second\"].prop == \"my_2nd_prop\"      assert Config.sections[SectionForTest.name][\"second\"].foo is None      assert myFirstSection.attribute == \"my_attribute\"      assert myFirstSection.prop == \"my_prop\"      assert myFirstSection.foo == \"bar\"      assert myNewSection.attribute == \"my_2nd_attribute\"      assert myNewSection.prop == \"my_2nd_prop\"      assert myNewSection.foo is None      assert my2ndSection.attribute == \"my_2nd_attribute\"      assert my2ndSection.prop == \"my_2nd_prop\"      assert my2ndSection.foo is None      def test_block_registration():      myUniqueSection = Config.configure_unique_section_for_tests(attribute=\"my_unique_attribute\", prop=\"my_unique_prop\")      mySection = Config.configure_section_for_tests(id=\"section_id\", attribute=\"my_attribute\", prop=\"my_prop\", foo=\"bar\")        Config.block_update()        with pytest.raises(ConfigurationUpdateBlocked):          Config.configure_unique_section_for_tests(attribute=\"my_new_unique_attribute\", prop=\"my_new_unique_prop\")        with pytest.raises(ConfigurationUpdateBlocked):          Config.configure_section_for_tests(id=\"new\", attribute=\"my_attribute\", prop=\"my_prop\", foo=\"bar\")        with pytest.raises(ConfigurationUpdateBlocked):          myUniqueSection.attribute = \"foo\"        with pytest.raises(ConfigurationUpdateBlocked):          myUniqueSection.properties = {\"foo\": \"bar\"}        # myUniqueSection stay the same      assert myUniqueSection.attribute == \"my_unique_attribute\"      assert myUniqueSection.properties == {\"prop\": \"my_unique_prop\"}        with pytest.raises(ConfigurationUpdateBlocked):          mySection.attribute = \"foo\"        with pytest.raises(ConfigurationUpdateBlocked):          mySection.properties = {\"foo\": \"foo\"}        # mySection stay the same      assert mySection.attribute == \"my_attribute\"      assert mySection.properties == {\"prop\": \"my_prop\", \"foo\": \"bar\", \"prop_int\": 0} "}
{"text": "import pytest    from src.taipy.config.config import Config  from src.taipy.config.section import Section  from tests.config.utils.named_temporary_file import NamedTemporaryFile  from tests.config.utils.section_for_tests import SectionForTest  from tests.config.utils.section_of_sections_list_for_tests import SectionOfSectionsListForTest      @pytest.fixture  def _init_list_section_for_test():      Config._register_default(SectionOfSectionsListForTest(Section._DEFAULT_KEY, [], prop=\"default_prop\", prop_int=0))      Config.configure_list_section_for_tests = SectionOfSectionsListForTest._configure      Config.list_section_name = Config.sections[SectionOfSectionsListForTest.name]      def test_applied_config_compilation_does_not_change_other_configs():      assert len(Config._default_config._unique_sections) == 1      assert Config._default_config._unique_sections[\"unique_section_name\"] is not None      assert Config._default_config._unique_sections[\"unique_section_name\"].attribute == \"default_attribute\"      assert Config._default_config._unique_sections[\"unique_section_name\"].prop is None      assert len(Config._python_config._unique_sections) == 0      assert len(Config._file_config._unique_sections) == 0      assert len(Config._env_file_config._unique_sections) == 0      assert len(Config._applied_config._unique_sections) == 1      assert Config._applied_config._unique_sections[\"unique_section_name\"] is not None      assert Config._applied_config._unique_sections[\"unique_section_name\"].attribute == \"default_attribute\"      assert Config._applied_config._unique_sections[\"unique_section_name\"].prop is None      assert len(Config.unique_sections) == 1      assert Config.unique_sections[\"unique_section_name\"] is not None      assert Config.unique_sections[\"unique_section_name\"].attribute == \"default_attribute\"      assert Config.unique_sections[\"unique_section_name\"].prop is None      assert (          Config._applied_config._unique_sections[\"unique_section_name\"]          is not Config._default_config._unique_sections[\"unique_section_name\"]      )        Config.configure_unique_section_for_tests(\"qwe\", prop=\"rty\")        assert len(Config._default_config._unique_sections) == 1      assert Config._default_config._unique_sections[\"unique_section_name\"] is not None      assert Config._default_config._unique_sections[\"unique_section_name\"].attribute == \"default_attribute\"      assert Config._default_config._unique_sections[\"unique_section_name\"].prop is None      assert len(Config._python_config._unique_sections) == 1      assert Config._python_config._unique_sections[\"unique_section_name\"] is not None      assert Config._python_config._unique_sections[\"unique_section_name\"].attribute == \"qwe\"      assert Config._python_config._unique_sections[\"unique_section_name\"].prop == \"rty\"      assert (          Config._python_config._unique_sections[\"unique_section_name\"]          != Config._default_config._unique_sections[\"unique_section_name\"]      )      assert len(Config._file_config._unique_sections) == 0      assert len(Config._env_file_config._unique_sections) == 0      assert len(Config._applied_config._unique_sections) == 1      assert Config._applied_config._unique_sections[\"unique_section_name\"] is not None      assert Config._applied_config._unique_sections[\"unique_section_name\"].attribute == \"qwe\"      assert Config._applied_config._unique_sections[\"unique_section_name\"].prop == \"rty\"      assert (          Config._python_config._unique_sections[\"unique_section_name\"]          != Config._applied_config._unique_sections[\"unique_section_name\"]      )      assert (          Config._default_config._unique_sections[\"unique_section_name\"]          != Config._applied_config._unique_sections[\"unique_section_name\"]      )      assert len(Config.unique_sections) == 1      assert Config.unique_sections[\"unique_section_name\"] is not None      assert Config.unique_sections[\"unique_section_name\"].attribute == \"qwe\"      assert Config.unique_sections[\"unique_section_name\"].prop == \"rty\"      def test_nested_section_instance_in_python(_init_list_section_for_test):      s1_cfg = Config.configure_section_for_tests(\"s1\", attribute=\"foo\")      s2_cfg = Config.configure_section_for_tests(\"s2\", attribute=\"bar\")      ss_cfg = Config.configure_list_section_for_tests(\"ss\", attribute=\"foo\", sections_list=[s1_cfg, s2_cfg])        s1_config_applied_instance = Config.section_name[\"s1\"]      s1_config_python_instance = Config._python_config._sections[SectionForTest.name][\"s1\"]        s2_config_applied_instance = Config.section_name[\"s2\"]      s2_config_python_instance = Config._python_config._sections[SectionForTest.name][\"s2\"]        assert ss_cfg.sections_list[0] is s1_config_applied_instance      assert ss_cfg.sections_list[0] is not s1_config_python_instance      assert ss_cfg.sections_list[1] is s2_config_applied_instance      assert ss_cfg.sections_list[1] is not s2_config_python_instance      def _configure_in_toml():      return NamedTemporaryFile(          content=\"\"\"  [TAIPY]    [section_name.s1]  attribute = \"foo\"    [section_name.s2]  attribute = \"bar\"    [list_section_name.ss]  sections_list = [ \"foo\", \"s1:SECTION\", \"s2:SECTION\"]      \"\"\"      )      def test_nested_section_instance_load_toml(_init_list_section_for_test):      toml_config = _configure_in_toml()      Config.load(toml_config)        s1_config_applied_instance = Config.section_name[\"s1\"]      s1_config_python_instance = Config._python_config._sections[SectionForTest.name][\"s1\"]        s2_config_applied_instance = Config.section_name[\"s2\"]      s2_config_python_instance = Config._python_config._sections[SectionForTest.name][\"s2\"]        ss_cfg = Config.list_section_name[\"ss\"]        assert ss_cfg.sections_list[0] == \"foo\"      assert ss_cfg.sections_list[1] is s1_config_applied_instance      assert ss_cfg.sections_list[1] is not s1_config_python_instance      assert ss_cfg.sections_list[2] is s2_config_applied_instance      assert ss_cfg.sections_list[2] is not s2_config_python_instance      def test_nested_section_instance_override_toml(_init_list_section_for_test):      toml_config = _configure_in_toml()      Config.override(toml_config)        s1_config_applied_instance = Config.section_name[\"s1\"]      s1_config_python_instance = Config._file_config._sections[SectionForTest.name][\"s1\"]        s2_config_applied_instance = Config.section_name[\"s2\"]      s2_config_python_instance = Config._file_config._sections[SectionForTest.name][\"s2\"]        ss_cfg = Config.list_section_name[\"ss\"]        assert ss_cfg.sections_list[0] == \"foo\"      assert ss_cfg.sections_list[1] is s1_config_applied_instance      assert ss_cfg.sections_list[1] is not s1_config_python_instance      assert ss_cfg.sections_list[2] is s2_config_applied_instance      assert ss_cfg.sections_list[1] is not s2_config_python_instance "}
{"text": "import datetime  import json  import os  from unittest import mock    from src.taipy.config import Config  from src.taipy.config._serializer._json_serializer import _JsonSerializer  from src.taipy.config.common.frequency import Frequency  from src.taipy.config.common.scope import Scope  from tests.config.utils.named_temporary_file import NamedTemporaryFile  from tests.config.utils.section_for_tests import SectionForTest  from tests.config.utils.unique_section_for_tests import UniqueSectionForTest      def add(a, b):      return a + b      class CustomClass:      a = None      b = None      class CustomEncoder(json.JSONEncoder):      def default(self, o):          if isinstance(o, datetime):              result = {\"__type__\": \"Datetime\", \"__value__\": o.isoformat()}          else:              result = json.JSONEncoder.default(self, o)          return result      class CustomDecoder(json.JSONDecoder):      def __init__(self, *args, **kwargs):          json.JSONDecoder.__init__(self, object_hook=self.object_hook, *args, **kwargs)        def object_hook(self, source):          if source.get(\"__type__\") == \"Datetime\":              return datetime.fromisoformat(source.get(\"__value__\"))          else:              return source      def test_write_toml_configuration_file():      expected_toml_config = \"\"\"  [TAIPY]    [unique_section_name]  attribute = \"my_attribute\"  prop = \"my_prop\"  prop_int = \"1:int\"  prop_bool = \"False:bool\"  prop_list = [ \"p1\", \"1991-01-01T00:00:00:datetime\", \"1d0h0m0s:timedelta\",]  prop_scope = \"SCENARIO:SCOPE\"  prop_freq = \"QUARTERLY:FREQUENCY\"  baz = \"ENV[QUX]\"  quux = \"ENV[QUUZ]:bool\"  corge = [ \"grault\", \"ENV[GARPLY]\", \"ENV[WALDO]:int\", \"3.0:float\",]    [section_name.default]  attribute = \"default_attribute\"  prop = \"default_prop\"  prop_int = \"0:int\"    [section_name.my_id]  attribute = \"my_attribute\"  prop = \"default_prop\"  prop_int = \"1:int\"  prop_bool = \"False:bool\"  prop_list = [ \"unique_section_name:SECTION\",]  prop_scope = \"SCENARIO\"  baz = \"ENV[QUX]\"      \"\"\".strip()      tf = NamedTemporaryFile()      with mock.patch.dict(          os.environ, {\"FOO\": \"in_memory\", \"QUX\": \"qux\", \"QUUZ\": \"true\", \"GARPLY\": \"garply\", \"WALDO\": \"17\"}      ):          unique_section = Config.configure_unique_section_for_tests(              attribute=\"my_attribute\",              prop=\"my_prop\",              prop_int=1,              prop_bool=False,              prop_list=[\"p1\", datetime.datetime(1991, 1, 1), datetime.timedelta(days=1)],              prop_scope=Scope.SCENARIO,              prop_freq=Frequency.QUARTERLY,              baz=\"ENV[QUX]\",              quux=\"ENV[QUUZ]:bool\",              corge=(\"grault\", \"ENV[GARPLY]\", \"ENV[WALDO]:int\", 3.0),          )          Config.configure_section_for_tests(              \"my_id\",              \"my_attribute\",              prop_int=1,              prop_bool=False,              prop_list=[unique_section],              prop_scope=\"SCENARIO\",              baz=\"ENV[QUX]\",          )            Config.backup(tf.filename)          actual_config = tf.read().strip()          assert actual_config == expected_toml_config      def test_read_toml_configuration_file():      toml_config = \"\"\"  [TAIPY]  foo = \"bar\"    [unique_section_name]  attribute = \"my_attribute\"  prop = \"my_prop\"  prop_int = \"1:int\"  prop_bool = \"False:bool\"  prop_list = [ \"p1\", \"1991-01-01T00:00:00:datetime\", \"1d0h0m0s:timedelta\",]  prop_scope = \"SCENARIO:SCOPE\"  prop_freq = \"QUARTERLY:FREQUENCY\"  baz = \"ENV[QUX]\"  quux = \"ENV[QUUZ]:bool\"  corge = [ \"grault\", \"ENV[GARPLY]\", \"ENV[WALDO]:int\", \"3.0:float\",]    [TAIPY.custom_properties]  bar = \"baz\"    [section_name.default]  attribute = \"default_attribute\"  prop = \"default_prop\"  prop_int = \"0:int\"    [section_name.my_id]  attribute = \"my_attribute\"  prop = \"default_prop\"  prop_int = \"1:int\"  prop_bool = \"False:bool\"  prop_list = [ \"unique_section_name\", \"section_name.my_id\",]  prop_scope = \"SCENARIO:SCOPE\"  baz = \"ENV[QUX]\"      \"\"\".strip()      tf = NamedTemporaryFile(toml_config)      with mock.patch.dict(          os.environ, {\"FOO\": \"in_memory\", \"QUX\": \"qux\", \"QUUZ\": \"true\", \"GARPLY\": \"garply\", \"WALDO\": \"17\"}      ):          Config.override(tf.filename)            assert Config.global_config.foo == \"bar\"          assert Config.global_config.custom_properties.get(\"bar\") == \"baz\"            assert Config.unique_sections is not None          assert Config.unique_sections[UniqueSectionForTest.name] is not None          assert Config.unique_sections[UniqueSectionForTest.name].attribute == \"my_attribute\"          assert Config.unique_sections[UniqueSectionForTest.name].prop == \"my_prop\"          assert Config.unique_sections[UniqueSectionForTest.name].prop_int == 1          assert Config.unique_sections[UniqueSectionForTest.name].prop_bool is False          assert Config.unique_sections[UniqueSectionForTest.name].prop_list == [              \"p1\",              datetime.datetime(1991, 1, 1),              datetime.timedelta(days=1),          ]          assert Config.unique_sections[UniqueSectionForTest.name].prop_scope == Scope.SCENARIO          assert Config.unique_sections[UniqueSectionForTest.name].prop_freq == Frequency.QUARTERLY          assert Config.unique_sections[UniqueSectionForTest.name].baz == \"qux\"          assert Config.unique_sections[UniqueSectionForTest.name].quux is True          assert Config.unique_sections[UniqueSectionForTest.name].corge == [              \"grault\",              \"garply\",              17,              3.0,          ]            assert Config.sections is not None          assert len(Config.sections) == 1          assert Config.sections[SectionForTest.name] is not None          assert len(Config.sections[SectionForTest.name]) == 2          assert Config.sections[SectionForTest.name][\"default\"] is not None          assert Config.sections[SectionForTest.name][\"default\"].attribute == \"default_attribute\"          assert Config.sections[SectionForTest.name][\"default\"].prop == \"default_prop\"          assert Config.sections[SectionForTest.name][\"default\"].prop_int == 0          assert Config.sections[SectionForTest.name][\"my_id\"] is not None          assert Config.sections[SectionForTest.name][\"my_id\"].attribute == \"my_attribute\"          assert Config.sections[SectionForTest.name][\"my_id\"].prop == \"default_prop\"          assert Config.sections[SectionForTest.name][\"my_id\"].prop_int == 1          assert Config.sections[SectionForTest.name][\"my_id\"].prop_bool is False          assert Config.sections[SectionForTest.name][\"my_id\"].prop_list == [\"unique_section_name\", \"section_name.my_id\"]          assert Config.sections[SectionForTest.name][\"my_id\"].prop_scope == Scope.SCENARIO          assert Config.sections[SectionForTest.name][\"my_id\"].baz == \"qux\"            tf2 = NamedTemporaryFile()          Config.backup(tf2.filename)          actual_config_2 = tf2.read().strip()          assert actual_config_2 == toml_config      def test_read_write_toml_configuration_file_with_function_and_class():      expected_toml_config = \"\"\"  [TAIPY]    [unique_section_name]  attribute = \"my_attribute\"  prop = \"my_prop\"  prop_list = [ \"tests.config.test_section_serialization.CustomEncoder:class\", \"tests.config.test_section_serialization.CustomDecoder:class\",]    [section_name.default]  attribute = \"default_attribute\"  prop = \"default_prop\"  prop_int = \"0:int\"    [section_name.my_id]  attribute = \"my_attribute\"  prop = \"default_prop\"  prop_int = \"0:int\"  prop_fct_list = [ \"tests.config.test_section_serialization.add:function\",]  prop_class_list = [ \"tests.config.test_section_serialization.CustomClass:class\",]    [section_name.my_id_2]  attribute = \"my_attribute_2\"  prop = \"default_prop\"  prop_int = \"0:int\"  prop_fct_list = [ \"builtins.print:function\", \"builtins.pow:function\",]      \"\"\".strip()        tf = NamedTemporaryFile()      Config.configure_unique_section_for_tests(          attribute=\"my_attribute\",          prop=\"my_prop\",          prop_list=[CustomEncoder, CustomDecoder],      )      Config.configure_section_for_tests(          \"my_id\",          \"my_attribute\",          prop_fct_list=[add],          prop_class_list=[CustomClass],      )        Config.configure_section_for_tests(          \"my_id_2\",          \"my_attribute_2\",          prop_fct_list=[print, pow],      )        Config.backup(tf.filename)      actual_exported_toml = tf.read().strip()      assert actual_exported_toml == expected_toml_config        Config.override(tf.filename)      tf2 = NamedTemporaryFile()      Config.backup(tf2.filename)        actual_exported_toml_2 = tf2.read().strip()      assert actual_exported_toml_2 == expected_toml_config      def test_write_json_configuration_file():      expected_json_config = \"\"\"  {  \"TAIPY\": {},  \"unique_section_name\": {  \"attribute\": \"my_attribute\",  \"prop\": \"my_prop\",  \"prop_int\": \"1:int\",  \"prop_bool\": \"False:bool\",  \"prop_list\": [  \"p1\",  \"1991-01-01T00:00:00:datetime\",  \"1d0h0m0s:timedelta\"  ],  \"prop_scope\": \"SCENARIO:SCOPE\",  \"prop_freq\": \"QUARTERLY:FREQUENCY\"  },  \"section_name\": {  \"default\": {  \"attribute\": \"default_attribute\",  \"prop\": \"default_prop\",  \"prop_int\": \"0:int\"  },  \"my_id\": {  \"attribute\": \"my_attribute\",  \"prop\": \"default_prop\",  \"prop_int\": \"1:int\",  \"prop_bool\": \"False:bool\",  \"prop_list\": [  \"unique_section_name:SECTION\"  ],  \"prop_scope\": \"SCENARIO\",  \"baz\": \"ENV[QUX]\"  }  }  }      \"\"\".strip()      tf = NamedTemporaryFile()      Config._serializer = _JsonSerializer()        unique_section = Config.configure_unique_section_for_tests(          attribute=\"my_attribute\",          prop=\"my_prop\",          prop_int=1,          prop_bool=False,          prop_list=[\"p1\", datetime.datetime(1991, 1, 1), datetime.timedelta(days=1)],          prop_scope=Scope.SCENARIO,          prop_freq=Frequency.QUARTERLY,      )      Config.configure_section_for_tests(          \"my_id\",          \"my_attribute\",          prop_int=1,          prop_bool=False,          prop_list=[unique_section],          prop_scope=\"SCENARIO\",          baz=\"ENV[QUX]\",      )      Config.backup(tf.filename)      actual_config = tf.read()      assert actual_config == expected_json_config      def test_read_json_configuration_file():      json_config = \"\"\"  {  \"TAIPY\": {  \"root_folder\": \"./taipy/\",  \"storage_folder\": \".data/\",  \"repository_type\": \"filesystem\"  },  \"unique_section_name\": {  \"attribute\": \"my_attribute\",  \"prop\": \"my_prop\",  \"prop_int\": \"1:int\",  \"prop_bool\": \"False:bool\",  \"prop_list\": [  \"p1\",  \"1991-01-01T00:00:00:datetime\",  \"1d0h0m0s:timedelta\"  ],  \"prop_scope\": \"SCENARIO:SCOPE\",  \"prop_freq\": \"QUARTERLY:FREQUENCY\"  },  \"section_name\": {  \"default\": {  \"attribute\": \"default_attribute\",  \"prop\": \"default_prop\",  \"prop_int\": \"0:int\"  },  \"my_id\": {  \"attribute\": \"my_attribute\",  \"prop\": \"default_prop\",  \"prop_int\": \"1:int\",  \"prop_bool\": \"False:bool\",  \"prop_list\": [  \"unique_section_name\"  ],  \"prop_scope\": \"SCENARIO\"  }  }  }      \"\"\".strip()      Config._serializer = _JsonSerializer()      tf = NamedTemporaryFile(json_config)        Config.override(tf.filename)        assert Config.unique_sections is not None      assert Config.unique_sections[UniqueSectionForTest.name] is not None      assert Config.unique_sections[UniqueSectionForTest.name].attribute == \"my_attribute\"      assert Config.unique_sections[UniqueSectionForTest.name].prop == \"my_prop\"      assert Config.unique_sections[UniqueSectionForTest.name].prop_int == 1      assert Config.unique_sections[UniqueSectionForTest.name].prop_bool is False      assert Config.unique_sections[UniqueSectionForTest.name].prop_list == [          \"p1\",          datetime.datetime(1991, 1, 1),          datetime.timedelta(days=1),      ]      assert Config.unique_sections[UniqueSectionForTest.name].prop_scope == Scope.SCENARIO      assert Config.unique_sections[UniqueSectionForTest.name].prop_freq == Frequency.QUARTERLY        assert Config.sections is not None      assert len(Config.sections) == 1      assert Config.sections[SectionForTest.name] is not None      assert len(Config.sections[SectionForTest.name]) == 2      assert Config.sections[SectionForTest.name][\"default\"] is not None      assert Config.sections[SectionForTest.name][\"default\"].attribute == \"default_attribute\"      assert Config.sections[SectionForTest.name][\"default\"].prop == \"default_prop\"      assert Config.sections[SectionForTest.name][\"default\"].prop_int == 0      assert Config.sections[SectionForTest.name][\"my_id\"] is not None      assert Config.sections[SectionForTest.name][\"my_id\"].attribute == \"my_attribute\"      assert Config.sections[SectionForTest.name][\"my_id\"].prop == \"default_prop\"      assert Config.sections[SectionForTest.name][\"my_id\"].prop_int == 1      assert Config.sections[SectionForTest.name][\"my_id\"].prop_bool is False      assert Config.sections[SectionForTest.name][\"my_id\"].prop_list == [\"unique_section_name\"]        tf2 = NamedTemporaryFile()      Config.backup(tf2.filename)      actual_config_2 = tf2.read().strip()      assert actual_config_2 == json_config      def test_read_write_json_configuration_file_with_function_and_class():      expected_json_config = \"\"\"  {  \"TAIPY\": {},  \"unique_section_name\": {  \"attribute\": \"my_attribute\",  \"prop\": \"my_prop\",  \"prop_list\": [  \"tests.config.test_section_serialization.CustomEncoder:class\",  \"tests.config.test_section_serialization.CustomDecoder:class\"  ]  },  \"section_name\": {  \"default\": {  \"attribute\": \"default_attribute\",  \"prop\": \"default_prop\",  \"prop_int\": \"0:int\"  },  \"my_id\": {  \"attribute\": \"my_attribute\",  \"prop\": \"default_prop\",  \"prop_int\": \"0:int\",  \"prop_fct_list\": [  \"tests.config.test_section_serialization.add:function\"  ],  \"prop_class_list\": [  \"tests.config.test_section_serialization.CustomClass:class\"  ]  },  \"my_id_2\": {  \"attribute\": \"my_attribute_2\",  \"prop\": \"default_prop\",  \"prop_int\": \"0:int\",  \"prop_fct_list\": [  \"builtins.print:function\",  \"builtins.pow:function\"  ]  }  }  }      \"\"\".strip()        Config._serializer = _JsonSerializer()      tf = NamedTemporaryFile()      Config.configure_unique_section_for_tests(          attribute=\"my_attribute\",          prop=\"my_prop\",          prop_list=[CustomEncoder, CustomDecoder],      )      Config.configure_section_for_tests(          \"my_id\",          \"my_attribute\",          prop_fct_list=[add],          prop_class_list=[CustomClass],      )      Config.configure_section_for_tests(          \"my_id_2\",          \"my_attribute_2\",          prop_fct_list=[print, pow],      )        Config.backup(tf.filename)      actual_exported_json = tf.read().strip()      assert actual_exported_json == expected_json_config        Config.override(tf.filename)      tf2 = NamedTemporaryFile()      Config.backup(tf2.filename)        actual_exported_json_2 = tf2.read().strip()      assert actual_exported_json_2 == expected_json_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 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 datetime  import os  from unittest import mock    import pytest    from src.taipy.config.common.frequency import Frequency  from src.taipy.config.common.scope import Scope  from src.taipy.config.common._template_handler import _TemplateHandler  from src.taipy.config.exceptions.exceptions import InconsistentEnvVariableError      def test_replace_if_template():      assert_does_not_change(\"123\")      assert_does_not_change(\"foo\")      assert_does_not_change(\"_foo\")      assert_does_not_change(\"_foo_\")      assert_does_not_change(\"foo_\")      assert_does_not_change(\"foo\")      assert_does_not_change(\"foo_1\")      assert_does_not_change(\"1foo_1\")      assert_does_not_change(\"env(foo)\")      assert_does_not_change(\"env<foo>\")      assert_does_not_change(\"env[foo]\")      assert_does_not_change(\"Env[foo]\")      assert_does_not_change(\"ENV[1foo]\")        assert_does_not_change(\"123:bool\")      assert_does_not_change(\"foo:bool\")      assert_does_not_change(\"_foo:bool\")      assert_does_not_change(\"_foo_:bool\")      assert_does_not_change(\"foo_:bool\")      assert_does_not_change(\"foo:bool\")      assert_does_not_change(\"foo_1:bool\")      assert_does_not_change(\"1foo_1:bool\")      assert_does_not_change(\"env(foo):bool\")      assert_does_not_change(\"env<foo>:bool\")      assert_does_not_change(\"env[foo]:bool\")      assert_does_not_change(\"Env[foo]:bool\")      assert_does_not_change(\"ENV[1foo]:bool\")        assert_does_not_change(\"ENV[foo]:\")      assert_does_not_change(\"ENV[_foo]:\")      assert_does_not_change(\"ENV[foo_]:\")      assert_does_not_change(\"ENV[foo0]:\")      assert_does_not_change(\"ENV[foo_0]:\")      assert_does_not_change(\"ENV[_foo_0]:\")        assert_does_not_change(\"ENV[foo]:foo\")      assert_does_not_change(\"ENV[_foo]:foo\")      assert_does_not_change(\"ENV[foo_]:foo\")      assert_does_not_change(\"ENV[foo0]:foo\")      assert_does_not_change(\"ENV[foo_0]:foo\")      assert_does_not_change(\"ENV[_foo_0]:foo\")        assert_does_replace(\"ENV[foo]\", \"foo\", \"VALUE\", str)      assert_does_replace(\"ENV[_foo]\", \"_foo\", \"VALUE\", str)      assert_does_replace(\"ENV[foo_]\", \"foo_\", \"VALUE\", str)      assert_does_replace(\"ENV[foo0]\", \"foo0\", \"VALUE\", str)      assert_does_replace(\"ENV[foo_0]\", \"foo_0\", \"VALUE\", str)      assert_does_replace(\"ENV[_foo_0]\", \"_foo_0\", \"VALUE\", str)        assert_does_replace(\"ENV[foo]:str\", \"foo\", \"VALUE\", str)      assert_does_replace(\"ENV[_foo]:str\", \"_foo\", \"VALUE\", str)      assert_does_replace(\"ENV[foo_]:str\", \"foo_\", \"VALUE\", str)      assert_does_replace(\"ENV[foo0]:str\", \"foo0\", \"VALUE\", str)      assert_does_replace(\"ENV[foo_0]:str\", \"foo_0\", \"VALUE\", str)      assert_does_replace(\"ENV[_foo_0]:str\", \"_foo_0\", \"VALUE\", str)        assert_does_replace(\"ENV[foo]:int\", \"foo\", \"1\", int)      assert_does_replace(\"ENV[_foo]:int\", \"_foo\", \"1\", int)      assert_does_replace(\"ENV[foo_]:int\", \"foo_\", \"1\", int)      assert_does_replace(\"ENV[foo0]:int\", \"foo0\", \"1\", int)      assert_does_replace(\"ENV[foo_0]:int\", \"foo_0\", \"1\", int)      assert_does_replace(\"ENV[_foo_0]:int\", \"_foo_0\", \"1\", int)        assert_does_replace(\"ENV[foo]:float\", \"foo\", \"1.\", float)      assert_does_replace(\"ENV[_foo]:float\", \"_foo\", \"1.\", float)      assert_does_replace(\"ENV[foo_]:float\", \"foo_\", \"1.\", float)      assert_does_replace(\"ENV[foo0]:float\", \"foo0\", \"1.\", float)      assert_does_replace(\"ENV[foo_0]:float\", \"foo_0\", \"1.\", float)      assert_does_replace(\"ENV[_foo_0]:float\", \"_foo_0\", \"1.\", float)        assert_does_replace(\"ENV[foo]:bool\", \"foo\", \"True\", bool)      assert_does_replace(\"ENV[_foo]:bool\", \"_foo\", \"True\", bool)      assert_does_replace(\"ENV[foo_]:bool\", \"foo_\", \"True\", bool)      assert_does_replace(\"ENV[foo0]:bool\", \"foo0\", \"True\", bool)      assert_does_replace(\"ENV[foo_0]:bool\", \"foo_0\", \"True\", bool)      assert_does_replace(\"ENV[_foo_0]:bool\", \"_foo_0\", \"True\", bool)      def assert_does_replace(template, env_variable_name, replaced_by, as_type):      with mock.patch.dict(os.environ, {env_variable_name: replaced_by}):          tpl = _TemplateHandler()          assert tpl._replace_templates(template) == as_type(replaced_by)      def assert_does_not_change(template):      tpl = _TemplateHandler()      assert tpl._replace_templates(template) == template      def test_replace_tuple_list_dict():      with mock.patch.dict(os.environ, {\"FOO\": \"true\", \"BAR\": \"3\", \"BAZ\": \"qux\"}):          tpl = _TemplateHandler()          now = datetime.datetime.now()          actual = tpl._replace_templates((\"ENV[FOO]:bool\", now, \"ENV[BAR]:int\", \"ENV[BAZ]\", \"quz\"))          assert actual == (True, now, 3, \"qux\", \"quz\")          actual = tpl._replace_templates((\"ENV[FOO]:bool\", now, \"ENV[BAR]:int\", \"ENV[BAZ]\", \"quz\"))          assert actual == (True, now, 3, \"qux\", \"quz\")      def test_to_bool():      with pytest.raises(InconsistentEnvVariableError):          _TemplateHandler._to_bool(\"okhds\")      with pytest.raises(InconsistentEnvVariableError):          _TemplateHandler._to_bool(\"no\")      with pytest.raises(InconsistentEnvVariableError):          _TemplateHandler._to_bool(\"tru\")      with pytest.raises(InconsistentEnvVariableError):          _TemplateHandler._to_bool(\"tru_e\")        assert _TemplateHandler._to_bool(\"true\")      assert _TemplateHandler._to_bool(\"True\")      assert _TemplateHandler._to_bool(\"TRUE\")      assert _TemplateHandler._to_bool(\"TruE\")      assert _TemplateHandler._to_bool(\"TrUE\")        assert not _TemplateHandler._to_bool(\"false\")      assert not _TemplateHandler._to_bool(\"False\")      assert not _TemplateHandler._to_bool(\"FALSE\")      assert not _TemplateHandler._to_bool(\"FalSE\")      assert not _TemplateHandler._to_bool(\"FalSe\")      def test_to_int():      with pytest.raises(InconsistentEnvVariableError):          _TemplateHandler._to_int(\"okhds\")      with pytest.raises(InconsistentEnvVariableError):          _TemplateHandler._to_int(\"_45\")      with pytest.raises(InconsistentEnvVariableError):          _TemplateHandler._to_int(\"12.5\")        assert 12 == _TemplateHandler._to_int(\"12\")      assert 0 == _TemplateHandler._to_int(\"0\")      assert -2 == _TemplateHandler._to_int(\"-2\")      assert 156165 == _TemplateHandler._to_int(\"156165\")      def test_to_float():      with pytest.raises(InconsistentEnvVariableError):          _TemplateHandler._to_float(\"okhds\")      with pytest.raises(InconsistentEnvVariableError):          _TemplateHandler._to_float(\"_45\")        assert 12.5 == _TemplateHandler._to_float(\"12.5\")      assert 2.0 == _TemplateHandler._to_float(\"2\")      assert 0.0 == _TemplateHandler._to_float(\"0\")      assert -2.1 == _TemplateHandler._to_float(\"-2.1\")      assert 156165.3 == _TemplateHandler._to_float(\"156165.3\")      def test_to_scope():      with pytest.raises(InconsistentEnvVariableError):          _TemplateHandler._to_scope(\"okhds\")      with pytest.raises(InconsistentEnvVariableError):          _TemplateHandler._to_scope(\"plop\")        assert Scope.GLOBAL == _TemplateHandler._to_scope(\"global\")      assert Scope.GLOBAL == _TemplateHandler._to_scope(\"GLOBAL\")      assert Scope.SCENARIO == _TemplateHandler._to_scope(\"SCENARIO\")      assert Scope.CYCLE == _TemplateHandler._to_scope(\"cycle\")      def test_to_frequency():      with pytest.raises(InconsistentEnvVariableError):          _TemplateHandler._to_frequency(\"okhds\")      with pytest.raises(InconsistentEnvVariableError):          _TemplateHandler._to_frequency(\"plop\")        assert Frequency.DAILY == _TemplateHandler._to_frequency(\"DAILY\")      assert Frequency.DAILY == _TemplateHandler._to_frequency(\"Daily\")      assert Frequency.WEEKLY == _TemplateHandler._to_frequency(\"weekly\")      assert Frequency.WEEKLY == _TemplateHandler._to_frequency(\"WEEKLY\")      assert Frequency.MONTHLY == _TemplateHandler._to_frequency(\"Monthly\")      assert Frequency.MONTHLY == _TemplateHandler._to_frequency(\"MONThLY\")      assert Frequency.QUARTERLY == _TemplateHandler._to_frequency(\"QuaRtERlY\")      assert Frequency.YEARLY == _TemplateHandler._to_frequency(\"Yearly\") "}
{"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 os  from typing import Dict    from ..logger._taipy_logger import _TaipyLogger  from ._config import _Config  from ._config_comparator._config_comparator import _ConfigComparator  from ._serializer._json_serializer import _JsonSerializer  from ._serializer._toml_serializer import _TomlSerializer  from .checker._checker import _Checker  from .checker.issue_collector import IssueCollector  from .common._classproperty import _Classproperty  from .common._config_blocker import _ConfigBlocker  from .global_app.global_app_config import GlobalAppConfig  from .section import Section  from .unique_section import UniqueSection      class Config:      \"\"\"Configuration singleton.\"\"\"        _ENVIRONMENT_VARIABLE_NAME_WITH_CONFIG_PATH = \"TAIPY_CONFIG_PATH\"      __logger = _TaipyLogger._get_logger()      _default_config = _Config._default_config()      _python_config = _Config()      _file_config = _Config()      _env_file_config = _Config()      _applied_config = _Config()      _collector = IssueCollector()      _serializer = _TomlSerializer()      __json_serializer = _JsonSerializer()      _comparator: _ConfigComparator = _ConfigComparator()        @_Classproperty      def unique_sections(cls) -> Dict[str, UniqueSection]:          \"\"\"Return all unique sections.\"\"\"          return cls._applied_config._unique_sections        @_Classproperty      def sections(cls) -> Dict[str, Dict[str, Section]]:          \"\"\"Return all non unique sections.\"\"\"          return cls._applied_config._sections        @_Classproperty      def global_config(cls) -> GlobalAppConfig:          \"\"\"Return configuration values related to the global application as a `GlobalAppConfig^`.\"\"\"          return cls._applied_config._global_config        @classmethod      @_ConfigBlocker._check()      def load(cls, filename):          \"\"\"Load a configuration file.            The current Python configuration is replaced and the Config compilation is triggered.            Parameters:              filename (Union[str, Path]): The path of the toml configuration file to load.          \"\"\"          cls.__logger.info(f\"Loading configuration. Filename: '{filename}'\")          cls._python_config = cls._serializer._read(filename)          cls._compile_configs()          cls.__logger.info(f\"Configuration '{filename}' successfully loaded.\")        @classmethod      def export(cls, filename):          \"\"\"Export a configuration.            The export is done in a toml file.            The exported configuration is taken from the Python code configuration.            Parameters:              filename (Union[str, Path]): The path of the file to export.          Note:              If *filename* already exists, it is overwritten.          \"\"\"          cls._serializer._write(cls._python_config, filename)        @classmethod      def backup(cls, filename):          \"\"\"Backup a configuration.            The backup is done in a toml file.            The backed up configuration is a compilation from the three possible methods to configure          the application: the Python code configuration, the file configuration and the environment          configuration.            Parameters:              filename (Union[str, Path]): The path of the file to export.          Note:              If *filename* already exists, it is overwritten.          \"\"\"          cls._serializer._write(cls._applied_config, filename)        @classmethod      @_ConfigBlocker._check()      def restore(cls, filename):          \"\"\"Restore a configuration file and replace the current applied configuration.            Parameters:              filename (Union[str, Path]): The path of the toml configuration file to load.          \"\"\"          cls.__logger.info(f\"Restoring configuration. Filename: '{filename}'\")          cls._applied_config = cls._serializer._read(filename)          cls.__logger.info(f\"Configuration '{filename}' successfully restored.\")        @classmethod      @_ConfigBlocker._check()      def override(cls, filename):          \"\"\"Load a configuration from a file and overrides the current config.            Parameters:              filename (Union[str, Path]): The path of the toml configuration file to load.          \"\"\"          cls.__logger.info(f\"Loading configuration. Filename: '{filename}'\")          cls._file_config = cls._serializer._read(filename)          cls.__logger.info(\"Overriding configuration.'\")          cls._compile_configs()          cls.__logger.info(f\"Configuration '{filename}' successfully loaded.\")        @classmethod      def block_update(cls):          \"\"\"Block update on the configuration signgleton.\"\"\"          _ConfigBlocker._block()        @classmethod      def unblock_update(cls):          \"\"\"Unblock update on the configuration signgleton.\"\"\"          _ConfigBlocker._unblock()        @classmethod      @_ConfigBlocker._check()      def configure_global_app(cls, **properties) -> GlobalAppConfig:          \"\"\"Configure the global application.            Parameters:              **properties (Dict[str, Any]): A dictionary of additional properties.          Returns:              The global application configuration.          \"\"\"          glob_cfg = GlobalAppConfig(**properties)          if cls._python_config._global_config is None:              cls._python_config._global_config = glob_cfg          else:              cls._python_config._global_config._update(glob_cfg._to_dict())          cls._compile_configs()          return cls._applied_config._global_config        @classmethod      def check(cls) -> IssueCollector:          \"\"\"Check configuration.            This method logs issue messages and returns an issue collector.            Returns:              Collector containing the info, warning and error issues.          \"\"\"          cls._collector = _Checker._check(cls._applied_config)          cls.__log_message(cls)          return cls._collector        @classmethod      @_ConfigBlocker._check()      def _register_default(cls, default_section: Section):          if isinstance(default_section, UniqueSection):              if cls._default_config._unique_sections.get(default_section.name, None):                  cls._default_config._unique_sections[default_section.name]._update(default_section._to_dict())              else:                  cls._default_config._unique_sections[default_section.name] = default_section          else:              if def_sections := cls._default_config._sections.get(default_section.name, None):                  def_sections[default_section.id] = default_section              else:                  cls._default_config._sections[default_section.name] = {default_section.id: default_section}          cls._serializer._section_class[default_section.name] = default_section.__class__  # type: ignore          cls.__json_serializer._section_class[default_section.name] = default_section.__class__  # type: ignore          cls._compile_configs()        @classmethod      @_ConfigBlocker._check()      def _register(cls, section):          if isinstance(section, UniqueSection):              if cls._python_config._unique_sections.get(section.name, None):                  cls._python_config._unique_sections[section.name]._update(section._to_dict())              else:                  cls._python_config._unique_sections[section.name] = section          else:              if sections := cls._python_config._sections.get(section.name, None):                  if sections.get(section.id, None):                      sections[section.id]._update(section._to_dict())                  else:                      sections[section.id] = section              else:                  cls._python_config._sections[section.name] = {section.id: section}          cls._serializer._section_class[section.name] = section.__class__          cls.__json_serializer._section_class[section.name] = section.__class__          cls._compile_configs()        @classmethod      def _override_env_file(cls):          if config_filename := os.environ.get(cls._ENVIRONMENT_VARIABLE_NAME_WITH_CONFIG_PATH):              cls.__logger.info(f\"Loading configuration provided by environment variable. Filename: '{config_filename}'\")              cls._env_file_config = cls._serializer._read(config_filename)              cls.__logger.info(f\"Configuration '{config_filename}' successfully loaded.\")        @classmethod      def _compile_configs(cls):          Config._override_env_file()          cls._applied_config._clean()          if cls._default_config:              cls._applied_config._update(cls._default_config)          if cls._python_config:              cls._applied_config._update(cls._python_config)          if cls._file_config:              cls._applied_config._update(cls._file_config)          if cls._env_file_config:              cls._applied_config._update(cls._env_file_config)        @classmethod      def __log_message(cls, config):          for issue in config._collector._warnings:              cls.__logger.warning(str(issue))          for issue in config._collector._infos:              cls.__logger.info(str(issue))          for issue in config._collector._errors:              cls.__logger.error(str(issue))          if len(config._collector._errors) != 0:              raise SystemExit(\"Configuration errors found. Please check the error log for more information.\")        @classmethod      def _to_json(cls, _config: _Config) -> str:          return cls.__json_serializer._serialize(_config)        @classmethod      def _from_json(cls, config_as_str: str) -> _Config:          return cls.__json_serializer._deserialize(config_as_str)      Config._override_env_file() "}
{"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 inspect  import re  import types  from abc import abstractmethod  from datetime import datetime, timedelta  from typing import Any, Dict, Optional    from .._config import _Config  from ..common._template_handler import _TemplateHandler  from ..common._validate_id import _validate_id  from ..common.frequency import Frequency  from ..common.scope import Scope  from ..exceptions.exceptions import LoadingError  from ..global_app.global_app_config import GlobalAppConfig  from ..section import Section  from ..unique_section import UniqueSection      class _BaseSerializer(object):      \"\"\"Base serializer class for taipy configuration.\"\"\"        _GLOBAL_NODE_NAME = \"TAIPY\"      _section_class = {_GLOBAL_NODE_NAME: GlobalAppConfig}        @classmethod      @abstractmethod      def _write(cls, configuration: _Config, filename: str):          raise NotImplementedError        @classmethod      def _str(cls, configuration: _Config):          config_as_dict = {cls._GLOBAL_NODE_NAME: configuration._global_config._to_dict()}          for u_sect_name, u_sect in configuration._unique_sections.items():              config_as_dict[u_sect_name] = u_sect._to_dict()          for sect_name, sections in configuration._sections.items():              config_as_dict[sect_name] = cls._to_dict(sections)          return cls._stringify(config_as_dict)        @classmethod      def _to_dict(cls, sections: Dict[str, Any]):          return {section_id: section._to_dict() for section_id, section in sections.items()}        @classmethod      def _stringify(cls, as_dict):          if as_dict is None:              return None          if isinstance(as_dict, Section):              return as_dict.id + \":SECTION\"          if isinstance(as_dict, Scope):              return as_dict.name + \":SCOPE\"          if isinstance(as_dict, Frequency):              return as_dict.name + \":FREQUENCY\"          if isinstance(as_dict, bool):              return str(as_dict) + \":bool\"          if isinstance(as_dict, int):              return str(as_dict) + \":int\"          if isinstance(as_dict, float):              return str(as_dict) + \":float\"          if isinstance(as_dict, datetime):              return as_dict.isoformat() + \":datetime\"          if isinstance(as_dict, timedelta):              return cls._timedelta_to_str(as_dict) + \":timedelta\"          if inspect.isfunction(as_dict) or isinstance(as_dict, types.BuiltinFunctionType):              return as_dict.__module__ + \".\" + as_dict.__name__ + \":function\"          if inspect.isclass(as_dict):              return as_dict.__module__ + \".\" + as_dict.__qualname__ + \":class\"          if isinstance(as_dict, dict):              return {str(key): cls._stringify(val) for key, val in as_dict.items()}          if isinstance(as_dict, list):              return [cls._stringify(val) for val in as_dict]          if isinstance(as_dict, tuple):              return [cls._stringify(val) for val in as_dict]          return as_dict        @staticmethod      def _extract_node(config_as_dict, cls_config, node, config: Optional[Any]) -> Dict[str, Section]:          res = {}          for key, value in config_as_dict.get(node, {}).items():  # my_task, {input=[], output=[my_data_node], ...}              key = _validate_id(key)              res[key] = cls_config._from_dict(value, key, config)  # if config is None else cls_config._from_dict(key,              # value, config)          return res        @classmethod      def _from_dict(cls, as_dict) -> _Config:          config = _Config()          config._global_config = GlobalAppConfig._from_dict(as_dict.get(cls._GLOBAL_NODE_NAME, {}))          for section_name, sect_as_dict in as_dict.items():              if section_class := cls._section_class.get(section_name, None):                  if issubclass(section_class, UniqueSection):                      config._unique_sections[section_name] = section_class._from_dict(                          sect_as_dict, None, None                      )  # type: ignore                  elif issubclass(section_class, Section):                      config._sections[section_name] = cls._extract_node(as_dict, section_class, section_name, config)          return config        @classmethod      def _pythonify(cls, val):          match = re.fullmatch(_TemplateHandler._PATTERN, str(val))          if not match:              if isinstance(val, str):                  TYPE_PATTERN = (                      r\"^(.+):(\\bbool\\b|\\bstr\\b|\\bint\\b|\\bfloat\\b|\\bdatetime\\b||\\btimedelta\\b|\"                      r\"\\bfunction\\b|\\bclass\\b|\\bSCOPE\\b|\\bFREQUENCY\\b|\\bSECTION\\b)?$\"                  )                  match = re.fullmatch(TYPE_PATTERN, str(val))                  if match:                      actual_val = match.group(1)                      dynamic_type = match.group(2)                      if dynamic_type == \"SECTION\":                          return actual_val                      if dynamic_type == \"FREQUENCY\":                          return Frequency[actual_val]                      if dynamic_type == \"SCOPE\":                          return Scope[actual_val]                      if dynamic_type == \"bool\":                          return _TemplateHandler._to_bool(actual_val)                      elif dynamic_type == \"int\":                          return _TemplateHandler._to_int(actual_val)                      elif dynamic_type == \"float\":                          return _TemplateHandler._to_float(actual_val)                      elif dynamic_type == \"datetime\":                          return _TemplateHandler._to_datetime(actual_val)                      elif dynamic_type == \"timedelta\":                          return _TemplateHandler._to_timedelta(actual_val)                      elif dynamic_type == \"function\":                          return _TemplateHandler._to_function(actual_val)                      elif dynamic_type == \"class\":                          return _TemplateHandler._to_class(actual_val)                      elif dynamic_type == \"str\":                          return actual_val                      else:                          error_msg = f\"Error loading toml configuration at {val}. {dynamic_type} type is not supported.\"                          raise LoadingError(error_msg)              if isinstance(val, dict):                  return {str(k): cls._pythonify(v) for k, v in val.items()}              if isinstance(val, list):                  return [cls._pythonify(v) for v in val]          return val        @classmethod      def _timedelta_to_str(cls, 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\"          ) "}
{"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": "import re  from typing import Dict, List, Set    from .._serializer._json_serializer import _JsonSerializer      class _ComparatorResult(dict):        ADDED_ITEMS_KEY = \"added_items\"      REMOVED_ITEMS_KEY = \"removed_items\"      MODIFIED_ITEMS_KEY = \"modified_items\"        CONFLICTED_SECTION_KEY = \"conflicted_sections\"      UNCONFLICTED_SECTION_KEY = \"unconflicted_sections\"        def __init__(self, unconflicted_sections: Set[str]):          super().__init__()            self._unconflicted_sections = unconflicted_sections        def _sort_by_section(self):          if self.get(self.CONFLICTED_SECTION_KEY):              for key in self[self.CONFLICTED_SECTION_KEY].keys():                  self[self.CONFLICTED_SECTION_KEY][key].sort(key=lambda x: x[0][0])            if self.get(self.UNCONFLICTED_SECTION_KEY):              for key in self[self.UNCONFLICTED_SECTION_KEY].keys():                  self[self.UNCONFLICTED_SECTION_KEY][key].sort(key=lambda x: x[0][0])        def _check_added_items(self, config_deepdiff, new_json_config):          if dictionary_item_added := config_deepdiff.get(\"dictionary_item_added\"):              for item_added in dictionary_item_added:                  section_name, config_id, attribute = self.__get_changed_entity_attribute(item_added)                  diff_sections = self.__get_section(section_name)                    if attribute:                      value_added = new_json_config[section_name][config_id][attribute]                  elif config_id:                      value_added = new_json_config[section_name][config_id]                  else:                      value_added = new_json_config[section_name]                    section_name = self.__rename_global_node_name(section_name)                  self.__create_or_append_list(                      diff_sections,                      self.ADDED_ITEMS_KEY,                      ((section_name, config_id, attribute), (value_added)),                  )        def _check_removed_items(self, config_deepdiff, old_json_config):          if dictionary_item_removed := config_deepdiff.get(\"dictionary_item_removed\"):              for item_removed in dictionary_item_removed:                  section_name, config_id, attribute = self.__get_changed_entity_attribute(item_removed)                  diff_sections = self.__get_section(section_name)                    if attribute:                      value_removed = old_json_config[section_name][config_id][attribute]                  elif config_id:                      value_removed = old_json_config[section_name][config_id]                  else:                      value_removed = old_json_config[section_name]                    section_name = self.__rename_global_node_name(section_name)                  self.__create_or_append_list(                      diff_sections,                      self.REMOVED_ITEMS_KEY,                      ((section_name, config_id, attribute), (value_removed)),                  )        def _check_modified_items(self, config_deepdiff, old_json_config, new_json_config):          if values_changed := config_deepdiff.get(\"values_changed\"):              for item_changed, value_changed in values_changed.items():                  section_name, config_id, attribute = self.__get_changed_entity_attribute(item_changed)                  diff_sections = self.__get_section(section_name)                    section_name = self.__rename_global_node_name(section_name)                  self.__create_or_append_list(                      diff_sections,                      self.MODIFIED_ITEMS_KEY,                      ((section_name, config_id, attribute), (value_changed[\"old_value\"], value_changed[\"new_value\"])),                  )            # Iterable item added will be considered a modified item          if iterable_item_added := config_deepdiff.get(\"iterable_item_added\"):              self.__check_modified_iterable(iterable_item_added, old_json_config, new_json_config)            # Iterable item removed will be considered a modified item          if iterable_item_removed := config_deepdiff.get(\"iterable_item_removed\"):              self.__check_modified_iterable(iterable_item_removed, old_json_config, new_json_config)        def __check_modified_iterable(self, iterable_items, old_json_config, new_json_config):          for item in iterable_items:              section_name, config_id, attribute = self.__get_changed_entity_attribute(item)              diff_sections = self.__get_section(section_name)                if attribute:                  new_value = new_json_config[section_name][config_id][attribute]                  old_value = old_json_config[section_name][config_id][attribute]              else:                  new_value = new_json_config[section_name][config_id]                  old_value = old_json_config[section_name][config_id]                section_name = self.__rename_global_node_name(section_name)              modified_value = ((section_name, config_id, attribute), (old_value, new_value))                if (                  not diff_sections.get(self.MODIFIED_ITEMS_KEY)                  or modified_value not in diff_sections[self.MODIFIED_ITEMS_KEY]              ):                  self.__create_or_append_list(                      diff_sections,                      self.MODIFIED_ITEMS_KEY,                      modified_value,                  )        def __get_section(self, section_name: str) -> Dict[str, List]:          if section_name in self._unconflicted_sections:              if not self.get(self.UNCONFLICTED_SECTION_KEY):                  self[self.UNCONFLICTED_SECTION_KEY] = {}              return self[self.UNCONFLICTED_SECTION_KEY]            if not self.get(self.CONFLICTED_SECTION_KEY):              self[self.CONFLICTED_SECTION_KEY] = {}          return self[self.CONFLICTED_SECTION_KEY]        def __create_or_append_list(self, diff_dict, key, value):          if diff_dict.get(key):              diff_dict[key].append(value)          else:              diff_dict[key] = [value]        def __get_changed_entity_attribute(self, attribute_bracket_notation):          \"\"\"Split the section name, the config id (if exists), and the attribute name (if exists)          from JSON bracket notation.          \"\"\"          try:              section_name, config_id, attribute = re.findall(r\"\\[\\'(.*?)\\'\\]\", attribute_bracket_notation)          except ValueError:              try:                  section_name, config_id = re.findall(r\"\\[\\'(.*?)\\'\\]\", attribute_bracket_notation)                  attribute = None              except ValueError:                  section_name = re.findall(r\"\\[\\'(.*?)\\'\\]\", attribute_bracket_notation)[0]                  config_id = None                  attribute = None            return section_name, config_id, attribute        def __rename_global_node_name(self, node_name):          if node_name == _JsonSerializer._GLOBAL_NODE_NAME:              return \"Global Configuration\"          return node_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 json  from copy import copy  from typing import Optional, Set, Union    from deepdiff import DeepDiff    from ...logger._taipy_logger import _TaipyLogger  from .._config import _Config  from .._serializer._json_serializer import _JsonSerializer  from ._comparator_result import _ComparatorResult      class _ConfigComparator:      def __init__(self):          self._unconflicted_sections: Set[str] = set()          self.__logger = _TaipyLogger._get_logger()        def _add_unconflicted_section(self, section_name: Union[str, Set[str]]):          if isinstance(section_name, str):              section_name = {section_name}            self._unconflicted_sections.update(section_name)        def _find_conflict_config(          self,          old_config: _Config,          new_config: _Config,          old_version_number: Optional[str] = None,          new_version_number: Optional[str] = None,      ):          \"\"\"Compare between 2 _Config object to check for compatibility.            Args:              old_config (_Config): The old _Config.              new_config (_Config): The new _Config.              old_version_number (str, optional): The old version number for logging. Defaults to None.              new_version_number (str, optional): The new version number for logging. Defaults to None.            Returns:              _ComparatorResult: Return a _ComparatorResult dictionary with the following format:          ```python          {              \"added_items\": [                  ((section_name_1, config_id_1, attribute_1), added_object_1),                  ((section_name_2, config_id_2, attribute_2), added_object_2),              ],              \"removed_items\": [                  ((section_name_1, config_id_1, attribute_1), removed_object_1),                  ((section_name_2, config_id_2, attribute_2), removed_object_2),              ],              \"modified_items\": [                  ((section_name_1, config_id_1, attribute_1), (old_value_1, new_value_1)),                  ((section_name_2, config_id_2, attribute_2), (old_value_2, new_value_2)),              ],          }          ```          \"\"\"          comparator_result = self.__get_config_diff(old_config, new_config)          self.__log_find_conflict_message(comparator_result, old_version_number, new_version_number)          return comparator_result        def _compare(          self,          config_1: _Config,          config_2: _Config,          version_number_1: str,          version_number_2: str,      ):          \"\"\"Compare between 2 _Config object to check for compatibility.            Args:              config_1 (_Config): The old _Config.              config_2 (_Config): The new _Config.              version_number_1 (str): The old version number for logging.              version_number_2 (str): The new version number for logging.          \"\"\"          comparator_result = self.__get_config_diff(config_1, config_2)          self.__log_comparison_message(comparator_result, version_number_1, version_number_2)            return comparator_result        def __get_config_diff(self, config_1, config_2):          json_config_1 = json.loads(_JsonSerializer._serialize(config_1))          json_config_2 = json.loads(_JsonSerializer._serialize(config_2))            config_deepdiff = DeepDiff(json_config_1, json_config_2, ignore_order=True)            comparator_result = _ComparatorResult(copy(self._unconflicted_sections))            comparator_result._check_added_items(config_deepdiff, json_config_2)          comparator_result._check_removed_items(config_deepdiff, json_config_1)          comparator_result._check_modified_items(config_deepdiff, json_config_1, json_config_2)          comparator_result._sort_by_section()            return comparator_result        def __log_comparison_message(          self,          comparator_result: _ComparatorResult,          version_number_1: str,          version_number_2: str,      ):          config_str_1 = f\"version {version_number_1} Configuration\"          config_str_2 = f\"version {version_number_2} Configuration\"            diff_messages = []          for _, sections in comparator_result.items():              diff_messages = self.__get_messages(sections)            if diff_messages:              self.__logger.info(                  f\"Differences between {config_str_1} and {config_str_2}:\\n\\t\" + \"\\n\\t\".join(diff_messages)              )          else:              self.__logger.info(f\"There is no difference between {config_str_1} and {config_str_2}.\")        def __log_find_conflict_message(          self,          comparator_result: _ComparatorResult,          old_version_number: Optional[str] = None,          new_version_number: Optional[str] = None,      ):          old_config_str = (              f\"configuration for version {old_version_number}\" if old_version_number else \"current configuration\"          )          new_config_str = (              f\"configuration for version {new_version_number}\" if new_version_number else \"current configuration\"          )            if unconflicted_sections := comparator_result.get(_ComparatorResult.UNCONFLICTED_SECTION_KEY):              unconflicted_messages = self.__get_messages(unconflicted_sections)              self.__logger.info(                  f\"There are non-conflicting changes between the {old_config_str}\"                  f\" and the {new_config_str}:\\n\\t\" + \"\\n\\t\".join(unconflicted_messages)              )            if conflicted_sections := comparator_result.get(_ComparatorResult.CONFLICTED_SECTION_KEY):              conflicted_messages = self.__get_messages(conflicted_sections)              self.__logger.error(                  f\"The {old_config_str} conflicts with the {new_config_str}:\\n\\t\" + \"\\n\\t\".join(conflicted_messages)              )        def __get_messages(self, diff_sections):          dq = '\"'          messages = []            if added_items := diff_sections.get(_ComparatorResult.ADDED_ITEMS_KEY):              for diff in added_items:                  ((section_name, config_id, attribute), added_object) = diff                  messages.append(                      f\"{section_name} {dq}{config_id}{dq} \"                      f\"{f'has attribute {dq}{attribute}{dq}' if attribute else 'was'} added: {added_object}\"                  )            if removed_items := diff_sections.get(_ComparatorResult.REMOVED_ITEMS_KEY):              for diff in removed_items:                  ((section_name, config_id, attribute), removed_object) = diff                  messages.append(                      f\"{section_name} {dq}{config_id}{dq} \"                      f\"{f'has attribute {dq}{attribute}{dq}' if attribute else 'was'} removed\"                  )            if modified_items := diff_sections.get(_ComparatorResult.MODIFIED_ITEMS_KEY):              for diff in modified_items:                  ((section_name, config_id, attribute), (old_value, new_value)) = diff                  messages.append(                      f\"{section_name} {dq}{config_id}{dq} \"                      f\"{f'has attribute {dq}{attribute}{dq}' if attribute else 'was'} modified: \"                      f\"{old_value} -> {new_value}\"                  )            return messages "}
{"text": "#  # Licensed under the Apache License, Version 2.0 (the \"License\"); you may not use this file except in compliance with  # the License. You may obtain a copy of the License at  #  #        http://www.apache.org/licenses/LICENSE-2.0  #  # Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on  # an \"AS IS\" BASIS, WITHOUT 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": "import os    import pytest  from cookiecutter.exceptions import FailedHookException  from cookiecutter.main import cookiecutter    from .utils import _run_template      def test_default_answer(tmpdir):      cookiecutter(          template=\"src/taipy/templates/default\",          output_dir=str(tmpdir),          no_input=True,      )        assert os.listdir(tmpdir) == [\"taipy_application\"]      assert (          os.listdir(os.path.join(tmpdir, \"taipy_application\")).sort() == [\"requirements.txt\", \"main.py\", \"images\"].sort()      )      with open(os.path.join(tmpdir, \"taipy_application\", \"requirements.txt\")) as requirements_file:          # Assert post_gen_project hook is successful          assert \"taipy==\" in requirements_file.read()        oldpwd = os.getcwd()      os.chdir(os.path.join(tmpdir, \"taipy_application\"))      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\")      def test_main_file_with_and_without_extension(tmpdir):      cookiecutter(          template=\"src/taipy/templates/default\",          output_dir=str(tmpdir),          no_input=True,          extra_context={              \"Application main Python file\": \"app.py\",          },      )      assert (          os.listdir(os.path.join(tmpdir, \"taipy_application\")).sort() == [\"requirements.txt\", \"app.py\", \"images\"].sort()      )        cookiecutter(          template=\"src/taipy/templates/default\",          output_dir=str(tmpdir),          no_input=True,          extra_context={              \"Application root folder name\": \"foo_app\",              \"Application main Python file\": \"app\",          },      )      assert os.listdir(os.path.join(tmpdir, \"foo_app\")).sort() == [\"requirements.txt\", \"app.py\", \"images\"].sort()      def test_with_core_service(tmpdir):      cookiecutter(          template=\"src/taipy/templates/default\",          output_dir=str(tmpdir),          no_input=True,          extra_context={              \"Does the application use scenario management or version management?\": \"y\",              \"Does the application use Rest API?\": \"no\",          },      )        assert (          os.listdir(os.path.join(tmpdir, \"taipy_application\")).sort()          == [\"requirements.txt\", \"main.py\", \"images\", \"configuration\", \"algorithms\"].sort()      )      with open(os.path.join(tmpdir, \"taipy_application\", \"main.py\")) as main_file:          assert \"core = Core()\" in main_file.read()        oldpwd = os.getcwd()      os.chdir(os.path.join(tmpdir, \"taipy_application\"))      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\")      assert \"[Taipy][INFO] Development mode: \" in str(stdout, \"utf-8\")      def test_with_rest_service(tmpdir):      cookiecutter(          template=\"src/taipy/templates/default\",          output_dir=str(tmpdir),          no_input=True,          extra_context={              \"Does the application use scenario management or version management?\": \"n\",              \"Does the application use Rest API?\": \"yes\",          },      )        assert (          os.listdir(os.path.join(tmpdir, \"taipy_application\")).sort() == [\"requirements.txt\", \"main.py\", \"images\"].sort()      )      with open(os.path.join(tmpdir, \"taipy_application\", \"main.py\")) as main_file:          assert \"rest = Rest()\" in main_file.read()        oldpwd = os.getcwd()      os.chdir(os.path.join(tmpdir, \"taipy_application\"))      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\")      assert \"[Taipy][INFO] Development mode: \" in str(stdout, \"utf-8\")      def test_with_both_core_rest_services(tmpdir):      cookiecutter(          template=\"src/taipy/templates/default\",          output_dir=str(tmpdir),          no_input=True,          extra_context={              \"Does the application use scenario management or version management?\": \"n\",              \"Does the application use Rest API?\": \"yes\",          },      )        assert (          os.listdir(os.path.join(tmpdir, \"taipy_application\")).sort()          == [\"requirements.txt\", \"main.py\", \"images\", \"configuration\", \"algorithms\"].sort()      )      with open(os.path.join(tmpdir, \"taipy_application\", \"main.py\")) as main_file:          assert \"rest = Rest()\" in main_file.read()          assert \"core = Core()\" not in main_file.read()        oldpwd = os.getcwd()      os.chdir(os.path.join(tmpdir, \"taipy_application\"))      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\")      assert \"[Taipy][INFO] Development mode: \" in str(stdout, \"utf-8\")      def test_multipage_gui_template(tmpdir):      cookiecutter(          template=\"src/taipy/templates/default\",          output_dir=str(tmpdir),          no_input=True,          extra_context={              \"Application root folder name\": \"foo_app\",              \"Page names in multi-page application?\": \"name_1 name_2 name_3\",          },      )        assert (          os.listdir(os.path.join(tmpdir, \"foo_app\")).sort() == [\"requirements.txt\", \"main.py\", \"pages\", \"images\"].sort()      )      assert (          os.listdir(os.path.join(tmpdir, \"foo_app\", \"pages\")).sort()          == [\"name_1\", \"name_2\", \"name_3\", \"root.md\", \"root.py\", \"__init__.py\"].sort()      )        oldpwd = os.getcwd()      os.chdir(os.path.join(tmpdir, \"foo_app\"))      stdout = _run_template(\"main.py\")      os.chdir(oldpwd)      assert \"[Taipy][INFO]  * Server starting on\" in str(stdout, \"utf-8\")      def test_multipage_gui_template_with_invalid_page_name(tmpdir, capfd):      with pytest.raises(FailedHookException):          cookiecutter(              template=\"src/taipy/templates/default\",              output_dir=str(tmpdir),              no_input=True,              extra_context={                  \"Application root folder name\": \"foo_app\",                  \"Page names in multi-page application?\": \"valid_var_name 1_invalid_var_name\",              },          )        _, stderr = capfd.readouterr()      assert 'Page name \"1_invalid_var_name\" is not a valid Python identifier' in stderr        assert not os.path.exists(os.path.join(tmpdir, \"foo_app\")) "}
{"text": "#  # Licensed under the Apache License, Version 2.0 (the \"License\"); you may not use this file except in compliance with  # the License. You may obtain a copy of the License at  #  #        http://www.apache.org/licenses/LICENSE-2.0  #  # Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on  # an \"AS IS\" BASIS, WITHOUT 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 shutil    import taipy      def handle_services(use_rest, use_core):      if use_core or use_rest:          # Write \"import taipy as tp\" at the third line of the import.txt file          with open(os.path.join(os.getcwd(), \"sections\", \"import.txt\"), \"r\") as import_file:              import_lines = import_file.readlines()              import_lines[0] = \"import taipy as tp\\n\" + import_lines[0] + \"\\n\"          with open(os.path.join(os.getcwd(), \"sections\", \"import.txt\"), \"w\") as import_file:              import_file.writelines(import_lines)        # Import the necessary services      if use_core and use_rest:          with open(os.path.join(os.getcwd(), \"sections\", \"import.txt\"), \"a\") as import_file:              import_file.write(\"from taipy import Core, Rest\\n\")      elif use_core:          with open(os.path.join(os.getcwd(), \"sections\", \"import.txt\"), \"a\") as import_file:              import_file.write(\"from taipy import Core\\n\")      elif use_rest:          with open(os.path.join(os.getcwd(), \"sections\", \"import.txt\"), \"a\") as import_file:              import_file.write(\"from taipy import Rest\\n\")        # Start the Rest service      if use_rest:          with open(os.path.join(os.getcwd(), \"sections\", \"main.txt\"), \"a\") as main_file:              main_file.write(\"    rest = Rest()\\n\")        if use_core:          # Create and submit the placeholder scenario          with open(os.path.join(os.getcwd(), \"sections\", \"main.txt\"), \"a\") as main_file:              main_file.write(\"    core = Core()\\n\")              main_file.write(\"    core.run()\\n\")              main_file.write(\"    # #############################################################################\\n\")              main_file.write(\"    # PLACEHOLDER: Create and submit your scenario here                           #\\n\")              main_file.write(\"    #                                                                             #\\n\")              main_file.write(\"    # Example:                                                                    #\\n\")              main_file.write(\"    # from configuration import scenario_config                                   #\\n\")              main_file.write(\"    # scenario = tp.create_scenario(scenario_config)                              #\\n\")              main_file.write(\"    # scenario.submit()                                                           #\\n\")              main_file.write(\"    # Comment, remove or replace the previous lines with your own use case        #\\n\")              main_file.write(\"    # #############################################################################\\n\")      else:          shutil.rmtree(os.path.join(os.getcwd(), \"algorithms\"))          shutil.rmtree(os.path.join(os.getcwd(), \"configuration\"))      def handle_run_service():      with open(os.path.join(os.getcwd(), \"sections\", \"main.txt\"), \"a+\") as main_file:          main_file.seek(0)          main_content = main_file.read()          # Run Rest service along with the GUI service          if \"rest = Rest()\" in main_content:              main_file.write('    tp.run(gui, rest, title=\"{{cookiecutter.__application_title}}\")\\n')          else:              main_file.write('    gui.run(title=\"{{cookiecutter.__application_title}}\")\\n')      def handle_single_page_app():      shutil.rmtree(os.path.join(os.getcwd(), \"pages\"))        with open(os.path.join(os.getcwd(), \"sections\", \"main.txt\"), \"a\") as main_file:          main_file.write(\"\\n\")          main_file.write(\"    gui = Gui(page=page)\\n\")        handle_run_service()        with open(os.path.join(os.getcwd(), \"sections\", \"page_content.txt\"), \"a\") as page_content_file:          page_content_file.write(              '''  page = \"\"\"  <center>  <|navbar|lov={[(\"home\", \"Homepage\")]}|>  </center>    \"\"\"  '''          )      def handle_multi_page_app(pages):      for page_name in pages:          os.mkdir(os.path.join(os.getcwd(), \"pages\", page_name))          with open(os.path.join(os.getcwd(), \"pages\", \"page_example\", \"page_example.md\"), \"r\") as page_md_file:              page_md_content = page_md_file.read()          page_md_content = page_md_content.replace(\"Page example\", page_name.replace(\"_\", \" \").title())          with open(os.path.join(os.getcwd(), \"pages\", page_name, page_name + \".md\"), \"w\") as page_md_file:              page_md_file.write(page_md_content)            with open(os.path.join(os.getcwd(), \"pages\", \"page_example\", \"page_example.py\"), \"r\") as page_content_file:              page_py_content = page_content_file.read()          page_py_content = page_py_content.replace(\"page_example\", page_name)          with open(os.path.join(os.getcwd(), \"pages\", page_name, page_name + \".py\"), \"w\") as page_content_file:              page_content_file.write(page_py_content)        with open(os.path.join(os.getcwd(), \"pages\", \"__init__.py\"), \"a\") as page_init_file:          for page_name in pages:              page_init_file.write(f\"from .{page_name}.{page_name} import {page_name}\\n\")        shutil.rmtree(os.path.join(os.getcwd(), \"pages\", \"page_example\"))        newline = \",\\n\\t\"      user_page_dict = newline.join(f'\"{page_name}\": {page_name}' for page_name in pages)      page_dict = \"\"\"  pages = {      \"/\": root_page,      {pages}  }  \"\"\"      with open(os.path.join(os.getcwd(), \"sections\", \"page_content.txt\"), \"a\") as page_content_file:          page_content_file.write(page_dict.replace(\"{pages}\", user_page_dict))        with open(os.path.join(os.getcwd(), \"sections\", \"import.txt\"), \"a\") as import_file:          import_file.write(\"from pages import *\\n\")        with open(os.path.join(os.getcwd(), \"sections\", \"main.txt\"), \"a\") as main_file:          main_file.write(\"\\n\")          main_file.write(\"    gui = Gui(pages=pages)\\n\")        handle_run_service()      def generate_main_file():      with open(os.path.join(os.getcwd(), \"sections\", \"import.txt\"), \"r\") as import_file:          import_lines = import_file.read()      with open(os.path.join(os.getcwd(), \"sections\", \"page_content.txt\"), \"r\") as page_content_file:          page_content = page_content_file.read()      with open(os.path.join(os.getcwd(), \"sections\", \"main.txt\"), \"r\") as main_file:          main_lines = main_file.read()        with open(os.path.join(os.getcwd(), \"{{cookiecutter.__main_file}}.py\"), \"a\") as app_main_file:          app_main_file.write(import_lines)          app_main_file.write(\"\\n\")          app_main_file.write(page_content)          app_main_file.write(\"\\n\\n\")          app_main_file.write(main_lines)      with open(os.path.join(os.getcwd(), \"requirements.txt\"), \"a\") as requirement_file:      requirement_file.write(f\"taipy=={taipy.version._get_version()}\\n\")    use_core = \"{{ cookiecutter.__core }}\".upper()  use_rest = \"{{ cookiecutter.__rest }}\".upper()  handle_services(use_rest in [\"YES\", \"Y\"], use_core in [\"YES\", \"Y\"])    pages = \"{{ cookiecutter.__pages }}\".split(\" \")  # Remove empty string from pages list  pages = [page for page in pages if page != \"\"]  if len(pages) == 0:      handle_single_page_app()  else:      handle_multi_page_app(pages)    generate_main_file()    # Remove the sections folder  shutil.rmtree(os.path.join(os.getcwd(), \"sections\"))    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": "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": "import os  import shutil  import uuid  from datetime import datetime, timedelta    import pandas as pd  import pytest  from dotenv import load_dotenv    from src.taipy.rest.app import create_app  from taipy.config import Config  from taipy.config.common.frequency import Frequency  from taipy.config.common.scope import Scope  from taipy.core import Cycle, DataNodeId, Job, JobId, Scenario, Sequence, Task  from taipy.core.cycle._cycle_manager import _CycleManager  from taipy.core.data.in_memory import InMemoryDataNode  from taipy.core.job._job_manager import _JobManager  from taipy.core.task._task_manager import _TaskManager    from .setup.shared.algorithms import evaluate, forecast      @pytest.fixture  def setup_end_to_end():      model_cfg = Config.configure_data_node(\"model\", path=\"setup/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=\"setup/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_config = Config.configure_scenario(          \"scenario\", [forecast_task_cfg, evaluate_task_cfg], frequency=Frequency.DAILY      )      scenario_config.add_sequences({\"sequence\": [forecast_task_cfg, evaluate_task_cfg]})      @pytest.fixture()  def app():      load_dotenv(\".testenv\")      app = create_app(testing=True)      app.config.update(          {              \"TESTING\": True,          }      )      with app.app_context(), app.test_request_context():          yield app      @pytest.fixture()  def client(app):      return app.test_client()      @pytest.fixture  def datanode_data():      return {          \"name\": \"foo\",          \"storage_type\": \"in_memory\",          \"scope\": \"scenario\",          \"default_data\": [\"1991-01-01T00:00:00\"],      }      @pytest.fixture  def task_data():      return {          \"config_id\": \"foo\",          \"input_ids\": [\"DATASOURCE_foo_3b888e17-1974-4a56-a42c-c7c96bc9cd54\"],          \"function_name\": \"print\",          \"function_module\": \"builtins\",          \"output_ids\": [\"DATASOURCE_foo_4d9923b8-eb9f-4f3c-8055-3a1ce8bee309\"],      }      @pytest.fixture  def sequence_data():      return {          \"name\": \"foo\",          \"task_ids\": [\"TASK_foo_3b888e17-1974-4a56-a42c-c7c96bc9cd54\"],      }      @pytest.fixture  def scenario_data():      return {          \"name\": \"foo\",          \"sequence_ids\": [\"SEQUENCE_foo_3b888e17-1974-4a56-a42c-c7c96bc9cd54\"],          \"properties\": {},      }      @pytest.fixture  def default_datanode():      return InMemoryDataNode(          \"input_ds\",          Scope.SCENARIO,          DataNodeId(\"f\"),          \"my name\",          \"owner_id\",          properties={\"default_data\": [1, 2, 3, 4, 5, 6]},      )      @pytest.fixture  def default_df_datanode():      return InMemoryDataNode(          \"input_ds\",          Scope.SCENARIO,          DataNodeId(\"id_uio2\"),          \"my name\",          \"owner_id\",          properties={\"default_data\": pd.DataFrame([{\"a\": 1, \"b\": 2}, {\"a\": 3, \"b\": 4}, {\"a\": 5, \"b\": 6}])},      )      @pytest.fixture  def default_datanode_config():      return Config.configure_data_node(f\"taipy_{uuid.uuid4().hex}\", \"in_memory\", Scope.SCENARIO)      @pytest.fixture  def default_datanode_config_list():      configs = []      for i in range(10):          configs.append(Config.configure_data_node(id=f\"ds_{i}\", storage_type=\"in_memory\", scope=Scope.SCENARIO))      return configs      def __default_task():      input_ds = InMemoryDataNode(          \"input_ds\",          Scope.SCENARIO,          DataNodeId(\"id_uio\"),          \"my name\",          \"owner_id\",          properties={\"default_data\": \"In memory Data Source\"},      )        output_ds = InMemoryDataNode(          \"output_ds\",          Scope.SCENARIO,          DataNodeId(\"id_uio\"),          \"my name\",          \"owner_id\",          properties={\"default_data\": \"In memory Data Source\"},      )      return Task(          config_id=\"foo\",          properties={},          function=print,          input=[input_ds],          output=[output_ds],          id=None,      )      @pytest.fixture  def default_task():      return __default_task()      @pytest.fixture  def default_task_config():      return Config.configure_task(\"task1\", print, [], [])      @pytest.fixture  def default_task_config_list():      configs = []      for i in range(10):          configs.append(Config.configure_task(f\"task_{i}\", print, [], []))      return configs      def __default_sequence():      return Sequence(properties={\"name\": \"foo\"}, tasks=[__default_task()], sequence_id=\"SEQUENCE_foo_SCENARIO_acb\")      def __task_config():      return Config.configure_task(\"task1\", print, [], [])      @pytest.fixture  def default_sequence():      return __default_sequence()      @pytest.fixture  def default_scenario_config():      task_config = __task_config()      scenario_config = Config.configure_scenario(          f\"taipy_{uuid.uuid4().hex}\",          [task_config],      )      scenario_config.add_sequences({\"sequence\": [task_config]})      return scenario_config      @pytest.fixture  def default_scenario_config_list():      configs = []      for _ in range(10):          task_config = Config.configure_task(f\"taipy_{uuid.uuid4().hex}\", print)          scenario_config = Config.configure_scenario(              f\"taipy_{uuid.uuid4().hex}\",              [task_config],          )          scenario_config.add_sequences({\"sequence\": [task_config]})          configs.append(scenario_config)      return configs      @pytest.fixture  def default_scenario():      return Scenario(config_id=\"foo\", properties={}, tasks=[__default_task()], scenario_id=\"SCENARIO_scenario_id\")      def __create_cycle(name=\"foo\"):      now = datetime.now()      return Cycle(          name=name,          frequency=Frequency.DAILY,          properties={},          creation_date=now,          start_date=now,          end_date=now + timedelta(days=5),      )      @pytest.fixture  def create_cycle_list():      cycles = []      manager = _CycleManager      for i in range(10):          c = __create_cycle(f\"cycle_{1}\")      return cycles      @pytest.fixture  def cycle_data():      return {          \"name\": \"foo\",          \"frequency\": \"daily\",          \"properties\": {},          \"creation_date\": \"2022-02-03T22:17:27.317114\",          \"start_date\": \"2022-02-03T22:17:27.317114\",          \"end_date\": \"2022-02-08T22:17:27.317114\",      }      @pytest.fixture  def default_cycle():      return __create_cycle()      def __create_job():      task_manager = _TaskManager      task = __default_task()      task_manager._set(task)      submit_id = f\"SUBMISSION_{str(uuid.uuid4())}\"      return Job(id=JobId(f\"JOB_{uuid.uuid4()}\"), task=task, submit_id=submit_id, submit_entity_id=task.id)      @pytest.fixture  def default_job():      return __create_job()      @pytest.fixture  def create_job_list():      jobs = []      manager = _JobManager      for i in range(10):          c = __create_job()      return jobs      @pytest.fixture(scope=\"function\", autouse=True)  def cleanup_files():      Config.unblock_update()      if os.path.exists(\".data\"):          shutil.rmtree(\".data\") "}
{"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 datetime import datetime    from flask import request  from flask_restful import Resource    from taipy.config.common.frequency import Frequency  from taipy.core import Cycle  from taipy.core.cycle._cycle_manager_factory import _CycleManagerFactory  from taipy.core.exceptions.exceptions import NonExistingCycle    from ...commons.to_from_model import _to_model  from ..middlewares._middleware import _middleware  from ..schemas import CycleResponseSchema, CycleSchema    REPOSITORY = \"cycle\"      def _get_or_raise(cycle_id: str) -> None:      manager = _CycleManagerFactory._build_manager()      cycle = manager._get(cycle_id)      if not cycle:          raise NonExistingCycle(cycle_id)      return cycle      class CycleResource(Resource):      \"\"\"Single object resource        ---      get:        tags:          - api        description: |          Returns a `CycleSchema^` representing the unique `Cycle^` identified by the *cycle_id*          given as parameter. If no cycle corresponds to *cycle_id*, a `404` error is returned.            !!! Example                === \"Curl\"                  ```shell                      curl -X GET http://localhost:5000/api/v1/cycles/CYCLE_223894_e0fab919-b50b-4b9f-ac09-52f77474fa7a                  ```                  In this example the REST API is served on port 5000 on localhost. We are using curl command line                  client.                    `CYCLE_223894_e0fab919-b50b-4b9f-ac09-52f77474fa7a` is the value of the *cycle_id* parameter. It                  represents the identifier of the Cycle we want to retrieve.                    In case of success here is an example of the response:                  ``` JSON                  {\"cycle\": {                      \"frequency\": \"Frequency.DAILY\",                      \"creation_date\": \"2022-08-04T17:13:32.797384\",                      \"id\": \"CYCLE_223894_e0fab919-b50b-4b9f-ac09-52f77474fa7a\",                      \"start_date\": \"2022-08-04T00:00:00\",                      \"end_date\": \"2022-08-04T23:59:59.999999\",                      \"name\": \"Frequency.DAILY_2022-08-04T17:13:32.797384\"                  ```                    In case of failure here is an example of the response:                  ``` JSON                  {\"message\": \"Cycle CYCLE_223894_e0fab919-b50b-4b9f-ac09-52f77474fa7a not found.\"}                  ```                === \"Python\"                  This Python example requires the 'requests' package to be installed (`pip install requests`).                  ```python                  import requests                      response = requests.get(\"http://localhost:5000/api/v1/cycles/CYCLE_223894_e0fab919-b50b-4b9f-ac09-52f77474fa7a\")                      print(response)                      print(response.json())                  ```                  `CYCLE_223894_e0fab919-b50b-4b9f-ac09-52f77474fa7a` is the value of the  *cycle_id* parameter. It                  represents the identifier of the Cycle we want to retrieve.                    In case of success here is an output example:                  ```                  <Response [200]>                  {'cycle': {                      'frequency': 'Frequency.DAILY',                      'creation_date': '2022-08-04T17:13:32.797384',                      'id': 'CYCLE_223894_e0fab919-b50b-4b9f-ac09-52f77474fa7a',                      'start_date': '2022-08-04T00:00:00',                      'end_date': '2022-08-04T23:59:59.999999',                      'name': 'Frequency.DAILY_2022-08-04T17:13:32.797384'                  ```                    In case of failure here is an output example:                  ```                  <Response [404]>                  {'message': 'Cycle CYCLE_223894_e0fab919-b50b-4b9f-ac09-52f77474fa7a not found.'}                    ```            !!! Note            When the authorization feature is activated (available in Taipy Enterprise edition only), this endpoint              requires the `TAIPY_READER` role.          parameters:          - in: path            name: cycle_id            schema:              type: string            description: The identifier of the cycle to retrieve.        responses:          200:            content:              application/json:                schema:                  type: object                  properties:                    cycle: CycleSchema          404:            description: No cycle has the *cycle_id* identifier.      delete:        tags:          - api        description: |          Deletes the `Cycle^` identified by the  *cycle_id* given as parameter. If the cycle does not exist,          a 404 error is returned.            !!! Example                === \"Curl\"                  ```shell                      curl -X DELETE http://localhost:5000/api/v1/cycles/CYCLE_223894_e0fab919-b50b-4b9f-ac09-52f77474fa7a                  ```                  In this example the REST API is served on port 5000 on localhost. We are using curl command line                  client.                    `CYCLE_223894_e0fab919-b50b-4b9f-ac09-52f77474fa7a` is the value of the  *cycle_id* parameter. It                  represents the identifier of the Cycle we want to delete.                    In case of success here is an example of the response:                  ``` JSON                  {\"message\": \"Cycle CYCLE_223894_e0fab919-b50b-4b9f-ac09-52f77474fa7a was deleted.\"}                  ```                    In case of failure here is an example of the response:                  ``` JSON                  {\"message\": \"Cycle CYCLE_223894_e0fab919-b50b-4b9f-ac09-52f77474fa7a not found.\"}                  ```                === \"Python\"                  This Python example requires the 'requests' package to be installed (`pip install requests`).                  ```python                  import requests                      response = requests.delete(\"http://localhost:5000/api/v1/cycles/CYCLE_797384_ef210412-af91-4f41-b6e8-74d1648edcba\")                      print(response)                      print(response.json())                  ```                  `CYCLE_223894_e0fab919-b50b-4b9f-ac09-52f77474fa7a` is the value of the  *cycle_id* parameter. It                  represents the identifier of the Cycle we want to delete.                    In case of success here is an output example:                  ```                  <Response [200]>                  {\"message\": \"Cycle CYCLE_223894_e0fab919-b50b-4b9f-ac09-52f77474fa7a was deleted.\"}                  ```                    In case of failure here is an output example:                  ```                  <Response [404]>                  {'message': 'Cycle CYCLE_223894_e0fab919-b50b-4b9f-ac09-52f77474fa7a not found.'}                    ```            !!! Note              When the authorization feature is activated (available in Taipy Enterprise edition only), this endpoint              requires the `TAIPY_EDITOR` role.          parameters:          - in: path            name: cycle_id            schema:              type: string            description: The id of the cycle to delete.        responses:          200:            content:              application/json:                schema:                  type: object                  properties:                    message:                      type: string                      description: Status message.          404:            description: No cycle has the  *cycle_id* identifier.      \"\"\"        def __init__(self, **kwargs):          self.logger = kwargs.get(\"logger\")        @_middleware      def get(self, cycle_id):          schema = CycleResponseSchema()          cycle = _get_or_raise(cycle_id)          return {\"cycle\": schema.dump(_to_model(REPOSITORY, cycle))}        @_middleware      def delete(self, cycle_id):          manager = _CycleManagerFactory._build_manager()          _get_or_raise(cycle_id)          manager._delete(cycle_id)          return {\"message\": f\"Cycle {cycle_id} was deleted.\"}      class CycleList(Resource):      \"\"\"Creation and get_all        ---      get:        tags:          - api        description: |          Returns a `CycleSchema^` list representing all existing Cycles.            !!! Example                === \"Curl\"                  ```shell                      curl -X GET http://localhost:5000/api/v1/cycles                  ```                  In this example the REST API is served on port 5000 on localhost. We are using curl command line                  client.                    Here is an example of the response:                  ``` JSON                  [                      {                      \"frequency\": \"Frequency.DAILY\",                      \"end_date\": \"2022-08-06T23:59:59.999999\",                      \"creation_date\": \"2022-08-06T15:45:50.223894\",                      \"start_date\": \"2022-08-06T00:00:00\",                      \"id\": \"CYCLE_223894_e0fab919-b50b-4b9f-ac09-52f77474fa7a\",                      \"name\": \"Frequency.DAILY_2022-08-06T15:45:50.223894\"                      }                  ]                  ```                    If there is no cycle, the response is an empty list as follows:                  ``` JSON                  []                  ```                === \"Python\"                  This Python example requires the 'requests' package to be installed (`pip install requests`).                  ```python                  import requests                      response = requests.get(\"http://localhost:5000/api/v1/cycles\")                      print(response)                      print(response.json())                  ```                    In case of success here is an output example:                  ```                  <Response [200]>                  [{                      \"frequency\": \"Frequency.DAILY\",                      \"end_date\": \"2022-08-06T23:59:59.999999\",                      \"creation_date\": \"2022-08-06T15:45:50.223894\",                      \"start_date\": \"2022-08-06T00:00:00\",                      \"id\": \"CYCLE_223894_e0fab919-b50b-4b9f-ac09-52f77474fa7a\",                      \"name\": \"Frequency.DAILY_2022-08-06T15:45:50.223894\"                      }                  ]                  ```                    If there is no cycle, the response is an empty list as follows:                  ```                  <Response [200]>                  []                  ```            !!! Note              When the authorization feature is activated (available in Taipy Enterprise edition only), this endpoint              requires the `TAIPY_READER` role.          responses:          200:            content:              application/json:                schema:                  allOf:                    - type: object                      properties:                        results:                          type: array                          items:                            $ref: '#/components/schemas/CycleSchema'      post:        tags:          - api        description: |          Creates a new cycle from the `CycleSchema^` given in the request body.            !!! Example                === \"Curl\"                  ```shell                      curl -X POST -H \"Content-Type: application/json\"\\                      -d '{\"frequency\": \"DAILY\", \"properties\": {}, \"creation_date\": \"2020-01-01T00:00:00\",\\                      \"start_date\": \"2020-01-01T00:00:00\", \"end_date\": \"2020-01-01T00:00:00\"}'\\                      http://localhost:5000/api/v1/cycles                  ```                  In this example the REST API is served on port 5000 on localhost. We are using curl command line                  client.                    In the curl command line, a `CycleSchema^` is provided as JSON dictionary parameter with the curl                  option -d (--data) to specify the various attributes of the `Cycle^` to create:                  ``` JSON                  {                      \"frequency\": \"DAILY\",                      \"properties\": {},                      \"creation_date\": \"2020-01-01T00:00:00\",                      \"start_date\": \"2020-01-01T00:00:00\",                      \"end_date\": \"2020-01-01T00:00:00\"                  }                  ```                === \"Python\"                  This Python example requires the 'requests' package to be installed (`pip install requests`).                  ```python                  import requests                      cycle_schema = {                          \"frequency\": \"DAILY\",                          \"properties\": {},                          \"creation_date\": \"2020-01-01T00:00:00\",                          \"start_date\": \"2020-01-01T00:00:00\",                          \"end_date\": \"2020-01-01T00:00:00\"                      }                      response = requests.post(\"http://localhost:5000/api/v1/cycles\", json=cycle_schema)                      print(response)                      print(response.json())                  ```                  A `CycleSchema^` is provided as a dictionary to specify the various attributes of the `Cycle^` to                  create.                    Here is the output example:                  ```                  <Response [201]>                  {                      'message': 'Cycle was created.',                      'cycle': {                          'frequency': 'Frequency.DAILY',                          'end_date': '2020-01-01T00:00:00',                          'creation_date': '2020-01-01T00:00:00',                          'start_date': '2020-01-01T00:00:00',                          'id': 'CYCLE_c9cc527f-a8c8-4238-8f31-42166a9817db',                          'name': 'Frequency.DAILY_2020-01-01T00:00:00',                          'properties': {}}}                  ```            !!! Note              When the authorization feature is activated (available in Taipy Enterprise edition only), this endpoint              requires the `TAIPY_EDITOR` role.          requestBody:          required: true          content:            application/json:              schema:                CycleSchema        responses:          201:            content:              application/json:                schema:                  type: object                  properties:                    message:                      type: string                      description: Status message.                    cycle: CycleSchema      \"\"\"        def __init__(self, **kwargs):          self.logger = kwargs.get(\"logger\")        @_middleware      def get(self):          schema = CycleResponseSchema(many=True)          manager = _CycleManagerFactory._build_manager()          cycles = [_to_model(REPOSITORY, cycle) for cycle in manager._get_all()]          return schema.dump(cycles)        @_middleware      def post(self):          schema = CycleResponseSchema()          manager = _CycleManagerFactory._build_manager()            cycle = self.__create_cycle_from_schema(schema.load(request.json))          manager._set(cycle)            return {              \"message\": \"Cycle was created.\",              \"cycle\": schema.dump(_to_model(REPOSITORY, cycle)),          }, 201        def __create_cycle_from_schema(self, cycle_schema: CycleSchema):          return Cycle(              id=cycle_schema.get(\"id\"),              frequency=Frequency(getattr(Frequency, cycle_schema.get(\"frequency\", \"\").upper())),              properties=cycle_schema.get(\"properties\", {}),              creation_date=datetime.fromisoformat(cycle_schema.get(\"creation_date\")),              start_date=datetime.fromisoformat(cycle_schema.get(\"start_date\")),              end_date=datetime.fromisoformat(cycle_schema.get(\"end_date\")),          ) "}
{"text": "from flask import request  from flask_restful import Resource    from taipy.config.config import Config  from taipy.core.exceptions.exceptions import NonExistingTask, NonExistingTaskConfig  from taipy.core.task._task_manager_factory import _TaskManagerFactory    from ...commons.to_from_model import _to_model  from ..exceptions.exceptions import ConfigIdMissingException  from ..middlewares._middleware import _middleware  from ..schemas import TaskSchema      def _get_or_raise(task_id: str):      manager = _TaskManagerFactory._build_manager()      task = manager._get(task_id)      if task is None:          raise NonExistingTask(task_id)      return task      REPOSITORY = \"task\"      class TaskResource(Resource):      \"\"\"Single object resource        ---      get:        tags:          - api        summary: Get a task.        description: |          Return a single task by *task_id*. If the task does not exist, a 404 error is returned.            !!! Note            When the authorization feature is activated (available in the **Enterprise** edition only), this endpoint            requires `TAIPY_READER` role.            Code example:            ```shell            curl -X GET http://localhost:5000/api/v1/tasks/TASK_my_config_75750ed8-4e09-4e00-958d-e352ee426cc9          ```          parameters:          - in: path            name: task_id            schema:              type: string            description: The identifier of the task.        responses:          200:            content:              application/json:                schema:                  type: object                  properties:                    task: TaskSchema          404:            description: No task has the *task_id* identifier.      delete:        tags:          - api        summary: Delete a task.        description: |          Delete a task. If the task does not exist, a 404 error is returned.            !!! Note            When the authorization feature is activated (available in the **Enterprise** edition only), this endpoint            requires `TAIPY_EDITOR` role.            Code example:            ```shell            curl -X DELETE http://localhost:5000/api/v1/tasks/TASK_my_config_75750ed8-4e09-4e00-958d-e352ee426cc9          ```        parameters:          - in: path            name: task_id            schema:              type: string            description: The identifier of the task.        responses:          200:            content:              application/json:                schema:                  type: object                  properties:                    message:                      type: string                      description: Status message.          404:            description: No task has the *task_id* identifier.      \"\"\"        def __init__(self, **kwargs):          self.logger = kwargs.get(\"logger\")        @_middleware      def get(self, task_id):          schema = TaskSchema()          task = _get_or_raise(task_id)          return {\"task\": schema.dump(_to_model(REPOSITORY, task))}        @_middleware      def delete(self, task_id):          manager = _TaskManagerFactory._build_manager()          _get_or_raise(task_id)          manager._delete(task_id)          return {\"message\": f\"Task {task_id} was deleted.\"}      class TaskList(Resource):      \"\"\"Creation and get_all        ---      get:        tags:          - api        summary: Get all tasks.        description: |          Return an array of all tasks.            !!! Note            When the authorization feature is activated (available in the **Enterprise** edition only), this endpoint            requires `TAIPY_READER` role.            Code example:            ```shell            curl -X GET http://localhost:5000/api/v1/tasks          ```          responses:          200:            content:              application/json:                schema:                  allOf:                    - type: object                      properties:                        results:                          type: array                          items:                            $ref: '#/components/schemas/TaskSchema'      post:        tags:          - api        summary: Create a task.        description: |          Create a new task from its *config_id*. If the config does not exist, a 404 error is returned.            !!! Note            When the authorization feature is activated (available in the **Enterprise** edition only), this endpoint            requires `TAIPY_EDITOR` role.            Code example:            ```shell            curl -X POST http://localhost:5000/api/v1/tasks?config_id=my_task_config          ```        parameters:          - in: query            name: config_id            schema:              type: string            description: The identifier of the task configuration.        responses:          201:            content:              application/json:                schema:                  type: object                  properties:                    message:                      type: string                      description: Status message.                    task: TaskSchema      \"\"\"        def __init__(self, **kwargs):          self.logger = kwargs.get(\"logger\")        def fetch_config(self, config_id):          config = Config.tasks.get(config_id)          if not config:              raise NonExistingTaskConfig(config_id)          return config        @_middleware      def get(self):          schema = TaskSchema(many=True)          manager = _TaskManagerFactory._build_manager()          tasks = [_to_model(REPOSITORY, task) for task in manager._get_all()]          return schema.dump(tasks)        @_middleware      def post(self):          args = request.args          config_id = args.get(\"config_id\")            schema = TaskSchema()          manager = _TaskManagerFactory._build_manager()          if not config_id:              raise ConfigIdMissingException            config = self.fetch_config(config_id)          task = manager._bulk_get_or_create([config])[0]            return {              \"message\": \"Task was created.\",              \"task\": schema.dump(_to_model(REPOSITORY, task)),          }, 201      class TaskExecutor(Resource):      \"\"\"Execute a task        ---      post:        tags:          - api        summary: Execute a task.        description: |          Execute a task by *task_id*. If the task does not exist, a 404 error is returned.            !!! Note            When the authorization feature is activated (available in the **Enterprise** edition only), this endpoint            requires `TAIPY_EXECUTOR` role.            Code example:            ```shell            curl -X POST http://localhost:5000/api/v1/tasks/submit/TASK_my_config_75750ed8-4e09-4e00-958d-e352ee426cc9          ```          parameters:          - in: path            name: task_id            schema:              type: string        responses:          204:            content:              application/json:                schema:                  type: object                  properties:                    message:                      type: string                      description: Status message.                    task: TaskSchema          404:            description: No task has the *task_id* identifier.      \"\"\"        def __init__(self, **kwargs):          self.logger = kwargs.get(\"logger\")        @_middleware      def post(self, task_id):          manager = _TaskManagerFactory._build_manager()          task = _get_or_raise(task_id)          manager._orchestrator().submit_task(task)          return {\"message\": f\"Task {task_id} was submitted.\"} "}
{"text": "import uuid  from typing import Optional    from flask import request  from flask_restful import Resource    from taipy.config.config import Config  from taipy.core import Job, JobId  from taipy.core.exceptions.exceptions import NonExistingJob, NonExistingTaskConfig  from taipy.core.job._job_manager_factory import _JobManagerFactory  from taipy.core.task._task_manager_factory import _TaskManagerFactory    from ..exceptions.exceptions import ConfigIdMissingException  from ..middlewares._middleware import _middleware  from ..schemas import JobSchema      def _get_or_raise(job_id: str):      manager = _JobManagerFactory._build_manager()      job = manager._get(job_id)      if job is None:          raise NonExistingJob(job_id)      return job      class JobResource(Resource):      \"\"\"Single object resource        ---      get:        tags:          - api        summary: Get a job.        description: |          Return a single job by *job_id*. If the job does not exist, a 404 error is returned.            !!! Note            When the authorization feature is activated (available in the **Enterprise** edition only), the            endpoint requires `TAIPY_READER` role.            Code example:            ```shell            curl -X GET http://localhost:5000/api/v1/jobs/JOB_my_task_config_75750ed8-4e09-4e00-958d-e352ee426cc9          ```          parameters:          - in: path            name: job_id            schema:              type: string            description: The identifier of the job.        responses:          200:            content:              application/json:                schema:                  type: object                  properties:                    job: JobSchema          404:            description: No job has the *job_id* identifier.      delete:        tags:          - api        summary: Delete a job.        description: |          Delete a job. If the job does not exist, a 404 error is returned.            !!! Note            When the authorization feature is activated (available in the **Enterprise** edition only), the endpoint            requires `TAIPY_EDITOR` role.            Code example:            ```shell            curl -X DELETE http://localhost:5000/api/v1/jobs/JOB_my_task_config_75750ed8-4e09-4e00-958d-e352ee426cc9          ```          parameters:          - in: path            name: job_id            schema:              type: string            description: The identifier of the job.        responses:          200:            content:              application/json:                schema:                  type: object                  properties:                    message:                      type: string                      description: Status message.          404:            description: No job has the *job_id* identifier.      \"\"\"        def __init__(self, **kwargs):          self.logger = kwargs.get(\"logger\")        @_middleware      def get(self, job_id):          schema = JobSchema()          job = _get_or_raise(job_id)          return {\"job\": schema.dump(job)}        @_middleware      def delete(self, job_id):          manager = _JobManagerFactory._build_manager()          job = _get_or_raise(job_id)          manager._delete(job)          return {\"message\": f\"Job {job_id} was deleted.\"}      class JobList(Resource):      \"\"\"Creation and get_all        ---      get:        tags:          - api        summary: Get all jobs.        description: |          Return an array of all jobs.            !!! Note            When the authorization feature is activated (available in the **Enterprise** edition only), the endpoint            requires `TAIPY_READER` role.            Code example:            ```shell            curl -X GET http://localhost:5000/api/v1/jobs          ```          responses:          200:            content:              application/json:                schema:                  allOf:                    - type: object                      properties:                        results:                          type: array                          items:                            $ref: '#/components/schemas/JobSchema'      post:        tags:          - api        summary: Create a job.        description: |          Create a job from a task *config_id*. If the config does not exist, a 404 error is returned.            !!! Note            When the authorization feature is activated (available in the **Enterprise** edition only), the endpoint            requires `TAIPY_EDITOR` role.            Code example:            ```shell            curl -X POST http://localhost:5000/api/v1/jobs?task_id=TASK_my_config_75750ed8-4e09-4e00-958d-e352ee426cc9          ```          parameters:          - in: query            name: task_id            schema:              type: string            description: The identifier of the task configuration.        responses:          201:            content:              application/json:                schema:                  type: object                  properties:                    message:                      type: string                      description: Status message.                    job: JobSchema      \"\"\"        def __init__(self, **kwargs):          self.logger = kwargs.get(\"logger\")        def fetch_config(self, config_id):          config = Config.tasks.get(config_id)          if not config:              raise NonExistingTaskConfig(config_id)          return config        @_middleware      def get(self):          schema = JobSchema(many=True)          manager = _JobManagerFactory._build_manager()          jobs = manager._get_all()          return schema.dump(jobs)        @_middleware      def post(self):          args = request.args          task_config_id = args.get(\"task_id\")            if not task_config_id:              raise ConfigIdMissingException            manager = _JobManagerFactory._build_manager()          schema = JobSchema()          job = self.__create_job_from_schema(task_config_id)          manager._set(job)          return {              \"message\": \"Job was created.\",              \"job\": schema.dump(job),          }, 201        def __create_job_from_schema(self, task_config_id: str) -> Optional[Job]:          task_manager = _TaskManagerFactory._build_manager()          task = task_manager._bulk_get_or_create([self.fetch_config(task_config_id)])[0]          return Job(              id=JobId(f\"JOB_{uuid.uuid4()}\"), task=task, submit_id=f\"SUBMISSION_{uuid.uuid4()}\", submit_entity_id=task.id          )      class JobExecutor(Resource):      \"\"\"Cancel a job        ---      post:        tags:          - api        summary: Cancel a job.        description: |          Cancel a job by *job_id*. If the job does not exist, a 404 error is returned.            !!! Note            When the authorization feature is activated (available in the **Enterprise** edition only), the endpoint            requires `TAIPY_EXECUTOR` role.            Code example:            ```shell            curl -X POST http://localhost:5000/api/v1/jobs/cancel/JOB_my_task_config_75750ed8-4e09-4e00-958d-e352ee426cc9          ```          parameters:          - in: path            name: job_id            schema:              type: string        responses:          204:            content:              application/json:                schema:                  type: object                  properties:                    message:                      type: string                      description: Status message.                    job: JobSchema          404:            description: No job has the *job_id* identifier.      \"\"\"        def __init__(self, **kwargs):          self.logger = kwargs.get(\"logger\")        @_middleware      def post(self, job_id):          manager = _JobManagerFactory._build_manager()          job = _get_or_raise(job_id)          manager._cancel(job)          return {\"message\": f\"Job {job_id} was cancelled.\"} "}
{"text": "  from flask import request  from flask_restful import Resource    from taipy.core.exceptions.exceptions import NonExistingScenario, NonExistingSequence  from taipy.core.scenario._scenario_manager_factory import _ScenarioManagerFactory  from taipy.core.sequence._sequence_manager_factory import _SequenceManagerFactory    from ...commons.to_from_model import _to_model  from ..exceptions.exceptions import ScenarioIdMissingException, SequenceNameMissingException  from ..middlewares._middleware import _middleware  from ..schemas import SequenceResponseSchema      def _get_or_raise(sequence_id: str):      manager = _SequenceManagerFactory._build_manager()      sequence = manager._get(sequence_id)      if sequence is None:          raise NonExistingSequence(sequence_id)      return sequence      REPOSITORY = \"sequence\"      class SequenceResource(Resource):      \"\"\"Single object resource        ---      get:        tags:          - api        summary: Get a sequence.        description: |          Return a single sequence by sequence_id. If the sequence does not exist, a 404 error is returned.            !!! Note            When the authorization feature is activated (available in the **Enterprise** edition only), this endpoint            requires _TAIPY_READER_ role.            Code example:            ```shell            curl -X GET http://localhost:5000/api/v1/sequences/SEQUENCE_my_config_75750ed8-4e09-4e00-958d-e352ee426cc9          ```          parameters:          - in: path            name: sequence_id            schema:              type: string            description: The identifier of the sequence.        responses:          200:            content:              application/json:                schema:                  type: object                  properties:                    sequence: SequenceSchema          404:            description: No sequence has the *sequence_id* identifier.      delete:        tags:          - api        summary: Delete a sequence.        description: |          Delete a sequence. If the sequence does not exist, a 404 error is returned.            !!! Note            When the authorization feature is activated (available in the **Enterprise** edition only), this endpoint            requires _TAIPY_EDITOR_ role.            Code example:            ```shell            curl -X DELETE http://localhost:5000/api/v1/sequences/SEQUENCE_my_config_75750ed8-4e09-4e00-958d-e352ee426cc9          ```          parameters:          - in: path            name: sequence_id            schema:              type: string            description: The identifier of the sequence.        responses:          200:            content:              application/json:                schema:                  type: object                  properties:                    message:                      type: string                      description: Status message.          404:            description: No sequence has the *sequence_id* identifier.      \"\"\"        def __init__(self, **kwargs):          self.logger = kwargs.get(\"logger\")        @_middleware      def get(self, sequence_id):          schema = SequenceResponseSchema()          sequence = _get_or_raise(sequence_id)          return {\"sequence\": schema.dump(_to_model(REPOSITORY, sequence))}        @_middleware      def delete(self, sequence_id):          manager = _SequenceManagerFactory._build_manager()          _get_or_raise(sequence_id)          manager._delete(sequence_id)          return {\"message\": f\"Sequence {sequence_id} was deleted.\"}      class SequenceList(Resource):      \"\"\"Creation and get_all        ---      get:        tags:          - api        summary: Get all sequences.        description: |          Return an array of all sequences.            !!! Note            When the authorization feature is activated (available in the **Enterprise** edition only), this endpoint            requires _TAIPY_READER_ role.            Code example:            ```shell            curl -X GET http://localhost:5000/api/v1/sequences          ```          responses:          200:            content:              application/json:                schema:                  allOf:                    - type: object                      properties:                        results:                          type: array                          items:                            $ref: '#/components/schemas/SequenceSchema'      post:        tags:          - api        summary: Create a sequence.        description: |          Create a sequence from scenario_id, sequence_name and task_ids. If the scenario_id does not exist or sequence_name is not provided, a 404 error is returned.          !!! Note            When the authorization feature is activated (available in the **Enterprise** edition only), this endpoint            requires _TAIPY_EDITOR_ role.            Code example:            ```shell            curl -X POST --data '{\"scenario_id\": \"SCENARIO_scenario_id\", \"sequence_name\": \"sequence\", \"tasks\": []}' http://localhost:5000/api/v1/sequences          ```          parameters:          - in: query            name: scenario_id            schema:              type: string            description: The Scenario the Sequence belongs to.            name: sequence_name            schema:              type: string            description: The name of the Sequence.            name: tasks            schema:              type: list[string]            description: A list of task id of the Sequence.          responses:          201:            content:              application/json:                schema:                  type: object                  properties:                    message:                      type: string                      description: Status message.                    sequence: SequenceSchema      \"\"\"        def __init__(self, **kwargs):          self.logger = kwargs.get(\"logger\")        @_middleware      def get(self):          schema = SequenceResponseSchema(many=True)          manager = _SequenceManagerFactory._build_manager()          sequences = [_to_model(REPOSITORY, sequence) for sequence in manager._get_all()]          return schema.dump(sequences)        @_middleware      def post(self):          sequence_data = request.json          scenario_id = sequence_data.get(\"scenario_id\")          sequence_name = sequence_data.get(\"sequence_name\")          sequence_task_ids = sequence_data.get(\"task_ids\", [])            response_schema = SequenceResponseSchema()          if not scenario_id:              raise ScenarioIdMissingException          if not sequence_name:              raise SequenceNameMissingException            scenario = _ScenarioManagerFactory._build_manager()._get(scenario_id)          if not scenario:              raise NonExistingScenario(scenario_id=scenario_id)            scenario.add_sequence(sequence_name, sequence_task_ids)          sequence = scenario.sequences[sequence_name]            return {              \"message\": \"Sequence was created.\",              \"sequence\": response_schema.dump(_to_model(REPOSITORY, sequence)),          }, 201      class SequenceExecutor(Resource):      \"\"\"Execute a sequence        ---      post:        tags:          - api        summary: Execute a sequence.        description: |          Execute a sequence from sequence_id. If the sequence does not exist, a 404 error is returned.            !!! Note            When the authorization feature is activated (available in the **Enterprise** edition only), This endpoint            requires _TAIPY_EXECUTOR_ role.            Code example:            ```shell            curl -X POST http://localhost:5000/api/v1/sequences/submit/SEQUENCE_my_config_75750ed8-4e09-4e00-958d-e352ee426cc9          ```          parameters:          - in: path            name: sequence_id            schema:              type: string        responses:          204:            content:              application/json:                schema:                  type: object                  properties:                    message:                      type: string                      description: Status message.                    sequence: SequenceSchema          404:              description: No sequence has the *sequence_id* identifier.      \"\"\"        def __init__(self, **kwargs):          self.logger = kwargs.get(\"logger\")        @_middleware      def post(self, sequence_id):          _get_or_raise(sequence_id)          manager = _SequenceManagerFactory._build_manager()          manager._submit(sequence_id)          return {\"message\": f\"Sequence {sequence_id} was submitted.\"} "}
{"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": "from typing import List    import numpy as np  import pandas as pd  from flask import request  from flask_restful import Resource    from taipy.config.config import Config  from taipy.core.data._data_manager_factory import _DataManagerFactory  from taipy.core.data.operator import Operator  from taipy.core.exceptions.exceptions import NonExistingDataNode, NonExistingDataNodeConfig    from ...commons.to_from_model import _to_model  from ..exceptions.exceptions import ConfigIdMissingException  from ..middlewares._middleware import _middleware  from ..schemas import (      CSVDataNodeConfigSchema,      DataNodeFilterSchema,      DataNodeSchema,      ExcelDataNodeConfigSchema,      GenericDataNodeConfigSchema,      InMemoryDataNodeConfigSchema,      JSONDataNodeConfigSchema,      PickleDataNodeConfigSchema,      SQLTableDataNodeConfigSchema,      SQLDataNodeConfigSchema,      MongoCollectionDataNodeConfigSchema,  )    ds_schema_map = {      \"csv\": CSVDataNodeConfigSchema,      \"pickle\": PickleDataNodeConfigSchema,      \"in_memory\": InMemoryDataNodeConfigSchema,      \"sql_table\": SQLTableDataNodeConfigSchema,      \"sql\": SQLDataNodeConfigSchema,      \"mongo_collection\": MongoCollectionDataNodeConfigSchema,      \"excel\": ExcelDataNodeConfigSchema,      \"generic\": GenericDataNodeConfigSchema,      \"json\": JSONDataNodeConfigSchema,  }    REPOSITORY = \"data\"      def _get_or_raise(data_node_id: str) -> None:      manager = _DataManagerFactory._build_manager()      data_node = manager._get(data_node_id)      if not data_node:          raise NonExistingDataNode(data_node_id)      return data_node      class DataNodeResource(Resource):      \"\"\"Single object resource        ---      get:        tags:          - api        description: |          Returns a `DataNodeSchema^` representing the unique `DataNode^` identified by the *datanode_id*          given as parameter. If no data node corresponds to *datanode_id*, a `404` error is returned.            !!! Example                === \"Curl\"                  ```shell                      curl -X GET http://localhost:5000/api/v1/datanodes/DATANODE_hist_cfg_75750ed8-4e09-4e00-958d                      -e352ee426cc9                  ```                  In this example the REST API is served on port 5000 on localhost. We are using curl command line                  client.                    `DATANODE_hist_cfg_75750ed8-4e09-4e00-958d-e352ee426cc9` is the value of the *datanode_id* parameter. It                  represents the identifier of the data node we want to retrieve.                    In case of success here is an example of the response:                  ``` JSON                  {\"datanode\": {                      \"id\": \"DATANODE_historical_data_set_9db1b542-2e45-44e7-8a85-03ef9ead173d\",                      \"config_id\": \"historical_data_set\",                      \"scope\": \"<Scope.SCENARIO: 2>\",                      \"storage_type\": \"csv\",                      \"name\": \"Name of my historical data node\",                      \"owner_id\": \"SCENARIO_my_awesome_scenario_97f3fd67-8556-4c62-9b3b-ef189a599a38\",                      \"last_edit_date\": \"2022-08-10T16:03:40.855082\",                      \"job_ids\": [],                      \"version\": \"latest\",                      \"cacheable\": false,                      \"validity_days\": null,                      \"validity_seconds\": null,                      \"edit_in_progress\": false,                      \"data_node_properties\": {                          \"path\": \"daily-min-temperatures.csv\",                          \"has_header\": true}                      }}                  ```                    In case of failure here is an example of the response:                  ``` JSON                  {\"message\":\"DataNode DATANODE_historical_data_set_9db1b542-2e45-44e7-8a85-03ef9ead173d not found\"}                  ```                === \"Python\"                  This Python example requires the 'requests' package to be installed (`pip install requests`).                  ```python                  import requests                      response = requests.get(                      \"http://localhost:5000/api/v1/datanodes/DATANODE_historical_data_set_9db1b542-2e45-44e7-8a85-03ef9ead173d\")                      print(response)                      print(response.json())                  ```                  `DATANODE_hist_cfg_75750ed8-4e09-4e00-958d-e352ee426cc9` is the value of the *datanode_id* parameter. It                  represents the identifier of the data node we want to retrieve.                    In case of success here is an output example:                  ```                  <Response [200]>                  {\"datanode\": {                      \"id\": \"DATANODE_historical_data_set_9db1b542-2e45-44e7-8a85-03ef9ead173d\",                      \"config_id\": \"historical_data_set\",                      \"scope\": \"<Scope.SCENARIO: 2>\",                      \"storage_type\": \"csv\",                      \"name\": \"Name of my historical data node\",                      \"owner_id\": \"SCENARIO_my_awesome_scenario_97f3fd67-8556-4c62-9b3b-ef189a599a38\",                      \"last_edit_date\": \"2022-08-10T16:03:40.855082\",                      \"job_ids\": [],                      \"version\": \"latest\",                      \"cacheable\": false,                      \"validity_days\": null,                      \"validity_seconds\": null,                      \"edit_in_progress\": false,                      \"data_node_properties\": {                          \"path\": \"daily-min-temperatures.csv\",                          \"has_header\": true}                      }}                  ```                    In case of failure here is an output example:                  ```                  <Response [404]>                  {\"message\":\"DataNode DATANODE_historical_data_set_9db1b542-2e45-44e7-8a85-03ef9ead173d not found\"}                    ```            !!! Note            When the authorization feature is activated (available in Taipy Enterprise edition only), this endpoint              requires the `TAIPY_READER` role.          parameters:          - in: path            name: datanode_id            schema:              type: string            description: The identifier of the data node to retrieve.          responses:          200:            content:              application/json:                schema:                  type: object                  properties:                    datanode: DataNodeSchema          404:            description: No data node has the *datanode_id* identifier.      delete:        tags:          - api        summary: Delete a data node.        description: |          Deletes the `DataNode^` identified by the  *datanode_id* given as parameter. If the data node does not exist,          a 404 error is returned.            !!! Example                === \"Curl\"                  ```shell                      curl -X DELETE \\                      http://localhost:5000/api/v1/datanodes/DATANODE_historical_data_set_9db1b542-2e45-44e7-8a85-03ef9ead173d                  ```                  In this example the REST API is served on port 5000 on localhost. We are using curl command line                  client.                    `DATANODE_historical_data_set_9db1b542-2e45-44e7-8a85-03ef9ead173d` is the value of the                  *datanode_id* parameter. It represents the identifier of the data node we want to delete.                    In case of success here is an example of the response:                  ``` JSON                  {\"msg\": \"datanode DATANODE_historical_data_set_9db1b542-2e45-44e7-8a85-03ef9ead173d deleted\"}                  ```                    In case of failure here is an example of the response:                  ``` JSON                  {\"message\": \"Data node DATANODE_historical_data_set_9db1b542-2e45-44e7-8a85-03ef9ead173d not found.\"}                  ```                === \"Python\"                  This Python example requires the 'requests' package to be installed (`pip install requests`).                  ```python                  import requests                      response = requests.delete(                      \"http://localhost:5000/api/v1/datanodes/DATANODE_historical_data_set_9db1b542-2e45-44e7-8a85-03ef9ead173d\")                      print(response)                      print(response.json())                  ```                  `DATANODE_historical_data_set_9db1b542-2e45-44e7-8a85-03ef9ead173d` is the value of the                  *datanode_id* parameter. It represents the identifier of the Cycle we want to delete.                    In case of success here is an output example:                  ```                  <Response [200]>                  {\"msg\": \"Data node DATANODE_historical_data_set_9db1b542-2e45-44e7-8a85-03ef9ead173d deleted.\"}                  ```                    In case of failure here is an output example:                  ```                  <Response [404]>                  {'message': 'Data node DATANODE_historical_data_set_9db1b542-2e45-44e7-8a85-03ef9ead173d not found.'}                    ```            !!! Note              When the authorization feature is activated (available in Taipy Enterprise edition only), this endpoint              requires the `TAIPY_EDITOR` role.          parameters:          - in: path            name: datanode_id            schema:              type: string            description: The identifier of the data node to delete.        responses:          200:            content:              application/json:                schema:                  type: object                  properties:                    message:                      type: string                      description: Status message.          404:            description: No data node has the *datanode_id* identifier.      \"\"\"        def __init__(self, **kwargs):          self.logger = kwargs.get(\"logger\")        @_middleware      def get(self, datanode_id):          schema = DataNodeSchema()          datanode = _get_or_raise(datanode_id)          return {\"datanode\": schema.dump(_to_model(REPOSITORY, datanode))}        @_middleware      def delete(self, datanode_id):          _get_or_raise(datanode_id)          manager = _DataManagerFactory._build_manager()          manager._delete(datanode_id)          return {\"message\": f\"Data node {datanode_id} was deleted.\"}      class DataNodeList(Resource):      \"\"\"Creation and get_all        ---      get:        tags:          - api        description: |          Returns a `DataNodeSchema^` list representing all existing data nodes.            !!! Example                === \"Curl\"                  ```shell                      curl -X GET http://localhost:5000/api/v1/datanodes                  ```                  In this example the REST API is served on port 5000 on localhost. We are using curl command line                  client.                    Here is an example of the response:                  ``` JSON                  [                      {\"datanode\": {                          \"id\": \"DATANODE_historical_data_set_9db1b542-2e45-44e7-8a85-03ef9ead173d\",                          \"config_id\": \"historical_data_set\",                          \"scope\": \"<Scope.SCENARIO: 2>\",                          \"storage_type\": \"csv\",                          \"name\": \"Name of my historical data node\",                          \"owner_id\": \"SCENARIO_my_awesome_scenario_97f3fd67-8556-4c62-9b3b-ef189a599a38\",                          \"last_edit_date\": \"2022-08-10T16:03:40.855082\",                          \"job_ids\": [],                          \"version\": \"latest\",                          \"cacheable\": false,                          \"validity_days\": null,                          \"validity_seconds\": null,                          \"edit_in_progress\": false,                          \"data_node_properties\": {                              \"path\": \"daily-min-temperatures.csv\",                              \"has_header\": true}                      }}                  ]                  ```                    If there is no data node, the response is an empty list as follows:                  ``` JSON                  []                  ```                === \"Python\"                  This Python example requires the 'requests' package to be installed (`pip install requests`).                  ```python                  import requests                      response = requests.get(\"http://localhost:5000/api/v1/datanodes\")                      print(response)                      print(response.json())                  ```                    In case of success here is an output example:                  ```                  <Response [200]>                  [                      {\"datanode\": {                          \"id\": \"DATANODE_historical_data_set_9db1b542-2e45-44e7-8a85-03ef9ead173d\",                          \"config_id\": \"historical_data_set\",                          \"scope\": \"<Scope.SCENARIO: 2>\",                          \"storage_type\": \"csv\",                          \"name\": \"Name of my historical data node\",                          \"owner_id\": \"SCENARIO_my_awesome_scenario_97f3fd67-8556-4c62-9b3b-ef189a599a38\",                          \"last_edit_date\": \"2022-08-10T16:03:40.855082\",                          \"job_ids\": [],                          \"version\": \"latest\",                          \"cacheable\": false,                          \"validity_days\": null,                          \"validity_seconds\": null,                          \"edit_in_progress\": false,                          \"data_node_properties\": {                              \"path\": \"daily-min-temperatures.csv\",                              \"has_header\": true}                      }}                  ]                  ```                    If there is no data node, the response is an empty list as follows:                  ```                  <Response [200]>                  []                  ```            !!! Note              When the authorization feature is activated (available in Taipy Enterprise edition only), this endpoint              requires the `TAIPY_READER` role.          responses:          200:            content:              application/json:                schema:                  allOf:                    - type: object                      properties:                        results:                          type: array                          items:                            $ref: '#/components/schemas/DataNodeSchema'      post:        tags:          - api        description: |          Creates a new data node from the *config_id* given as parameter.            !!! Example                === \"Curl\"                  ```shell                      curl -X POST http://localhost:5000/api/v1/datanodes?config_id=historical_data_set                  ```                  In this example the REST API is served on port 5000 on localhost. We are using curl command line                  client.                    In this example the *config_id* value (\"historical_data_set\") is given as parameter directly in the                  url. A corresponding `DataNodeConfig^` must exist and must have been configured before.                    Here is the output message example:                  ```                  {\"msg\": \"datanode created\",                  \"datanode\": {                      \"default_path\": null,                      \"path\": \"daily-min-temperatures.csv\",                      \"name\": null,                      \"storage_type\": \"csv\",                      \"scope\": 2,                      \"has_header\": true}                  }                  ```                === \"Python\"                  This Python example requires the 'requests' package to be installed (`pip install requests`).                  ```python                  import requests                      response = requests.post(\"http://localhost:5000/api/v1/datanodes?config_id=historical_data_set\")                      print(response)                      print(response.json())                  ```                  In this example the *config_id* value (\"historical_data_set\") is given as parameter directly in the                  url. A corresponding `DataNodeConfig^` must exist and must have been configured before.                    Here is the output example:                  ```                  <Response [201]>                  {'msg': 'datanode created',                  'datanode': {                      'name': None,                      'scope': 2,                      'path': 'daily-min-temperatures.csv',                      'storage_type': 'csv',                      'default_path': None,                      'has_header': True}}                  ```            !!! Note              When the authorization feature is activated (available in Taipy Enterprise edition only), this endpoint              requires the `TAIPY_EDITOR` role.          parameters:          - in: query            name: config_id            schema:              type: string            description: The identifier of the data node configuration.        responses:          201:            content:              application/json:                schema:                  type: object                  properties:                    message:                      type: string                      description: Status message.                    datanode: DataNodeSchema      \"\"\"        def __init__(self, **kwargs):          self.logger = kwargs.get(\"logger\")        def fetch_config(self, config_id):          config = Config.data_nodes.get(config_id)          if not config:              raise NonExistingDataNodeConfig(config_id)          return config        @_middleware      def get(self):          schema = DataNodeSchema(many=True)          manager = _DataManagerFactory._build_manager()          datanodes = [_to_model(REPOSITORY, datanode) for datanode in manager._get_all()]          return schema.dump(datanodes)        @_middleware      def post(self):          args = request.args          config_id = args.get(\"config_id\")            if not config_id:              raise ConfigIdMissingException            config = self.fetch_config(config_id)          schema = ds_schema_map.get(config.storage_type)()          manager = _DataManagerFactory._build_manager()          manager._bulk_get_or_create({config})          return {              \"message\": \"Data node was created.\",              \"datanode\": schema.dump(config),          }, 201      class DataNodeReader(Resource):      \"\"\"Single object resource        ---      get:        tags:          - api        description: |          Returns the data read from the data node identified by *datanode_id*. If the data node does not exist,          a 404 error is returned.            !!! Example                === \"Curl\"                    ```shell                    curl -X GET \\                    http://localhost:5000/api/v1/datanodes/DATANODE_historical_data_set_9db1b542-2e45-44e7-8a85-03ef9ead173d/read                  ```                    `DATANODE_historical_data_set_9db1b542-2e45-44e7-8a85-03ef9ead173d` is the *datanode_id*                  parameter. It represents the identifier of the data node to read.                    Here is an output example. In this case, the storage type of the data node to read is `csv`,                  and no exposed type is specified. The data is exposed as a list of dictionaries, each dictionary                  representing a raw of the csv file.                  ```                  {\"data\": [                      {\"Date\": \"1981-01-01\", \"Temp\": 20.7}, {\"Date\": \"1981-01-02\", \"Temp\": 17.9},                      {\"Date\": \"1981-01-03\", \"Temp\": 18.8}, {\"Date\": \"1981-01-04\", \"Temp\": 14.6},                      {\"Date\": \"1981-01-05\", \"Temp\": 15.8}, {\"Date\": \"1981-01-06\", \"Temp\": 15.8},                      {\"Date\": \"1981-01-07\", \"Temp\": 15.8}                      ]}                  ```                === \"Python\"                  This Python example requires the 'requests' package to be installed (`pip install requests`).                  ```python                  import requests                      response = requests.get(                      \"http://localhost:5000/api/v1/datanodes/DATANODE_historical_data_set_9db1b542-2e45-44e7-8a85-03ef9ead173d/read\")                      print(response)                      print(response.json())                  ```                  `DATANODE_historical_data_set_9db1b542-2e45-44e7-8a85-03ef9ead173d` is the *datanode_id*                  parameter. It represents the identifier of the data node to read.                    Here is an output example. In this case, the storage type of the data node to read is `csv`,                  and no exposed type is specified. The data is exposed as a list of dictionaries, each dictionary                  representing a raw of the csv file.                  ```                  {\"data\": [                      {\"Date\": \"1981-01-01\", \"Temp\": 20.7}, {\"Date\": \"1981-01-02\", \"Temp\": 17.9},                      {\"Date\": \"1981-01-03\", \"Temp\": 18.8}, {\"Date\": \"1981-01-04\", \"Temp\": 14.6},                      {\"Date\": \"1981-01-05\", \"Temp\": 15.8}, {\"Date\": \"1981-01-06\", \"Temp\": 15.8},                      {\"Date\": \"1981-01-07\", \"Temp\": 15.8}                      ]}                  ```            !!! Note              When the authorization feature is activated (available in Taipy Enterprise edition only), this endpoint              requires the `TAIPY_READER` role.          parameters:          - in: path            name: datanode_id            schema:              type: string            description: The id of the data node to read.        requestBody:          content:            application/json:              schema:                DataNodeFilterSchema        responses:          200:            content:              application/json:                schema:                  type: object                  properties:                    data:                      type: Any                      description: The data read from the data node.          404:            description: No data node has the *datanode_id* identifier.      \"\"\"        def __init__(self, **kwargs):          self.logger = kwargs.get(\"logger\")        def __make_operators(self, schema: DataNodeFilterSchema) -> List:          return [              (                  x.get(\"key\"),                  x.get(\"value\"),                  Operator(getattr(Operator, x.get(\"operator\", \"\").upper())),              )              for x in schema.get(\"operators\")          ]        @_middleware      def get(self, datanode_id):          schema = DataNodeFilterSchema()          data = request.get_json(silent=True)          data_node = _get_or_raise(datanode_id)          operators = self.__make_operators(schema.load(data)) if data else []          data = data_node.filter(operators)          if isinstance(data, pd.DataFrame):              data = data.to_dict(orient=\"records\")          elif isinstance(data, np.ndarray):              data = list(data)          return {\"data\": data}      class DataNodeWriter(Resource):      \"\"\"Single object resource        ---      put:        tags:          - api        summary: Write into a data node.        description: |          Write data from request body into a data node by *datanode_id*. If the data node does not exist, a 404 error is returned.            !!! Note            When the authorization feature is activated (available in the **Enterprise** edition only), this endpoint requires `TAIPY_EDITOR` role.            Code example:            ```shell            curl -X PUT -d '[{\"path\": \"/abc\", \"type\": 1}, {\"path\": \"/def\", \"type\": 2}]' -H 'Content-Type: application/json'  http://localhost:5000/api/v1/datanodes/DATANODE_my_config_75750ed8-4e09-4e00-958d-e352ee426cc9/write          ```          parameters:          - in: path            name: datanode_id            schema:              type: string        requestBody:          content:            application/json:              schema:                Any        responses:          200:            content:              application/json:                schema:                  type: object                  properties:                    message:                      type: string                      description: Status message.          404:            description: No data node has the *datanode_id* identifier.      \"\"\"        def __init__(self, **kwargs):          self.logger = kwargs.get(\"logger\")        @_middleware      def put(self, datanode_id):          data = request.json          data_node = _get_or_raise(datanode_id)          data_node.write(data)          return {\"message\": f\"Data node {datanode_id} was successfully written.\"} "}
{"text": "from flask import request  from flask_restful import Resource    from taipy.config.config import Config  from taipy.core.exceptions.exceptions import NonExistingScenario, NonExistingScenarioConfig  from taipy.core.scenario._scenario_manager_factory import _ScenarioManagerFactory    from ...commons.to_from_model import _to_model  from ..exceptions.exceptions import ConfigIdMissingException  from ..middlewares._middleware import _middleware  from ..schemas import ScenarioResponseSchema      def _get_or_raise(scenario_id: str):      manager = _ScenarioManagerFactory._build_manager()      scenario = manager._get(scenario_id)      if scenario is None:          raise NonExistingScenario(scenario_id)      return scenario      REPOSITORY = \"scenario\"      class ScenarioResource(Resource):      \"\"\"Single object resource        ---      get:        tags:          - api        description: |          Returns a `ScenarioSchema^` representing the unique scenario identified by *scenario_id*. If no scenario          corresponds to *scenario_id*, a `404` error is returned.            !!! Example                === \"Curl\"                  ```shell                      curl -X GET http://localhost:5000/api/v1/scenarios/SCENARIO_63cb358d-5834-4d73-84e4-a6343df5e08c                  ```                  In this example the REST API is served on port 5000 on localhost. We are using curl command line                  client.                    `SCENARIO_63cb358d-5834-4d73-84e4-a6343df5e08c` is the value of the *scenario_id* parameter. It                  represents the identifier of the Scenario we want to retrieve.                    In case of success here is an example of the response:                  ``` JSON                  {\"scenario\": {                      \"cycle\": \"CYCLE_863418_fdd1499a-8925-4540-93fd-9dbfb4f0846d\",                      \"id\": \"SCENARIO_63cb358d-5834-4d73-84e4-a6343df5e08c\",                      \"properties\": {},                      \"tags\": [],                      \"version\": \"latest\",                      \"sequences\": [                          \"SEQUENCE_mean_baseline_5af317c9-34df-48b4-8a8a-bf4007e1de99\",                          \"SEQUENCE_arima_90aef6b9-8922-4a0c-b625-b2c6f3d19fa4\"],                      \"subscribers\": [],                      \"creation_date\": \"2022-08-15T19:21:01.871587\",                      \"primary_scenario\": true}}                  ```                    In case of failure here is an example of the response:                  ``` JSON                  {\"message\": \"SCENARIO_63cb358d-5834-4d73-84e4-a6343df5e08c not found.\"}                  ```                === \"Python\"                  This Python example requires the 'requests' package to be installed (`pip install requests`).                  ```python                  import requests                      response = requests.get(                      \"http://localhost:5000/api/v1/scenarios/SCENARIO_63cb358d-5834-4d73-84e4-a6343df5e08c\")                      print(response)                      print(response.json())                  ```                  `SCENARIO_63cb358d-5834-4d73-84e4-a6343df5e08c` is the value of the  *scenario_id* parameter. It                  represents the identifier of the Cycle we want to retrieve.                    In case of success here is an output example:                  ```                  <Response [200]>                  {\"scenario\": {                      \"cycle\": \"CYCLE_863418_fdd1499a-8925-4540-93fd-9dbfb4f0846d\",                      \"id\": \"SCENARIO_63cb358d-5834-4d73-84e4-a6343df5e08c\",                      \"properties\": {},                      \"tags\": [],                      \"version\": \"latest\",                      \"sequences\": [                          \"SEQUENCE_mean_baseline_5af317c9-34df-48b4-8a8a-bf4007e1de99\",                          \"SEQUENCE_arima_90aef6b9-8922-4a0c-b625-b2c6f3d19fa4\"],                      \"subscribers\": [],                      \"creation_date\": \"2022-08-15T19:21:01.871587\",                      \"primary_scenario\": true}}                  ```                    In case of failure here is an output example:                  ```                  <Response [404]>                  {'message': 'Scenario SCENARIO_63cb358d-5834-4d73-84e4-a6343df5e08c not found.'}                    ```            !!! Note              When the authorization feature is activated (available in Taipy Enterprise edition only), this endpoint              requires the `TAIPY_READER` role.            parameters:          - in: path            name: scenario_id            schema:              type: string            description: The identifier of the scenario to retrieve.        responses:          200:            content:              application/json:                schema:                  type: object                  properties:                    scenario: ScenarioSchema          404:            description: No scenario has the *scenario_id* identifier.      delete:        tags:          - api        description: |          Delete the `Scenario^` scenario identified by the *scenario_id* given as parameter. If the scenario does not          exist, a 404 error is returned.            !!! Example                === \"Curl\"                  ```shell                      curl -X DELETE http://localhost:5000/api/v1/scenarios/SCENARIO_63cb358d-5834-4d73-84e4-a6343df5e08c                  ```                  In this example the REST API is served on port 5000 on localhost. We are using curl command line                  client.                    `SCENARIO_63cb358d-5834-4d73-84e4-a6343df5e08c` is the value of the  *scenario_id* parameter. It                  represents the identifier of the scenario we want to delete.                    In case of success here is an example of the response:                  ``` JSON                  {\"msg\": \"Scenario SCENARIO_63cb358d-5834-4d73-84e4-a6343df5e08c deleted.\"}                  ```                    In case of failure here is an example of the response:                  ``` JSON                  {\"message\": \"Scenario SCENARIO_63cb358d-5834-4d73-84e4-a6343df5e08c not found.\"}                  ```                === \"Python\"                  This Python example requires the 'requests' package to be installed (`pip install requests`).                  ```python                  import requests                      response = requests.delete(                      \"http://localhost:5000/api/v1/scenarios/SCENARIO_63cb358d-5834-4d73-84e4-a6343df5e08c\")                      print(response)                      print(response.json())                  ```                  `SCENARIO_63cb358d-5834-4d73-84e4-a6343df5e08c` is the value of the *scenario_id* parameter. It                  represents the identifier of the Scenario we want to delete.                    In case of success here is an output example:                  ```                  <Response [200]>                  {\"msg\": \"Scenario SCENARIO_63cb358d-5834-4d73-84e4-a6343df5e08c deleted.\"}                  ```                    In case of failure here is an output example:                  ```                  <Response [404]>                  {'message': 'Scenario SCENARIO_63cb358d-5834-4d73-84e4-a6343df5e08c not found.'}                    ```            !!! Note              When the authorization feature is activated (available in Taipy Enterprise edition only), this endpoint              requires the `TAIPY_EDITOR` role.          parameters:          - in: path            name: scenario_id            schema:              type: string            description: The identifier of the scenario to delete.        responses:          200:            content:              application/json:                schema:                  type: object                  properties:                    message:                      type: string                      description: Status message.          404:            description: No scenario has the *scenario_id* identifier.      \"\"\"        def __init__(self, **kwargs):          self.logger = kwargs.get(\"logger\")        @_middleware      def get(self, scenario_id):          schema = ScenarioResponseSchema()          scenario = _get_or_raise(scenario_id)          return {\"scenario\": schema.dump(_to_model(REPOSITORY, scenario))}        @_middleware      def delete(self, scenario_id):          manager = _ScenarioManagerFactory._build_manager()          _get_or_raise(scenario_id)          manager._delete(scenario_id)          return {\"message\": f\"Scenario {scenario_id} was deleted.\"}      class ScenarioList(Resource):      \"\"\"Creation and get_all        ---      get:        tags:          - api        summary: Get all scenarios.        description: |          Returns a `ScenarioSchema^` list representing all existing Scenarios.            !!! Example                === \"Curl\"                  ```shell                      curl -X GET http://localhost:5000/api/v1/scenarios                  ```                  In this example the REST API is served on port 5000 on localhost. We are using curl command line                  client.                    Here is an example of the response:                  ``` JSON                  [{                      \"cycle\": \"CYCLE_863418_fdd1499a-8925-4540-93fd-9dbfb4f0846d\",                      \"id\": \"SCENARIO_63cb358d-5834-4d73-84e4-a6343df5e08c\",                      \"properties\": {},                      \"tags\": [],                      \"version\": \"latest\",                      \"sequences\": [                          \"SEQUENCE_mean_baseline_5af317c9-34df-48b4-8a8a-bf4007e1de99\",                          \"SEQUENCE_arima_90aef6b9-8922-4a0c-b625-b2c6f3d19fa4\"],                      \"subscribers\": [],                      \"creation_date\": \"2022-08-15T19:21:01.871587\",                      \"primary_scenario\": true                      }                  ]                  ```                    If there is no scenario, the response is an empty list as follows:                  ``` JSON                  []                  ```                === \"Python\"                  This Python example requires the 'requests' package to be installed (`pip install requests`).                  ```python                  import requests                      response = requests.get(\"http://localhost:5000/api/v1/scenarios\")                      print(response)                      print(response.json())                  ```                    In case of success here is an output example:                  ```                  <Response [200]>                  [{                      \"cycle\": \"CYCLE_863418_fdd1499a-8925-4540-93fd-9dbfb4f0846d\",                      \"id\": \"SCENARIO_63cb358d-5834-4d73-84e4-a6343df5e08c\",                      \"properties\": {},                      \"tags\": [],                      \"version\": \"latest\",                      \"sequences\": [                          \"SEQUENCE_mean_baseline_5af317c9-34df-48b4-8a8a-bf4007e1de99\",                          \"SEQUENCE_arima_90aef6b9-8922-4a0c-b625-b2c6f3d19fa4\"],                      \"subscribers\": [],                      \"creation_date\": \"2022-08-15T19:21:01.871587\",                      \"primary_scenario\": true                      }                  ]                  ```                    If there is no scenario, the response is an empty list as follows:                  ```                  <Response [200]>                  []                  ```            !!! Note              When the authorization feature is activated (available in Taipy Enterprise edition only), this endpoint              requires the `TAIPY_READER` role.          responses:          200:            content:              application/json:                schema:                  allOf:                    - type: object                      properties:                        results:                          type: array                          items:                            $ref: '#/components/schemas/ScenarioSchema'      post:        tags:          - api        description: |          Creates a new scenario from the  *config_id*. If the config does not exist, a 404 error is returned.            !!! Example                === \"Curl\"                  ```shell                      curl -X POST http://localhost:5000/api/v1/scenarios?config_id=my_scenario_config                  ```                  In this example the REST API is served on port 5000 on localhost. We are using curl command line                  client.                    In this example the *config_id* value (\"my_scenario_config\") is given as parameter directly in the                  url. A corresponding `ScenarioConfig^` must exist and must have been configured before.                    Here is the output message example:                  ```                  {\"msg\": \"scenario created.\",                  \"scenario\": {                      \"cycle\": \"CYCLE_863418_fdd1499a-8925-4540-93fd-9dbfb4f0846d\",                      \"id\": \"SCENARIO_63cb358d-5834-4d73-84e4-a6343df5e08c\",                      \"properties\": {},                      \"tags\": [],                      \"version\": \"latest\",                      \"sequences\": [                          \"SEQUENCE_mean_baseline_5af317c9-34df-48b4-8a8a-bf4007e1de99\",                          \"SEQUENCE_arima_90aef6b9-8922-4a0c-b625-b2c6f3d19fa4\"],                      \"subscribers\": [],                      \"creation_date\": \"2022-08-15T19:21:01.871587\",                      \"primary_scenario\": true}                  }                  ```                === \"Python\"                  This Python example requires the 'requests' package to be installed (`pip install requests`).                  ```python                  import requests                      response = requests.post(\"http://localhost:5000/api/v1/scenarios?config_id=my_scenario_config\")                      print(response)                      print(response.json())                  ```                  In this example the *config_id* value (\"my_scenario_config\") is given as parameter directly in the                  url. A corresponding `ScenarioConfig^` must exist and must have been configured before.                    Here is the output example:                  ```                  <Response [201]>                  {\"msg\": \"scenario created.\",                  \"scenario\": {                      \"cycle\": \"CYCLE_863418_fdd1499a-8925-4540-93fd-9dbfb4f0846d\",                      \"id\": \"SCENARIO_63cb358d-5834-4d73-84e4-a6343df5e08c\",                      \"properties\": {},                      \"tags\": [],                      \"version\": \"latest\",                      \"sequences\": [                          \"SEQUENCE_mean_baseline_5af317c9-34df-48b4-8a8a-bf4007e1de99\",                          \"SEQUENCE_arima_90aef6b9-8922-4a0c-b625-b2c6f3d19fa4\"],                      \"subscribers\": [],                      \"creation_date\": \"2022-08-15T19:21:01.871587\",                      \"primary_scenario\": true}                  }                  ```            !!! Note              When the authorization feature is activated (available in Taipy Enterprise edition only), this endpoint              requires the `TAIPY_EDITOR` role.          parameters:          - in: query            name: config_id            schema:              type: string            description: The identifier of the scenario configuration.        responses:          201:            content:              application/json:                schema:                  type: object                  properties:                    message:                      type: string                      description: Status message.                    scenario: ScenarioSchema      \"\"\"        def __init__(self, **kwargs):          self.logger = kwargs.get(\"logger\")        def fetch_config(self, config_id):          config = Config.scenarios.get(config_id)          if not config:              raise NonExistingScenarioConfig(config_id)          return config        @_middleware      def get(self):          schema = ScenarioResponseSchema(many=True)          manager = _ScenarioManagerFactory._build_manager()          scenarios = [_to_model(REPOSITORY, scenario) for scenario in manager._get_all()]          return schema.dump(scenarios)        @_middleware      def post(self):          args = request.args          config_id = args.get(\"config_id\")            response_schema = ScenarioResponseSchema()          manager = _ScenarioManagerFactory._build_manager()            if not config_id:              raise ConfigIdMissingException            config = self.fetch_config(config_id)          scenario = manager._create(config)            return {              \"message\": \"Scenario was created.\",              \"scenario\": response_schema.dump(_to_model(REPOSITORY, scenario)),          }, 201      class ScenarioExecutor(Resource):      \"\"\"Execute a scenario        ---      post:        tags:          - api        description: |          Executes a scenario by *scenario_id*. If the scenario does not exist, a 404 error is returned.            !!! Example                === \"Curl\"                  ```shell                      curl -X POST http://localhost:5000/api/v1/scenarios/submit/SCENARIO_63cb358d-5834-4d73-84e4-a6343df5e08c                  ```                  In this example the REST API is served on port 5000 on localhost. We are using curl command line                  client.                    `SCENARIO_63cb358d-5834-4d73-84e4-a6343df5e08c` is the value of the *scenario_id* parameter. It                  represents the identifier of the Scenario we want to submit.                    Here is the output message example:                  ```                  {\"message\": \"Executed scenario SCENARIO_63cb358d-5834-4d73-84e4-a6343df5e08c.\"}                  ```                === \"Python\"                  This Python example requires the 'requests' package to be installed (`pip install requests`).                  ```python                      import requests                          response = requests.post(                          \"http://localhost:5000/api/v1/scenarios/submit/SCENARIO_63cb358d-5834-4d73-84e4-a6343df5e08c\")                          print(response)                          print(response.json())                  ```                  `SCENARIO_63cb358d-5834-4d73-84e4-a6343df5e08c` is the value of the *scenario_id* parameter. It                  represents the identifier of the Scenario we want to submit.                    Here is the output example:                  ```                  <Response [202]>                  {\"message\": \"Executed scenario SCENARIO_63cb358d-5834-4d73-84e4-a6343df5e08c.\"}                  ```            !!! Note              When the authorization feature is activated (available in Taipy Enterprise edition only), this endpoint              requires the `TAIPY_EXECUTOR` role.          parameters:          - in: path            name: scenario_id            schema:              type: string            description: The identifier of the scenario to submit.        responses:          202:            content:              application/json:                schema:                  type: object                  properties:                    message:                      type: string                      description: Status message.                    scenario: ScenarioSchema          404:            description: No scenario has the *scenario_id* identifier.      \"\"\"        def __init__(self, **kwargs):          self.logger = kwargs.get(\"logger\")        @_middleware      def post(self, scenario_id):          _get_or_raise(scenario_id)          manager = _ScenarioManagerFactory._build_manager()          manager._submit(scenario_id)          return {\"message\": f\"Scenario {scenario_id} was submitted.\"} "}
{"text": "#  # Licensed under the Apache License, Version 2.0 (the \"License\"); you may not use this file except in compliance with  # the License. You may obtain a copy of the License at  #  #        http://www.apache.org/licenses/LICENSE-2.0  #  # Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on  # an \"AS IS\" BASIS, WITHOUT 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 step_10 import *  from step_06 import ml_pipeline_cfg    from taipy import Config, Frequency  from taipy.gui import notify    # Create scenarios each week and compare them  scenario_daily_cfg = Config.configure_scenario(id=\"scenario\",                                                 pipeline_configs=[baseline_pipeline_cfg, ml_pipeline_cfg],                                                 frequency=Frequency.DAILY)    if __name__ == \"__main__\":      # Delete all entities      Config.configure_global_app(clean_entities_enabled=True)      tp.clean_all_entities()    # Change the inital scenario selector to see which scenarios are primary  scenario_selector = [(scenario.id, (\"*\" if scenario.is_primary else \"\") + scenario.name) for scenario in tp.get_scenarios()]      # Redefine update_scenario_selector to add \"*\" in the display name when the scnario is primary  def update_scenario_selector(state, scenario):      print(\"Updating scenario selector...\")      # Create the scenario name for the scenario selector      # This name changes dependind whether the scenario is primary or not      scenario_name = (\"*\" if scenario.is_primary else \"\") + scenario.name      print(scenario_name)      # Update the scenario selector      state.scenario_selector += [(scenario.id, scenario_name)]      selected_scenario_is_primary = None      # Change the create_scenario function to create a scenario with the selected frequency  def create_scenario(state):      print(\"Execution of scenario...\")      # Extra information for scenario      creation_date = state.day      name = create_name_for_scenario(state)        # Create a scenario with the week cycle      scenario = tp.create_scenario(scenario_daily_cfg, creation_date=creation_date, name=name)        state.selected_scenario = (scenario.id, name)        # Change the scenario that is currently selected      submit_scenario(state)      # This is the same code as in step_9_dynamic_scenario_creation.py  def submit_scenario(state):      print(\"Submitting scenario...\")      # Get the currently selected scenario      scenario = tp.get(state.selected_scenario[0])        # 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      # if state.day != scenario.day.read():      scenario.day.write(state_day)      # if int(state.n_predictions) != scenario.n_predictions.read():      scenario.n_predictions.write(int(state.n_predictions))      # if state.max_capacity != scenario.max_capacity.read():      scenario.max_capacity.write(int(state.max_capacity))      # if state.day != scenario.creation_date:      scenario.creation_date = state.day        # Execute the pipelines/code      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 make_primary(state):      print(\"Making the current scenario primary...\")      scenario = tp.get(state.selected_scenario[0])      # Take the current scenario primary      tp.set_primary(scenario)        # Update the scenario selector accordingly      state.scenario_selector = [(scenario.id, (\"*\" if scenario.is_primary else \"\") + scenario.name)                                 for scenario in tp.get_scenarios()]      state.selected_scenario_is_primary = True      def remove_scenario_from_selector(state, scenario: list):      # Take all the scenarios in the selector that doesn't have the scenario.id      state.scenario_selector = [(s[0], s[1]) for s in state.scenario_selector if s[0] != scenario.id]      state.selected_scenario = state.scenario_selector[-1]      def delete_scenario(state):      scenario = tp.get(state.selected_scenario[0])        if scenario.is_primary:          # Notify the user that primary scenarios can not be deleted          notify(state, \"info\", \"Cannot delete the primary scenario\")      else:          # Delete the scenario and the related objects (datanodes, tasks, jobs,...)          tp.delete(scenario.id)            # Update the scenario selector accordingly          remove_scenario_from_selector(state, scenario)      # Add a \"Delete scenario\" and a \"Make primary\" buttons  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/>  <|Create new scenario|button|on_action=create_scenario|>  |>  |>      <|part|render={len(scenario_selector) > 0}|  <|layout|columns=1 1|    <|layout|columns=1 1|  <|  ## Scenario \\n <|{selected_scenario}|selector|lov={scenario_selector}|dropdown|>  |>    <br/>  <br/>  <br/>  <br/>  <|Delete scenario|button|on_action=delete_scenario|active={len(scenario_selector)>0}|>  <|Make primary|button|on_action=make_primary|active={not(selected_scenario_is_primary) and len(scenario_selector)>0}|>  |>          <|  ## 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])      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 selected_scenario_is_primary indicating if the current scenario is primary or not          state.selected_scenario_is_primary = tp.get(state.selected_scenario[0]).is_primary            # 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(pages=pages).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": "from flask import Flask, render_template, redirect, url_for, request, flash  from werkzeug.utils import secure_filename  from uploads.file_handler import is_file_type_allowed, upload_file_to_s3, get_presigned_file_url  from localStoragePy import localStoragePy  from transformers import AutoTokenizer, pipeline  # from tensorflow.keras.preprocessing.sequence import pad_sequences  # from tensorflow.keras.models import load_model  from taipy.gui import Gui    import webbrowser  import tensorflow as tf  import pandas as pd  import numpy as np  import pytorch_pretrained_bert as ppb  assert 'bert-large-cased' in ppb.modeling.PRETRAINED_MODEL_ARCHIVE_MAP  app = Flask(__name__)  app.secret_key = '3d6f45a5fc12445dbac2f59c3b6c7cb1'  localStorage = localStoragePy('app', 'json')  target_arr = [\"df['col1'].nunique()\",               \"df.sort_values(by=['col1'],inplace =True)\",               \"df.sort_values(by=['col1', 'col2'],inplace =True)\",               \"df.sort_values(by=['col1', 'col2', 'col3'],inplace =True)\",               \"df.drop(columns = 'col1',inplace = True)\",               \"new_df=df.loc[:, ['col1','col2']]\",               \"df['col1'].value_counts()\",               \"<|{dataset}|chart|type=bar|x=col1|y=col2|height=100%|>\",               \"<|{dataset}|chart|type=pie|values=col2|labels=col1|height=100%|>\",               \"<|{dataset}|chart|mode=lines|x=col1|y=col2|>\"]  portNo = 8888  @app.route(\"/\", methods=['GET'])  def home():          return render_template('home.html')    @app.route(\"/upload-file\", methods=['POST'])  def upload_file():      if 'file' not in request.files:          flash('No file uploaded', 'danger')          return redirect(url_for('home'))            file_to_upload = request.files['file']      if file_to_upload.filename == '':          flash('No file uploaded', 'danger')          return redirect(url_for('home'))            if file_to_upload and is_file_type_allowed(file_to_upload.filename):          provided_file_name = secure_filename(file_to_upload.filename)          stored_file_name = upload_file_to_s3(file_to_upload, provided_file_name)            localStorage.setItem(\"stored_file_name\", stored_file_name)          localStorage.setItem(\"provided_file_name\", provided_file_name)            flash(f'{provided_file_name} was successfully uploaded', 'success')            return redirect(url_for('home'))    @app.route(\"/query\", methods=['POST'])  def query():      try:          query = request.form['query']          provided_file_name = localStorage.getItem(\"provided_file_name\")          stored_file_name = localStorage.getItem(\"stored_file_name\")          csv = get_presigned_file_url(stored_file_name, provided_file_name)          df = pd.read_csv(csv)          print(\"query: \" + query)          prediction_int, cols_requested = getPredictionInt(df, query)          if prediction_int < 7:              panda_query = target_arr[prediction_int]              print(panda_query)              for i in range(len(cols_requested)):                  panda_query = panda_query.replace(\"col\" + str(i+1), cols_requested[i])              exec(panda_query)              html_string = '''                  <html lang=\"en\">                  <head>                      <meta charset=\"UTF-8\">                      <meta http-equiv=\"X-UA-Compatible\" content=\"IE=edge\">                      <meta name=\"viewport\" content=\"width=device-width, initial-scale=1.0\">                      <link href=\"https://cdn.jsdelivr.net/npm/bootstrap@5.0.2/dist/css/bootstrap.min.css\" rel=\"stylesheet\">                  </head>                      <body>                          <div class=\"justify-content-center mt-5\">                              <div class=\"text-center\">                                  <h4 class=\"\">Download CSV                                       <a href='{new_presigned_url}'>                                      <svg xmlns=\"http://www.w3.org/2000/svg\" fill=\"none\" viewBox=\"0 0 24 24\" stroke-width=\"1.5\" stroke=\"currentColor\" style=\"width:20px; height:20px;\">                                          <path stroke-linecap=\"round\" stroke-linejoin=\"round\" d=\"M3 16.5v2.25A2.25 2.25 0 005.25 21h13.5A2.25 2.25 0 0021 18.75V16.5M16.5 12L12 16.5m0 0L7.5 12m4.5 4.5V3\" />                                      </svg>                                      </a>                                  </h4>                                  <p>Click <a href='/'>here</a> to return to home page</p>                                  {table}                              </div>                          </div>                      </body>                  </html>.              '''              filename = \"new.csv\"              df.to_csv(filename, index=False)              file_to_upload = open(\"new.csv\", 'rb')              new_provided_file_name = secure_filename(filename)              new_stored_file_name = upload_file_to_s3(file_to_upload, new_provided_file_name)                            new_presigned_url = get_presigned_file_url(new_stored_file_name, new_provided_file_name)              print(\"Presigned url: \" + new_presigned_url)              df = df.reset_index(drop=True)              html = df.to_html(classes='table table-striped table-bordered w-75 mx-auto')              html = html.replace(\"text-align: right;\", \"text-align: left;\")              toDisplay = html_string.format(table = html, new_presigned_url = new_presigned_url)              return toDisplay          else:              print(\"taipy\")              taipy_query = target_arr[prediction_int]              dataset = df              for i in range(len(cols_requested)):                  taipy_query = taipy_query.replace(\"col\" + str(i+1), cols_requested[i])              page = \"\"\"{0}\"\"\"              page = page.format(taipy_query)              gui = Gui(page)              global portNo              portNum = portNo              portNo += 1              webbrowser.open_new_tab('http://localhost:' + str(portNum))              gui.run(port=portNum)              print(\"hello world\")              return redirect(url_for('home'))      except:          print(\"Invalid query\")          flash('Invalid query', 'danger')          return redirect(url_for('home'))  def getPredictionInt(df, query):            cols = df.columns      sentence = query      words = sentence.split()      cols_requested = []      for item in cols:          for word in words:              if(item.upper() == word.upper()):                  cols_requested.append(item)        general_sentence = sentence      for i in range(len(cols_requested)):          general_sentence = general_sentence.replace(cols_requested[i], \"col\" + str(i+1))        model_id = \"tanishabhagwanani/distilbert-base-uncased-finetuned-emotion\"      classifier = pipeline(\"text-classification\", model=model_id)      custom_question = query      preds = classifier(custom_question, return_all_scores=True)      preds_df = pd.DataFrame(preds[0])      prediction_int = np.argmax(preds_df.score)      return prediction_int, cols_requested    if __name__=='__main__':      app.run(host=\"localhost\", port=8000, debug=True)"}
{"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": "import json      def add_line(source, line, step):      on_change_needed = ['step_02', 'step_09', 'step_11']        line = line.replace('Getting Started with Taipy', 'Getting Started with Taipy on Notebooks')      line = line.replace('(../src/', '(https://docs.taipy.io/getting_started/src/')      line = line.replace('(dataset.csv)', '(https://docs.taipy.io/getting_started/step_01/dataset.csv)')        if line.startswith('!['):          if step != 'index':              line = line.replace('(', '(https://docs.taipy.io/getting_started/' + step + '/')          else:              line = line.replace('(', '(https://docs.taipy.io/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('# We can use Gui(\"# Getting Started with Taipy\").run() directly\\n')          source.append('# However, we need a Markdown and Gui object to modify the content of the page\\n')          source.append('# in the Notebook\\n')          source.append('\\n')          source.append('main_page = Markdown(\"# Getting Started with Taipy\")\\n')          source.append('gui = Gui(main_page)\\n')          source.append('gui.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('gui.stop()\\n')          if step in on_change_needed:              source.append('gui.on_change = on_change\\n')          source.append(f'main_page.set_content({name_of_md})\\n')          source.append('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',                     'Some functions will be used in the Getting Started for Notebooks that are primarly used for Notebooks (`gui.stop()`, `gui.run()`, `gui.on_change`, `set_content()`)\\n',                     'To have more explanation on these different functions, you can find the documentation related [here](https://docs.taipy.io/manuals/gui/notebooks/)\\n',                     '**Warning**: Do not forget to stop your server when you are finished. You can do so by restarting your kernel.\\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__\":      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 step_10 import *  from step_06 import ml_pipeline_cfg    from taipy import Config, Frequency  from taipy.gui import notify    # Create scenarios each week and compare them  scenario_daily_cfg = Config.configure_scenario(id=\"scenario\",                                                 pipeline_configs=[baseline_pipeline_cfg, ml_pipeline_cfg],                                                 frequency=Frequency.DAILY)    if __name__ == \"__main__\":      # Delete all entities      Config.configure_global_app(clean_entities_enabled=True)      tp.clean_all_entities()    # Change the inital scenario selector to see which scenarios are primary  scenario_selector = [(scenario.id, (\"*\" if scenario.is_primary else \"\") + scenario.name) for scenario in tp.get_scenarios()]      # Redefine update_scenario_selector to add \"*\" in the display name when the scnario is primary  def update_scenario_selector(state, scenario):      print(\"Updating scenario selector...\")      # Create the scenario name for the scenario selector      # This name changes dependind whether the scenario is primary or not      scenario_name = (\"*\" if scenario.is_primary else \"\") + scenario.name      print(scenario_name)      # Update the scenario selector      state.scenario_selector += [(scenario.id, scenario_name)]      selected_scenario_is_primary = None      # Change the create_scenario function to create a scenario with the selected frequency  def create_scenario(state):      print(\"Execution of scenario...\")      # Extra information for scenario      creation_date = state.day      name = create_name_for_scenario(state)        # Create a scenario with the week cycle      scenario = tp.create_scenario(scenario_daily_cfg, creation_date=creation_date, name=name)        state.selected_scenario = (scenario.id, name)        # Change the scenario that is currently selected      submit_scenario(state)      # This is the same code as in step_9_dynamic_scenario_creation.py  def submit_scenario(state):      print(\"Submitting scenario...\")      # Get the currently selected scenario      scenario = tp.get(state.selected_scenario[0])        # 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      # if state.day != scenario.day.read():      scenario.day.write(state_day)      # if int(state.n_predictions) != scenario.n_predictions.read():      scenario.n_predictions.write(int(state.n_predictions))      # if state.max_capacity != scenario.max_capacity.read():      scenario.max_capacity.write(int(state.max_capacity))      # if state.day != scenario.creation_date:      scenario.creation_date = state.day        # Execute the pipelines/code      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 make_primary(state):      print(\"Making the current scenario primary...\")      scenario = tp.get(state.selected_scenario[0])      # Take the current scenario primary      tp.set_primary(scenario)        # Update the scenario selector accordingly      state.scenario_selector = [(scenario.id, (\"*\" if scenario.is_primary else \"\") + scenario.name)                                 for scenario in tp.get_scenarios()]      state.selected_scenario_is_primary = True      def remove_scenario_from_selector(state, scenario: list):      # Take all the scenarios in the selector that doesn't have the scenario.id      state.scenario_selector = [(s[0], s[1]) for s in state.scenario_selector if s[0] != scenario.id]      state.selected_scenario = state.scenario_selector[-1]      def delete_scenario(state):      scenario = tp.get(state.selected_scenario[0])        if scenario.is_primary:          # Notify the user that primary scenarios can not be deleted          notify(state, \"info\", \"Cannot delete the primary scenario\")      else:          # Delete the scenario and the related objects (datanodes, tasks, jobs,...)          tp.delete(scenario.id)            # Update the scenario selector accordingly          remove_scenario_from_selector(state, scenario)      # Add a \"Delete scenario\" and a \"Make primary\" buttons  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/>  <|Create new scenario|button|on_action=create_scenario|>  |>  |>      <|part|render={len(scenario_selector) > 0}|  <|layout|columns=1 1|    <|layout|columns=1 1|  <|  ## Scenario \\n <|{selected_scenario}|selector|lov={scenario_selector}|dropdown|>  |>    <br/>  <br/>  <br/>  <br/>  <|Delete scenario|button|on_action=delete_scenario|active={len(scenario_selector)>0}|>  <|Make primary|button|on_action=make_primary|active={not(selected_scenario_is_primary) and len(scenario_selector)>0}|>  |>          <|  ## 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%|>  |>  \"\"\"    # Redefine the multi_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 + \"\"\"|>  \"\"\"      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 selected_scenario_is_primary indicating if the current scenario is primary or not          state.selected_scenario_is_primary = tp.get(state.selected_scenario[0]).is_primary            # 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=multi_pages).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) "}