deepfos 1.1.60__py3-none-any.whl

deepfos/api/datatable.py

@@ -0,0 +1,341 @@
+"""
+APIs provided by data-table-mysql-server1-0
+
+generated by model_code_gen.py
+  - **filename** : ``data_table_mysql.py``
+  - **json timestamp** : ``2021-06-29 10:49:22``
+"""
+from .base import get, post, DynamicRootAPI, ChildAPI
+from .models.datatable_mysql import *
+from deepfos.lib.decorator import cached_property
+from typing import List, Dict, Union, Any, Awaitable
+
+
+__all__ = ['MySQLAPI', 'ClickHouseAPI', 'SQLServerAPI', 'OracleAPI',
+           'KingBaseAPI', 'GaussAPI', 'DaMengAPI', 'PostgreSQLAPI',
+           'DeepEngineAPI', 'DeepModelAPI', 'DeepModelKingBaseAPI']
+
+
+class DDLAPI(ChildAPI):
+    endpoint = '/datatable-edit-view'
+
+    @post('column-add')
+    def column_add(self, datatableColumnAddDTO: DatatableColumnAddDTO) -> Union[Any, Awaitable[Any]]:
+        """
+        新增列字段信息（后端组件调用）
+
+        给数据表新增列信息（后端组件调用）
+        """
+        return {'body': datatableColumnAddDTO}
+
+    @post('datatable-save')
+    def create_table(self, param: DatatableInfoSaveParam) -> Union[DatatableInfoSaveParam, Awaitable[DatatableInfoSaveParam]]:
+        """
+        数据表新建&编辑（后端组件调用）
+
+        """
+        return {'body': param}
+
+    @post('datatable-save-edit')
+    def datatable_save_edit(self, param: DatatableInfoSaveParam) -> Union[DatatableInfoSaveParam, Awaitable[DatatableInfoSaveParam]]:
+        """
+        数据表新建&编辑（前端调用）
+
+        """
+        return {'body': param}
+
+    @post('generateActualTableName')
+    def generateActualTableName(self, param: GenerateActualTableNameDTO) -> Union[Any, Awaitable[Any]]:
+        """
+        根据tableName生成ActualTableName
+
+        """
+        return {'body': param}
+
+    @post('only-check')
+    def only_check(self, param: DatatableInfoSaveParam) -> Union[DatatableInfoSaveParam, Awaitable[DatatableInfoSaveParam]]:
+        """
+        数据表编辑--仅校验（后端组件调用）
+
+        数据表保存、编辑前的仅校验接口（后端组件调用）
+        """
+        return {'body': param}
+
+    @post('only-save')
+    def only_save(self, param: DatatableInfoSaveParam) -> Union[DatatableInfoSaveParam, Awaitable[DatatableInfoSaveParam]]:
+        """
+        数据表编辑--仅保存（后端组件调用，新建时实际表名的末尾加随机数）
+
+        数据表保存、编辑前的仅保存接口（后端组件调用，新建时实际表名的末尾加随
+        机数）
+        """
+        return {'body': param}
+
+    @post('only-save-edit')
+    def only_save_edit(self, param: DatatableInfoSaveParam) -> Union[DatatableInfoSaveParam, Awaitable[DatatableInfoSaveParam]]:
+        """
+        数据表编辑--仅保存（后端组件调用，带实际表名就不做任何处理）
+
+        数据表保存、编辑前的仅保存接口（后端组件调用，带实际表名就不做任何处理
+        ）
+        """
+        return {'body': param}
+
+
+class DMLAPI(ChildAPI):
+    endpoint = '/datatable'
+
+    @post('actual-tablename')
+    def get_tablename(self, table_info: BaseElementInfo) -> Union[str, Awaitable[str]]:
+        """
+        获取数据表实际表名
+
+        通过elementName,folderId从元素信息获取数据表实际表
+        名
+        """
+        return {'body': table_info}
+
+    @post('batch-actual-tablename')
+    def batch_tablename(self, paramList: List[BaseElementInfo]) -> Union[dict, Awaitable[dict]]:
+        """
+        根据元素名称批量获取实际表名
+
+        """
+        return {'body': paramList}
+
+    @post('column-list')
+    def list_column(self, table_name: str) -> Union[Any, Awaitable[Any]]:
+        """
+        返回数据表字段列表信息
+
+        根据实际表名，查询数据表字段信息
+        """
+        return {'param': {'actualTableName': table_name}}
+
+    @post('column/column-name')
+    def column_column_name(self, param: DatatableColumnInfoDTO) -> Union[MiscModel, Awaitable[MiscModel]]:
+        """
+        根据列名获取数据表的Column信息
+
+        根据列名获取列表的详细信息
+        """
+        return {'body': param}
+
+    @post('custom-sql')
+    def run_sql(self, sql: str) -> Union[CustomSqlRespDTO, Awaitable[CustomSqlRespDTO]]:
+        """
+        自定义SQL执行(后端调用)--增删改查，支持多表联合查询
+        """
+        return {'body': {'sql': sql}}
+
+    @post('data-diff')
+    def data_diff(self, param: DatatableInfoBasicInfoDTO) -> Union[str, Awaitable[str]]:
+        """
+        判断数据表与实际表是否一致
+
+        判断数据表组件元素配置信息和实际物理数据表字段信息是否一致
+        """
+        return {'body': param}
+
+    @post('datatable-info-batch')
+    def datatable_info_batch(self, param: List[BaseElementInfo]) -> Union[List[DatatableInfoBasicInfoDTO], Awaitable[List[DatatableInfoBasicInfoDTO]]]:
+        """
+        批量获取数据表信息
+
+        批量通过elementName,folderId从元素信息获取数据表信
+        息
+        """
+        return {'body': param}
+
+    @post('delete-data')
+    def delete_data(self, param: DatatableDataDeleteDTO) -> Union[bool, Awaitable[bool]]:
+        """
+        删除数据表中的数据
+
+        """
+        return {'body': param}
+
+    @post('distinct-column-members')
+    def distinct_column_members(self, param: DatatableInfoMemberDTO) -> Union[List[str], Awaitable[List[str]]]:
+        """
+        查询数据表列字段，去重后的数据集合
+
+        根据列名查询数据表，该列去重后的数据集合
+        """
+        return {'body': param}
+
+    @post('execute-sql')
+    def execute_sql(self, datatableSelectDTO: DatatableSelectDTO) -> Union[Any, Awaitable[Any]]:
+        """
+        查询数据表数据
+
+        执行查询sql查询数据表的数据
+        """
+        return {'body': datatableSelectDTO}
+
+    @post('executeBatchSql')
+    def execute_batch_sql(self, sqls: List[str]):
+        """
+        执行多句增删改sql
+
+        Args:
+            sqls: 查询sql
+        """
+        return {'body': {
+            "elementBaseInfoParamMap": {},
+            "batchSql": sqls,
+            },
+        }
+
+    @post('insert')
+    def insert(self, param: DatatableInsertDTO) -> Union[bool, Awaitable[bool]]:
+        """
+        向数据表中写入数据
+
+        """
+        return {'body': param}
+
+    @post('physical-table-exist')
+    def physical_table_exist(self, param: PhysicalTableExistDTO) -> Union[str, Awaitable[str]]:
+        """
+        根据元素信息或者直接通过传参的实际表名，判断对应的物理数据表是否存在
+
+        优先通过元素信息获取到实际表名后，再判断物理表是否存在
+        """
+        return {'body': param}
+
+    @post('table-ifexists')
+    def table_ifexists(self, param: DatatableInfoCheckDTO) -> Union[bool, Awaitable[bool]]:
+        """
+        数据表是否存在
+
+        根据数据表名称判断数据表是否存在
+        """
+        return {'body': param}
+
+    @post('table-ifexists-physical')
+    def table_ifexists_physical(self, param: DatatableInfoCheckDTO) -> Union[bool, Awaitable[bool]]:
+        """
+        只判断物理数据表是否存在
+
+        根据数据表名称，只判断物理数据表是否存在
+        """
+        return {'body': param}
+
+    @post('table-info-field')
+    def table_info_field(self, elementList: List[BaseElementInfo]) -> Union[List[DatatableInfoBasicInfoDTO], Awaitable[List[DatatableInfoBasicInfoDTO]]]:
+        """
+        获取数据表元素信息（从平台获取信息）
+
+        返回数据表所有元素配置信息（从平台获取信息）
+        """
+        return {'body': elementList}
+
+    @post('table-info-field-physical')
+    def table_info_field_physical(self, elementList: List[BaseElementInfo]) -> Union[List[DatatableInfoBasicInfoDTO], Awaitable[List[DatatableInfoBasicInfoDTO]]]:
+        """
+        获取数据表元素信息（从物理表获取信息）
+
+        返回数据表所有元素配置信息（从物理表获取信息）
+        """
+        return {'body': elementList}
+
+    @post('update-data')
+    def update_data(self, param: DatatableDataUpdateDTO) -> Union[bool, Awaitable[bool]]:
+        """
+        更新数据表中的数据
+
+        """
+        return {'body': param}
+
+    @post('account')
+    def create_account(self) -> Union[AccountInfo, Awaitable[AccountInfo]]:
+        """
+        获取/更新数据库账号
+
+        """
+        return {'body': {"serverType": "python"}}
+
+
+class MySQLAPI(DynamicRootAPI, builtin=True):
+    """MySQL数据表组件接口"""
+    module_type = 'DAT_MYSQL'
+    default_version = (1, 0)
+    multi_version = False
+    cls_name = 'MySQLAPI'
+    module_name = 'deepfos.api.datatable'
+    api_version = (1, 0)
+
+    @cached_property
+    def ddl(self) -> DDLAPI:
+        """
+        数据表新建&编辑相关接口
+        """
+        return DDLAPI(self)
+
+    @cached_property
+    def dml(self) -> DMLAPI:
+        """
+        外部组件访问数据表相关接口
+        """
+        return DMLAPI(self)
+
+
+class ClickHouseAPI(MySQLAPI, builtin=True):
+    """ClickHouse数据表组件接口"""
+    module_type = 'DAT_CLICKHOUSE'
+    cls_name = 'ClickHouseAPI'
+
+
+class SQLServerAPI(MySQLAPI, builtin=True):
+    """SQLServer数据表组件接口"""
+    module_type = 'DAT_SQLSERVER'
+    cls_name = 'SQLServerAPI'
+
+
+class OracleAPI(MySQLAPI, builtin=True):
+    """Oracle数据表组件接口"""
+    module_type = 'DAT_ORACLE'
+    cls_name = 'OracleAPI'
+
+
+class KingBaseAPI(MySQLAPI, builtin=True):
+    """KingBase数据表组件接口"""
+    module_type = 'DAT_KINGBASE'
+    cls_name = 'KingBaseAPI'
+
+
+class GaussAPI(MySQLAPI, builtin=True):
+    """GaussDB数据表组件接口"""
+    module_type = 'DAT_GAUSS'
+    cls_name = 'GaussAPI'
+
+
+class DaMengAPI(OracleAPI, builtin=True):
+    """达梦数据表组件接口"""
+    module_type = 'DAT_DAMENG'
+    cls_name = 'DaMengAPI'
+
+
+class PostgreSQLAPI(MySQLAPI, builtin=True):
+    """PostgreSQL数据表组件接口"""
+    module_type = 'DAT_POSTGRESQL'
+    cls_name = 'PostgreSQLAPI'
+
+
+class DeepEngineAPI(MySQLAPI, builtin=True):
+    """DeepEngine数据表组件接口"""
+    module_type = 'DAT_DEEPENGINE'
+    cls_name = 'DeepEngineAPI'
+
+
+class DeepModelAPI(MySQLAPI, builtin=True):
+    """DeepModel数据表组件接口"""
+    module_type = 'DAT_DEEPMODEL'
+    cls_name = 'DeepModelAPI'
+
+
+class DeepModelKingBaseAPI(MySQLAPI, builtin=True):
+    """DeepModel KingBase数据表组件接口"""
+    module_type = 'DAT_DEEPMODEL_KB'
+    cls_name = 'DeepModelKingBaseAPI'

