deepfos 1.1.60__py3-none-any.whl

deepfos/__init__.py

@@ -0,0 +1,6 @@
+# from .core import *
+from .options import OPTION, set_option, show_option
+
+from . import _version
+__version__ = _version.get_versions()['version']
+__product_version__ = '3.0.0'

deepfos/_version.py

@@ -0,0 +1,21 @@
+
+# This file was generated by 'versioneer.py' (0.20) from
+# revision-control system data, or from the parent directory name of an
+# unpacked source archive. Distribution tarballs contain a pre-generated copy
+# of this file.
+
+import json
+
+version_json = '''
+{
+ "date": "2025-02-19T15:49:28+0800",
+ "dirty": false,
+ "error": null,
+ "full-revisionid": "fd1a0dfd27f3bf0d25680e7593fbcdb9d43c7b33",
+ "version": "1.1.60"
+}
+'''  # END VERSION_JSON
+
+
+def get_versions():
+    return json.loads(version_json)

deepfos/algo/graph.py

@@ -0,0 +1,171 @@
+from collections import Counter
+
+
+class DAGraph:
+    """A directed acyclic graph of objects and their dependencies.
+
+    Supports a robust topological sort
+    to detect the order in which they must be handled.
+
+    Takes an optional iterator of ``(obj, dependencies)``
+    tuples to build the graph from.
+
+    Warning:
+        Does not support cycle detection.
+    """
+
+    def __init__(self, it=None):
+        self.adjacent = {}
+        if it is not None:
+            self.update(it)
+
+    def add_edge(self, A, B):
+        """Add an edge from object ``A`` to object ``B``.
+
+        I.e. ``A`` depends on ``B``.
+        """
+        self.adjacent.setdefault(A, []).append(B)
+
+    def connect(self, graph):
+        """Add nodes from another graph."""
+        self.adjacent.update(graph.adjacent)
+
+    def valency_of(self, vertex):
+        """Return the valency (degree) of a vertex in the graph."""
+        if vertex not in self:
+            return 0
+
+        adj_len = [len(self[vertex])]
+        for node in self[vertex]:
+            adj_len.append(self.valency_of(node))
+        return sum(adj_len)
+
+    def update(self, edges):
+        """Update graph with data from a list of ``(obj, deps)`` tuples."""
+        for vertex, successors in edges:
+            for succ in successors:
+                self.add_edge(vertex, succ)
+
+    def edges(self):
+        """Return generator that yields for all edges in the graph."""
+        return (obj for obj, adj in self.items() if adj)
+
+    def topsort(self):
+        """Sort the graph topologically.
+
+        Perform Khan's simple topological sort algorithm from '62.
+
+        See https://en.wikipedia.org/wiki/Topological_sorting
+        """
+        count = Counter()
+        result = []
+        getter = self.adjacent.get
+
+        for node in self:
+            for successor in self[node]:
+                count[successor] += 1
+        ready = [node for node in self if not count[node]]
+
+        while ready:
+            node = ready.pop()
+            result.append(node)
+
+            for successor in getter(node, []):
+                count[successor] -= 1
+                if count[successor] == 0:
+                    ready.append(successor)
+
+        return result
+
+    def _tarjan72(self):
+        """Perform Tarjan's algorithm to find strongly connected components.
+
+        See Also:
+            :wikipedia:`Tarjan%27s_strongly_connected_components_algorithm`
+        """
+        result, stack, low = [], [], {}
+        getter = self.adjacent.get
+
+        def visit(node):
+            if node in low:
+                return
+            num = len(low)
+            low[node] = num
+            stack_pos = len(stack)
+            stack.append(node)
+
+            for successor in getter(node, []):
+                visit(successor)
+                low[node] = min(low[node], low[successor])
+
+            if num == low[node]:
+                component = tuple(stack[stack_pos:])
+                stack[stack_pos:] = []
+                result.append(component)
+                for item in component:
+                    low[item] = len(self)
+
+        for n in self:
+            visit(n)
+
+        return result
+
+    def __iter__(self):
+        return self.adjacent.__iter__()
+
+    def __getitem__(self, node):
+        return self.adjacent.__getitem__(node)
+
+    def __len__(self):
+        return self.adjacent.__len__()
+
+    def __contains__(self, obj):
+        return self.adjacent.__contains__(obj)
+
+    def _iterate_items(self):
+        return self.adjacent.items()
+
+    items = iteritems = _iterate_items
+
+    @property
+    def is_acyclic(self):
+        scc = self._tarjan72()
+        return all(len(item) == 1 for item in scc)
+
+    def __repr__(self):
+        return '\n'.join(self.repr_node(N) for N in self)
+
+    def repr_node(self, obj, level=1, fmt='{0}({1})'):
+        output = [fmt.format(obj, self.valency_of(obj))]
+        if obj in self:
+            for other in self[obj]:
+                d = fmt.format(other, self.valency_of(other))
+                output.append('     ' * level + d)
+                output.extend(self.repr_node(other, level + 1).split('\n')[1:])
+        return '\n'.join(output)
+
+    def topsort_ori(self):
+        """Sort the graph topologically.
+
+        Returns:
+            List: of objects in the order in which they must be handled.
+        """
+        graph = self.__class__()
+        components = self._tarjan72()
+
+        NC = {
+            node: component for component in components for node in component
+        }
+        for component in components:
+            graph.add_arc(component)
+        for node in self:
+            node_c = NC[node]
+            for successor in self[node]:
+                successor_c = NC[successor]
+                if node_c != successor_c:
+                    graph.add_edge(node_c, successor_c)
+        return [t[0] for t in graph.topsort()]
+
+    def add_arc(self, obj):
+        """Add an object to the graph."""
+        self.adjacent.setdefault(obj, [])

