text stringlengths 0 105k |
|---|
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" ... |
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 ... |
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 dic... |
# # Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with # the License. You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software distributed u... |
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 ... |
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): in... |
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 ... |
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 exte... |
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... |
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(MdP... |
from .parser import _TaipyHTMLParser |
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_propert... |
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... |
"""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 ... |
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 va... |
from algos import clean_data from taipy import Config, Frequency, Scope def configure(): # ################################################################################################################## # PLACEHOLDER: Add your scenario configurations here ... |
from taipy import Config def configure(): Config.load("config/config.toml") return Config.scenarios["scenario_configuration"] |
def clean_data(df, replacement_type): df = df.fillna(replacement_type) return df |
from .algos import clean_data |
from .job_page import job_page from .scenario_page import scenario_page |
from taipy.gui import Markdown selected_scenario = None selected_data_node = None content = "" root = Markdown("pages/root.md") |
from .job_page import job_page |
from taipy.gui import Markdown job_page = Markdown("pages/job_page/job_page.md") |
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": ... |
from .scenario_page import scenario_page |
# 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... |
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 }}".uppe... |
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... |
# # Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with # the License. You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software distributed u... |
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.commun... |
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={ ... |
""" 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 conf... |
from .config import * |
""" 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 Pyth... |
from algorithms import * |
from .root import root_page |
""" 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") |
""" 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") |
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.') |
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 = imp... |
from ._GuiCoreLib import _GuiCore def _init_gui_core(): from taipy.gui import Gui Gui.add_library(_GuiCore()) _init_gui_core() |
from ._init import * |
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 .... |
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 ... |
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 _DoNo... |
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 := v... |
from .rest import Rest |
# # Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with # the License. You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software distributed u... |
"""# 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 Taip... |
"""Extensions registry All extensions here are used as singletons and initialized in application factory """ from .commons.apispec import APISpecExt apispec = APISpecExt() |
# # Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with # the License. You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software distributed u... |
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( ... |
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 _Task... |
# # Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with # the License. You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software distributed u... |
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 ... |
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 isin... |
"""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 e... |
from . import error_handler, views __all__ = ["views", "error_handler"] |
from flask import jsonify from marshmallow import ValidationError from taipy.core.exceptions.exceptions import ( NonExistingCycle, NonExistingDataNode, NonExistingDataNodeConfig, NonExistingJob, NonExistingScenario, NonExistingScenarioConfig, NonExistingSequence, NonExistingS... |
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, CycleR... |
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 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 ..ex... |
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 _Job... |
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 .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, SequenceRes... |
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.ex... |
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 ... |
# # Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with # the License. You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software distributed u... |
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(*arg... |
# # Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with # the License. You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software distributed u... |
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): ... |
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 ... |
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.Str... |
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.Strin... |
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 = field... |
from .cycle import CycleResponseSchema, CycleSchema from .datanode import ( CSVDataNodeConfigSchema, DataNodeConfigSchema, DataNodeFilterSchema, DataNodeSchema, ExcelDataNodeConfigSchema, GenericDataNodeConfigSchema, InMemoryDataNodeConfigSchema, JSONDataNodeConfigSchema, M... |
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) la... |
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 ... |
from taipy.gui import Gui from pages.examples import page_examples pages = {"/":""" Cette page est générée avec Taipy. Voir taipy.io pour plus d'informations <|navbar|>""", "Examples":page_examples} if __name__=="__main__": gui = Gui(pages=pages) gui.run(port=5006) |
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} ... |
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_vgg1... |
msg = "Hello world" print(msg) |
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, v... |
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... |
""" 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 impo... |
""" 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['NGRA... |
""" Module Name: Page Markdown Template Author: Kenneth Leung Last Modified: 19 Mar 2023 """ data_page = """ # Extracted arXiv Abstracts <|{df}|table|> """ |
""" 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( q... |
""" 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 in... |
from taipy.gui import Gui from pages import * pages = { "/": root_page, "pages": pages } if __name__ == "__main__": gui = Gui(pages=pages) gui.run(title="ui") |
from .root import root_page from .pages.pages import pages |
""" """ from taipy.gui import Markdown root_page = Markdown("pages/root.md") |
""" <|{value}|text|format=%.2f|> """ from taipy.gui import Markdown pages = Markdown("pages/pages/pages.md") |
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 betwee... |
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, ... |
""" 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 *... |
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", st... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.