deepfos/api/deep_pipeline.py

@@ -0,0 +1,61 @@
+from typing import Union, Any, Awaitable
+
+from deepfos.lib.decorator import cached_property
+from .base import DynamicRootAPI, ChildAPI, get, post
+from .models.deep_pipeline import *
+
+__all__ = ['DeepPipelineAPI']
+
+
+class RunAPI(ChildAPI):
+    """数据流的执行、获取执行信息等逻辑"""
+    endpoint = '/'
+
+    @post('run')
+    def run_async(self, run_info: RunInfo) -> Union[str, Awaitable[str]]:
+        """
+        异步执行数据流
+        异步执行数据流，返回任务id
+        """
+        return {'body': run_info}
+
+    @get('run')
+    def result(self, task_id: str, timeout: int = None) -> Union[Any, Awaitable[Any]]:
+        """获取执行结果"""
+        return {'param': {'timeout': timeout}, 'path': f'{task_id}/result'}
+
+
+class FlowAPI(ChildAPI):
+    """数据流定义相关接口"""
+    endpoint = '/flow'
+
+    @get('')
+    def open(self, element_name: str, folder_id: str, version: str) -> Union[FlowInfo, Awaitable[FlowInfo]]:
+        """查看数据流"""
+        return {
+            'param': {
+                'elementName': element_name,
+                'folderId': folder_id,
+                'version': version
+            }
+        }
+
+
+class DeepPipelineAPI(DynamicRootAPI, builtin=True):
+    """DeepPipeline组件接口"""
+    module_type = 'DPL'
+    default_version = (3, 0)
+    multi_version = False
+    cls_name = 'DeepPipelineAPI'
+    module_name = 'deepfos.api.deep_pipeline'
+    api_version = (3, 0)
+
+    @cached_property
+    def run(self) -> RunAPI:
+        """数据流的执行、获取执行信息等逻辑"""
+        return RunAPI(self)
+
+    @cached_property
+    def flow(self) -> FlowAPI:
+        """数据流定义相关接口"""
+        return FlowAPI(self)