deepfos/algo/segtree.py

@@ -0,0 +1,31 @@
+"""
+Segment Tree
+"""
+
+from typing import Protocol, Sequence, Optional, Callable, Iterable, Any
+
+
+class NodeLike(Protocol):
+    name: str
+    parent: Optional['NodeLike']
+    children: Sequence['NodeLike']
+
+
+class Visitor:
+    def __init__(self, on_node: Callable[[NodeLike], Any]):
+        self.on_node = on_node
+
+    def visit(self, node: NodeLike):
+        for node in self.iter_node(node):
+            self.on_node(node)
+
+    def iter_node(self, node: NodeLike) -> Iterable[NodeLike]:
+        raise NotImplementedError()
+
+
+class DFVisitor(Visitor):
+    def iter_node(self, node: NodeLike) -> Iterable[NodeLike]:
+        yield node
+        for child in node.children:
+            yield from self.iter_node(child)
+

deepfos/api/V1_1/business_model.py

@@ -0,0 +1,119 @@
+"""
+APIs provided by business-model-server1-1
+
+generated by api_code_gen.py
+  - **filename** : ``business_model.py``
+  - **json timestamp** : ``2023-03-02 16:19:07``
+"""
+from deepfos.api.base import get, post, DynamicRootAPI, ChildAPI
+from .models.business_model import *
+from deepfos.lib.decorator import cached_property
+from typing import List, Dict, Union, Any, Awaitable
+
+import deepfos.api.business_model as last_ver
+
+__all__ = ['BusinessModelAPI']
+
+
+class ModelAPI(last_ver.ModelAPI):
+    endpoint = '/business'
+
+    @post('model')
+    def save(self, logicTableInfo: BusinessModelDTOReq) -> Union[BusinessModelResultVO, Awaitable[BusinessModelResultVO]]:
+        """
+        业务模型-配置-基础配置-保存
+
+        业务模型配置(不含权限)保存，使用场景：1、通过页面配置业务模型保存时
+        使用
+        """
+        return {'body': logicTableInfo}
+
+
+class ApprovalAPI(last_ver.ApprovalAPI):
+    endpoint = '/business/model'
+
+
+
+class DataAPI(ChildAPI):
+    endpoint = '/business/model/data'
+
+    @post('save')
+    def save(self, modelDataSaveDTO: ModelDataSaveDTO) -> Union[List[ModelDataReturnDTO], Awaitable[List[ModelDataReturnDTO]]]:
+        """
+        基于业务模型的数据保存，应用场景：业务明细表使用视图保存。
+        """
+        return {'body': modelDataSaveDTO}
+
+
+class ConfigureAPI(last_ver.ConfigureAPI):
+    endpoint = '/business/model/form'
+
+    @get('structure/top')
+    def structure_top(self, elementName: str, folderId: str = None, path: str = None) -> Union[StructureDTO, Awaitable[StructureDTO]]:
+        """
+        业务模型-基础配置相关-主表配置查询接口
+
+        object 含数据表信息、字段信息、业务主键、冗余字段等
+        """
+        return {'param': {'elementName': elementName, 'folderId': folderId, 'path': path}}
+
+    @get('structures')
+    def structures(self, elementName: str, folderId: str = None, path: str = None) -> Union[List[StructureDTO], Awaitable[List[StructureDTO]]]:
+        """
+        业务模型表-基础配置相关-查询接口模型元素
+
+        list 含数据表信息、字段信息、业务主键、冗余字段等
+        """
+        return {'param': {'elementName': elementName, 'folderId': folderId, 'path': path}}
+
+
+class PermissionAPI(last_ver.PermissionAPI):
+    endpoint = '/business/model'
+
+
+
+class BusinessModelAPI(DynamicRootAPI, builtin=True):
+    """业务模型组件接口"""
+    module_type = 'BCUB'
+    default_version = (1, 0)
+    multi_version = True
+    cls_name = 'BusinessModelAPI'
+    module_name = 'deepfos.api.V1_1.business_model'
+    api_version = (1, 1)
+
+    @cached_property
+    def model(self) -> ModelAPI:
+        """
+        业务模型基础配置
+        """
+        return ModelAPI(self)
+
+    @cached_property
+    def approval(self) -> ApprovalAPI:
+        """
+        业务模型审批流相关接口
+        """
+        return ApprovalAPI(self)
+
+    @cached_property
+    def data(self) -> DataAPI:
+        """
+        业务模型数据相关接口
+        """
+        return DataAPI(self)
+
+    @cached_property
+    def configure(self) -> ConfigureAPI:
+        """
+        业务模型基本配置相关接口
+        """
+        return ConfigureAPI(self)
+
+    @cached_property
+    def permission(self) -> PermissionAPI:
+        """
+        业务模型权限配置
+        """
+        return PermissionAPI(self)
+
+