deepfos/api/deepconnector.py

@@ -0,0 +1,36 @@
+from typing import Union, Awaitable
+
+from deepfos.element.base import T_ElementInfoWithServer
+from deepfos.lib.decorator import cached_property
+
+from .base import ChildAPI, get, RootAPI
+from .models.deepconnector import *
+
+
+__all__ = ['DeepConnectorAPI']
+
+
+class DataSourceAPI(ChildAPI):
+    """连接信息相关接口"""
+    endpoint = '/apis/v3/ds/spaces/{space}/apps/{app}'
+
+    @get('connection-info', data_wrapped=False)
+    def connection_info(self, element_info: T_ElementInfoWithServer) -> Union[ConnectionInfoVo, Awaitable[ConnectionInfoVo]]:
+        return {
+            'param': {
+                'elementName': element_info.elementName,
+                'folderId': element_info.folderId
+            }
+        }
+
+
+class DeepConnectorAPI(RootAPI):
+    """连接器组件接口"""
+    prefix = lambda: 'http://deep-connector-server'
+    url_need_format = True
+    module_type = 'CONN'
+
+    @cached_property
+    def datasource(self) -> DataSourceAPI:
+        """连接信息相关接口"""
+        return DataSourceAPI(self)

deepfos/api/deepfos_task.py

@@ -0,0 +1,92 @@
+"""
+APIs provided by deepfos-task-server
+
+generated by api_code_gen.py
+  - **filename** : ``deepfos_task.py``
+  - **json timestamp** : ``2023-02-22 14:40:20``
+"""
+from deepfos.api.base import RootAPI, ChildAPI, get, post
+from .models.deepfos_task import *
+from deepfos.options import OPTION
+from deepfos.lib.decorator import cached_property
+from typing import List, Dict, Union, Any, Awaitable, Optional
+
+
+__all__ = ['TaskAPI']
+
+
+class TaskInstance(ChildAPI):
+    endpoint = '/api/deepfos/task'
+
+    @post('instance/period/create')
+    def instance_period_create(self, periodTaskCreateDTO: PeriodicTaskCreateInfo) -> Union[PeriodicTaskViewInfo, Awaitable[PeriodicTaskViewInfo]]:
+        """
+        创建一个周期任务实例
+
+        """
+        return {'body': periodTaskCreateDTO}
+
+    @post('instance/scheduled/create')
+    def instance_scheduled_create(self, scheduledTaskCreateDTO: ScheduledTaskCreateInfo) -> Union[ScheduledTaskViewInfo, Awaitable[ScheduledTaskViewInfo]]:
+        """
+        创建一个定时任务实例
+
+        """
+        return {'body': scheduledTaskCreateDTO}
+
+    @post('search')
+    def search(self, taskSearchDTO: TaskSearchDTO) -> Union[List[Optional[TTaskInfo]], Awaitable[List[Optional[TTaskInfo]]]]:
+        """
+        根据筛选条件查询任务配置
+
+        """
+        return {'body': taskSearchDTO}
+
+
+class Job(ChildAPI):
+    endpoint = '/job'
+
+    @post('batch-add')
+    def batch_add(self, jobCreateDtoList: List[JobCreateDto]) -> Union[int, Awaitable[int]]:
+        """
+        作业批量创建接口
+
+        """
+        return {'body': jobCreateDtoList}
+
+    @get('current-content')
+    def query_current_content(self, batchId: str = None, jobId: str = None) -> Union[List[JobCurrentContentDTO], Awaitable[List[JobCurrentContentDTO]]]:
+        """
+        根据jobId获取等待中与运行中作业与作业明细信息
+
+        """
+        return {'param': {'batchId': batchId, 'jobId': jobId}}
+
+    @post('current-content')
+    def current_content(self, jobSearchDTO: JobSearchDTO) -> Union[JobCurrentContentDTOResp, Awaitable[JobCurrentContentDTOResp]]:
+        """
+        根据筛选条件获取等待中与运行中作业与作业明细信息
+
+        """
+        return {'body': jobSearchDTO}
+
+
+class TaskAPI(RootAPI):
+    """任务管理接口"""
+    prefix = lambda: OPTION.server.deepfos_task
+
+    @cached_property
+    def task_instance(self) -> TaskInstance:
+        """
+        任务相关接口
+        """
+        return TaskInstance(self)
+
+    @cached_property
+    def job(self) -> Job:
+        """
+        作业相关接口
+        """
+        return Job(self)
+
+