wedata-pre-code 1.0.0__tar.gz

wedata_pre_code-1.0.0/PKG-INFO

@@ -0,0 +1,192 @@
+Metadata-Version: 2.4
+Name: wedata-pre-code
+Version: 1.0.0
+Summary: WeData平台的预执行代码库，为机器学习实验提供与MLflow的深度集成
+Author-email: WeData Team <wedata@tencent.com>
+License: MIT
+Project-URL: Homepage, https://wedata.tencent.com
+Project-URL: Documentation, https://wedata.tencent.com/docs
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+Requires-Dist: mlflow>=2.0.0
+Provides-Extra: dev
+Requires-Dist: pytest>=6.0.0; extra == "dev"
+Requires-Dist: black>=21.0.0; extra == "dev"
+Requires-Dist: flake8>=3.9.0; extra == "dev"
+
+# WeData Pre-Code Library
+
+WeData平台的预执行代码库，为机器学习实验提供与MLflow的深度集成和WeData平台的功能增强。
+
+## 项目概述
+
+本项目提供了两个版本的WeData客户端，用于在WeData平台上运行机器学习实验时提供以下功能：
+
+- **MLflow集成增强**：自动注入WeData平台特定的标签和过滤条件
+- **权限控制**：基于项目/工作空间的权限验证机制
+- **URL生成**：自动生成实验和运行的查看链接
+- **环境配置**：自动设置运行环境变量
+
+## 版本说明
+
+### Wedata2PreCodeClient (WeData 2.0版本)
+
+适用于WeData 2.0平台的客户端，主要特性：
+
+- 基于项目ID进行权限控制
+- 支持国内站和国际站URL模板
+- 自动注入项目标签和机器学习类型标签
+- 提供完整的MLflow客户端装饰器
+
+### Wedata3PreCodeClient (WeData 3.0版本)
+
+适用于WeData 3.0平台的客户端，主要特性：
+
+- 基于工作空间ID进行权限控制
+- 支持更灵活的配置选项
+- 增强的标签注入和验证机制
+- 支持机器学习和深度学习两种实验类型
+
+## 安装和使用
+
+### 安装依赖
+
+```bash
+pip install mlflow
+```
+
+### 使用Wedata2PreCodeClient
+
+```python
+from wedata_pre_code.wedata2.client import Wedata2PreCodeClient
+
+# 初始化客户端
+client = Wedata2PreCodeClient(
+    wedata_project_id="your_project_id",
+    wedata_notebook_engine="your_engine",
+    qcloud_uin="your_uin",
+    qcloud_subuin="your_subuin",
+    wedata_default_feature_store_database="your_db",
+    wedata_feature_store_databases="your_dbs",
+    qcloud_region="your_region",
+    mlflow_tracking_uri="your_tracking_uri",
+    kernel_task_name="task_name",
+    kernel_task_id="task_id",
+    kernel_region="region",
+    kernel_is_international=False
+)
+
+# 现在可以使用MLflow客户端，会自动应用WeData的增强功能
+import mlflow
+mlflow.start_run()
+# ... 你的实验代码
+```
+
+### 使用Wedata3PreCodeClient
+
+```python
+from wedata_pre_code.wedata3.client import Wedata3PreCodeClient
+
+# 初始化客户端
+client = Wedata3PreCodeClient(
+    workspace_id="your_workspace_id",
+    mlflow_tracking_uri="your_tracking_uri",
+    base_url="your_base_url",
+    region="your_region",
+    run_context_data="your_context_data"
+)
+
+# 现在可以使用MLflow客户端，会自动应用WeData的增强功能
+import mlflow
+mlflow.start_run()
+# ... 你的实验代码
+```
+
+## 功能特性
+
+### 自动标签注入
+
+- 自动为实验、运行和模型注入WeData平台标签
+- 包括项目ID、工作空间ID、机器学习类型等信息
+- 确保数据在平台上的可追溯性
+
+### 权限验证
+
+- 在执行敏感操作前验证权限
+- 防止跨项目/工作空间的未授权操作
+- 保护内置标签不被修改
+
+### URL生成
+
+- 自动生成实验和运行的查看URL
+- 在运行终止时显示访问链接
+- 方便用户快速访问实验结果
+
+### 环境配置
+
+- 自动设置MLflow跟踪URI
+- 配置运行上下文环境变量
+- 支持国际站和国内站的不同配置
+
+## 项目结构
+
+```
+pre-execute/
+├── src/
+│   └── wedata_pre_code/
+│       ├── __init__.py
+│       ├── client.py              # 主客户端入口
+│       ├── common/
+│       │   ├── __init__.py
+│       │   └── base_client.py     # 基础客户端类
+│       ├── wedata2/
+│       │   ├── __init__.py
+│       │   └── client.py          # WeData 2.0客户端
+│       └── wedata3/
+│           ├── __init__.py
+│           └── client.py          # WeData 3.0客户端
+├── docs/                          # 文档目录
+├── pyproject.toml                 # 项目配置
+├── requirement.txt                # 依赖文件
+└── README.md                     # 项目说明
+```
+
+## 开发指南
+
+### 添加新的装饰器
+
+要添加新的MLflow客户端方法装饰器，可以参考现有的实现模式：
+
+1. 在相应的客户端类中定义装饰器函数
+2. 使用`@wraps`保留原函数属性
+3. 在装饰器内部实现特定的逻辑
+4. 将装饰器应用到目标MLflow方法
+
+### 测试
+
+确保在修改代码后测试以下场景：
+
+- 正常创建实验和运行
+- 权限验证功能
+- 标签注入的正确性
+- URL生成的准确性
+
+## 注意事项
+
+- 确保MLflow服务器配置正确
+- 验证环境变量设置完整
+- 注意不同版本客户端的参数差异
+- 在生产环境使用前进行充分测试
+
+## 支持与反馈
+
+如有问题或建议，请联系WeData平台技术支持团队。

wedata_pre_code-1.0.0/README.md

@@ -0,0 +1,167 @@
+# WeData Pre-Code Library
+
+WeData平台的预执行代码库，为机器学习实验提供与MLflow的深度集成和WeData平台的功能增强。
+
+## 项目概述
+
+本项目提供了两个版本的WeData客户端，用于在WeData平台上运行机器学习实验时提供以下功能：
+
+- **MLflow集成增强**：自动注入WeData平台特定的标签和过滤条件
+- **权限控制**：基于项目/工作空间的权限验证机制
+- **URL生成**：自动生成实验和运行的查看链接
+- **环境配置**：自动设置运行环境变量
+
+## 版本说明
+
+### Wedata2PreCodeClient (WeData 2.0版本)
+
+适用于WeData 2.0平台的客户端，主要特性：
+
+- 基于项目ID进行权限控制
+- 支持国内站和国际站URL模板
+- 自动注入项目标签和机器学习类型标签
+- 提供完整的MLflow客户端装饰器
+
+### Wedata3PreCodeClient (WeData 3.0版本)
+
+适用于WeData 3.0平台的客户端，主要特性：
+
+- 基于工作空间ID进行权限控制
+- 支持更灵活的配置选项
+- 增强的标签注入和验证机制
+- 支持机器学习和深度学习两种实验类型
+
+## 安装和使用
+
+### 安装依赖
+
+```bash
+pip install mlflow
+```
+
+### 使用Wedata2PreCodeClient
+
+```python
+from wedata_pre_code.wedata2.client import Wedata2PreCodeClient
+
+# 初始化客户端
+client = Wedata2PreCodeClient(
+    wedata_project_id="your_project_id",
+    wedata_notebook_engine="your_engine",
+    qcloud_uin="your_uin",
+    qcloud_subuin="your_subuin",
+    wedata_default_feature_store_database="your_db",
+    wedata_feature_store_databases="your_dbs",
+    qcloud_region="your_region",
+    mlflow_tracking_uri="your_tracking_uri",
+    kernel_task_name="task_name",
+    kernel_task_id="task_id",
+    kernel_region="region",
+    kernel_is_international=False
+)
+
+# 现在可以使用MLflow客户端，会自动应用WeData的增强功能
+import mlflow
+mlflow.start_run()
+# ... 你的实验代码
+```
+
+### 使用Wedata3PreCodeClient
+
+```python
+from wedata_pre_code.wedata3.client import Wedata3PreCodeClient
+
+# 初始化客户端
+client = Wedata3PreCodeClient(
+    workspace_id="your_workspace_id",
+    mlflow_tracking_uri="your_tracking_uri",
+    base_url="your_base_url",
+    region="your_region",
+    run_context_data="your_context_data"
+)
+
+# 现在可以使用MLflow客户端，会自动应用WeData的增强功能
+import mlflow
+mlflow.start_run()
+# ... 你的实验代码
+```
+
+## 功能特性
+
+### 自动标签注入
+
+- 自动为实验、运行和模型注入WeData平台标签
+- 包括项目ID、工作空间ID、机器学习类型等信息
+- 确保数据在平台上的可追溯性
+
+### 权限验证
+
+- 在执行敏感操作前验证权限
+- 防止跨项目/工作空间的未授权操作
+- 保护内置标签不被修改
+
+### URL生成
+
+- 自动生成实验和运行的查看URL
+- 在运行终止时显示访问链接
+- 方便用户快速访问实验结果
+
+### 环境配置
+
+- 自动设置MLflow跟踪URI
+- 配置运行上下文环境变量
+- 支持国际站和国内站的不同配置
+
+## 项目结构
+
+```
+pre-execute/
+├── src/
+│   └── wedata_pre_code/
+│       ├── __init__.py
+│       ├── client.py              # 主客户端入口
+│       ├── common/
+│       │   ├── __init__.py
+│       │   └── base_client.py     # 基础客户端类
+│       ├── wedata2/
+│       │   ├── __init__.py
+│       │   └── client.py          # WeData 2.0客户端
+│       └── wedata3/
+│           ├── __init__.py
+│           └── client.py          # WeData 3.0客户端
+├── docs/                          # 文档目录
+├── pyproject.toml                 # 项目配置
+├── requirement.txt                # 依赖文件
+└── README.md                     # 项目说明
+```
+
+## 开发指南
+
+### 添加新的装饰器
+
+要添加新的MLflow客户端方法装饰器，可以参考现有的实现模式：
+
+1. 在相应的客户端类中定义装饰器函数
+2. 使用`@wraps`保留原函数属性
+3. 在装饰器内部实现特定的逻辑
+4. 将装饰器应用到目标MLflow方法
+
+### 测试
+
+确保在修改代码后测试以下场景：
+
+- 正常创建实验和运行
+- 权限验证功能
+- 标签注入的正确性
+- URL生成的准确性
+
+## 注意事项
+
+- 确保MLflow服务器配置正确
+- 验证环境变量设置完整
+- 注意不同版本客户端的参数差异
+- 在生产环境使用前进行充分测试
+
+## 支持与反馈
+
+如有问题或建议，请联系WeData平台技术支持团队。

wedata_pre_code-1.0.0/pyproject.toml

@@ -0,0 +1,43 @@
+[build-system]
+requires = ["setuptools>=45", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "wedata-pre-code"
+version = "1.0.0"
+description = "WeData平台的预执行代码库，为机器学习实验提供与MLflow的深度集成"
+authors = [
+    {name = "WeData Team", email = "wedata@tencent.com"}
+]
+readme = "README.md"
+license = {text = "MIT"}
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Intended Audience :: Developers",
+    "License :: OSI Approved :: MIT License",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.8",
+    "Programming Language :: Python :: 3.9",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Topic :: Scientific/Engineering :: Artificial Intelligence",
+]
+requires-python = ">=3.8"
+dependencies = [
+    "mlflow>=2.0.0",
+]
+
+[project.optional-dependencies]
+dev = [
+    "pytest>=6.0.0",
+    "black>=21.0.0",
+    "flake8>=3.9.0",
+]
+
+[project.urls]
+Homepage = "https://wedata.tencent.com"
+Documentation = "https://wedata.tencent.com/docs"
+
+[tool.setuptools.packages.find]
+where = ["src"]
+include = ["wedata_pre_code*"]

wedata_pre_code-1.0.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

wedata_pre_code-1.0.0/src/wedata_pre_code/__init__.py

@@ -0,0 +1,12 @@
+"""WeData Pre-Code Library
+
+WeData平台的预执行代码库，为机器学习实验提供与MLflow的深度集成和WeData平台的功能增强。
+"""
+
+from .client import PreCodeClient
+
+__all__ = [
+    "PreCodeClient"
+]
+
+__version__ = "1.0.0"

wedata_pre_code-1.0.0/src/wedata_pre_code/client.py

@@ -0,0 +1,11 @@
+
+
+class PreCodeClient:
+
+    def init_wedata2_pre_code(self, **kwargs):
+        from wedata_pre_code.wedata2.client import Wedata2PreCodeClient
+        return Wedata2PreCodeClient(**kwargs)
+
+    def init_wedata3_pre_code(self, **kwargs):
+        from wedata_pre_code.wedata3.client import Wedata3PreCodeClient
+        return Wedata3PreCodeClient(**kwargs)

wedata_pre_code-1.0.0/src/wedata_pre_code/common/base_client.py

@@ -0,0 +1,18 @@
+class BaseClient:
+
+    def set_properties(self, **kwargs):
+        for key, value in kwargs.items():
+            setattr(self, key, value)
+
+    def check_properties(self, *args):
+        for arg in args:
+            if not hasattr(self, arg):
+                raise AttributeError(f"Missing required property: {arg}")
+
+    def check_required_properties(self, *args):
+        for arg in args:
+            if not hasattr(self, arg):
+                raise AttributeError(f"Missing required property: {arg}")
+            if getattr(self, arg) is None:
+                raise AttributeError(f"Required property cannot be None: {arg}")
+

wedata_pre_code-1.0.0/src/wedata_pre_code/wedata2/client.py

@@ -0,0 +1,334 @@
+from wedata_pre_code.common.base_client import BaseClient
+
+
+class Wedata2PreCodeClient(BaseClient):
+    def __init__(self, wedata_project_id: str = None, wedata_notebook_engine: str = None, qcloud_uin: str = None,
+                 qcloud_subuin: str = None, wedata_default_feature_store_database: str = None,
+                 wedata_feature_store_databases: str = None, qcloud_region: str = None,
+                 mlflow_tracking_uri: str = None, kernel_task_name: str = None, kernel_task_id: str = None,
+                 kernel_submit_form_workflow: str = None, kernel_region: str = None, kernel_is_international: str = None):
+
+        self.wedata_project_id = wedata_project_id
+        self.wedata_notebook_engine = wedata_notebook_engine
+        self.qcloud_uin = qcloud_uin
+        self.qcloud_subuin = qcloud_subuin
+        self.wedata_default_feature_store_database = wedata_default_feature_store_database
+        self.wedata_feature_store_databases = wedata_feature_store_databases
+        self.qcloud_region = qcloud_region
+        self.mlflow_tracking_uri = mlflow_tracking_uri
+        self.kernel_task_name = kernel_task_name
+        self.kernel_task_id = kernel_task_id
+        self.kernel_submit_form_workflow = kernel_submit_form_workflow
+        self.kernel_region = kernel_region
+        self.kernel_is_international = kernel_is_international
+        self.check_required_properties("wedata_project_id", "wedata_notebook_engine", "qcloud_uin", "qcloud_subuin",
+                                       "wedata_default_feature_store_database", "wedata_feature_store_databases",
+                                       "qcloud_region", "mlflow_tracking_uri", "kernel_task_name", "kernel_task_id",
+                                       "kernel_submit_form_workflow", "kernel_region")
+        self.init_pre_code()
+
+    def init_pre_code(self):
+        import os
+        from mlflow.tracking._tracking_service.client import TrackingServiceClient
+        from mlflow.tracking import MlflowClient
+        from functools import wraps
+        import json
+
+        os.environ['WEDATA_PROJECT_ID'] = self.wedata_project_id
+        os.environ['WEDATA_NOTEBOOK_ENGINE'] = self.wedata_notebook_engine
+        os.environ['QCLOUD_UIN'] = self.qcloud_uin
+        os.environ['QCLOUD_SUBUIN'] = self.qcloud_subuin
+        os.environ['WEDATA_DEFAULT_FEATURE_STORE_DATABASE'] = self.wedata_default_feature_store_database
+        os.environ['WEDATA_FEATURE_STORE_DATABASES'] = self.wedata_feature_store_databases
+        os.environ['QCLOUD_REGION'] = self.qcloud_region
+        os.environ["MLFLOW_TRACKING_URI"] = self.mlflow_tracking_uri
+
+        user_name = self.qcloud_uin
+        task_name = self.kernel_task_name
+        task_id = self.kernel_task_id
+        try:
+            workflow_id = self.kernel_submit_form_workflow
+        except Exception:
+            workflow_id = ""
+
+        project_id = self.wedata_project_id
+        os.environ["WEDATA_PROJECT_ID"] = project_id
+        os.environ["KERNEL_SUBMIT_FORM_WORKFLOW"] = workflow_id
+
+        region = self.kernel_region
+        is_international = self.kernel_is_international
+
+        template = (
+            "https://{region}.wedata.tencentcloud.com"  # 国际站
+            if is_international
+            else "https://{region}.wedata.cloud.tencent.com"  # 国内站
+        )
+        base_url = f"{template.format(region=region)}"
+
+        run_context_data = {
+            "mlflow.source.name": task_name,
+            "mlflow.user": user_name,
+            "wedata.taskId": task_id,
+            "wedata.workflowId": workflow_id,
+            "wedata.datascience.type": "MACHINE_LEARNING",
+            "wedata.project": project_id
+        }
+        run_context_value = json.dumps(run_context_data, indent=None)
+
+        os.environ["MLFLOW_RUN_CONTEXT"] = run_context_value
+
+        def log_after_terminated(func):
+            @wraps(func)
+            def wrapper(self, run_id, *args, **kwargs):
+                print("wedata log_after_terminated wrapper")
+                # 调用原set_terminated
+                result = func(self, run_id, *args, **kwargs)
+                # 获取experiment_id
+                run_info = self.store.get_run(run_id).info
+                run_name = run_info.run_name
+                experiment_id = run_info.experiment_id
+                experment_url = f"{base_url}/datascience/experiments-single/{experiment_id}?ProjectId={project_id}"
+                run_url = f"{base_url}/datascience/experiments/task-detail-learn/{run_id}?ProjectId={project_id}"
+                print(f"View run {run_name} at :{run_url}")
+                print(f"View experiment at:{experment_url}")
+                return result
+
+            return wrapper
+
+        from mlflow.models.model import Model
+        def inject_model_version_tag(func):
+            @wraps(func)
+            def wrapper(*args, **kwargs):
+                print("wedata inject_model_version_tag wrapper")
+                registered_model_name = kwargs.get("registered_model_name")
+                if registered_model_name is None:
+                    # 如果在 args 里，找到它的位置
+                    import inspect
+                    sig = inspect.signature(func)
+                    params = list(sig.parameters.keys())
+                    if 'registered_model_name' in params:
+                        idx = params.index('registered_model_name') - 1  # -1 因为 self
+                        if len(args) > idx:
+                            registered_model_name = args[idx]
+                result = func(*args, **kwargs)
+                model_version = result.registered_model_version
+                # 添加 tag
+                if registered_model_name and model_version:
+                    from mlflow import MlflowClient
+                    MlflowClient().set_model_version_tag(registered_model_name, model_version, "mlflow.user",
+                                                         "{user_name}")
+                    MlflowClient().set_model_version_tag(registered_model_name, model_version, "wedata.project",
+                                                         "{project_id}")
+                    MlflowClient().set_model_version_tag(registered_model_name, model_version,
+                                                         "wedata.datascience.type", "MACHINE_LEARNING")
+                return result
+
+            return wrapper
+
+        Model.log = inject_model_version_tag(Model.log)
+
+        def inject_project_filter(func):
+            @wraps(func)
+            def wrapper(*args, **kwargs):
+                # 从环境变量获取 project 值
+                project = os.getenv("WEDATA_PROJECT_ID")
+                if project:
+                    # 获取原始过滤条件
+                    filter_str = kwargs.get("filter_string", "")
+                    # 拼接新的过滤条件（假设 project 存储在 run 的 tag 中）
+                    new_filter = f"tags.wedata.project = '{project}' and tags.wedata.datascience.type='MACHINE_LEARNING'"
+                    if filter_str:
+                        new_filter = f"({filter_str}) and ({new_filter})"
+                    kwargs["filter_string"] = new_filter
+                return func(*args, **kwargs)
+
+            return wrapper
+
+        def inject_project_tag(func):
+            @wraps(func)
+            def wrapper(self, *args, **kwargs):
+                project = os.getenv("WEDATA_PROJECT_ID")
+                workflow_id = os.getenv("KERNEL_SUBMIT_FORM_WORKFLOW")
+                args_list = list(args)
+                if project:
+                    if 'tags' in kwargs:
+                        tags = kwargs['tags'] or {}
+                        tags = tags.copy()
+                        tags["wedata.project"] = project
+                        tags["wedata.datascience.type"] = "MACHINE_LEARNING"
+                        tags["wedata.workflowId"] = workflow_id
+                        kwargs['tags'] = tags
+                    else:
+                        current_tags = {}
+                        method_name = func.__name__
+                        if current_tags == None:
+                            if method_name in ('create_experiment', 'create_run'):
+                                if len(args_list) >= 3:
+                                    current_tags = args_list[2]
+                            elif method_name in ('create_registered_model'):
+                                if len(args_list) >= 2:
+                                    current_tags = args[1]
+                            elif method_name in ('create_model_version'):
+                                if len(args_list) >= 5:
+                                    current_tags = args[4]
+                        if current_tags is None:
+                            current_tags = {}
+                        else:
+                            current_tags = current_tags.copy()  # 避免修改原始字典
+                        current_tags["wedata.project"] = project
+                        current_tags["wedata.datascience.type"] = "MACHINE_LEARNING"
+                        current_tags["mlflow.user"] = "{user_name}"
+                        kwargs["tags"] = current_tags
+                return func(self, *args, **kwargs)
+
+            return wrapper
+
+        def validate_wedata_tag(func):
+            @wraps(func)
+            def wrapper(*args, **kwargs):
+                project = os.getenv("WEDATA_PROJECT_ID")
+                # 调用原始方法获取 Experiment
+                obj = func(*args, **kwargs)
+
+                # 如果 Experiment 不存在，直接返回错误
+                if obj is None:
+                    # print("object is not exists")
+                    return obj
+
+                project_tag = None
+                datascience_type_tag = None
+                method_name = func.__name__
+                obj_name = 'object'
+                if 'run' in method_name:
+                    project_tag = obj.data.tags.get("wedata.project")
+                    datascience_type_tag = obj.data.tags.get("wedata.datascience.type")
+                    obj_name = 'run'
+                elif 'experiment' in method_name:
+                    obj_name = 'experiment'
+                    project_tag = obj.tags.get("wedata.project")
+                    datascience_type_tag = obj.tags.get("wedata.datascience.type")
+                elif 'model' in method_name:
+                    obj_name = 'model'
+                    project_tag = obj.tags.get("wedata.project")
+                    datascience_type_tag = obj.tags.get("wedata.datascience.type")
+                # 检查标签是否存在且值正确
+                if project and project_tag != project:
+                    print(f"this project:{project},has no {obj_name}")
+                    return None
+                if datascience_type_tag != 'MACHINE_LEARNING':
+                    print("Only MACHINE_LEARNING experiment/run/model can be operated in the notebook")
+                    return None
+                return obj
+
+            return wrapper
+
+        def validate_wedata_before_operation(func):
+            @wraps(func)
+            def wrapper(self, *args, **kwargs):
+                project = os.getenv("WEDATA_PROJECT_ID")
+                # 如果未设置环境变量，直接执行原删除操作
+                if not project:
+                    return func(self, *args, **kwargs)
+                method_name = func.__name__
+
+                id_name = None
+                res = None
+                project_tag = None
+                data_science_type = None
+                # 如果设置了环境变量，则校验标签
+                # 获取 Experiment 对象
+                if 'experiment' in method_name:
+                    id_name = kwargs.get("experiment_id") or (args[0] if args else None)
+                    res = self.get_experiment(id_name)
+                    if not res:
+                        print(f"Experiment: '{id_name}' not exist or does not have permission to operate")
+                        return
+                    project_tag = res.tags.get("wedata.project")
+                    data_science_type = res.tags.get("wedata.datascience.type")
+                elif 'model' in method_name:
+                    id_name = kwargs.get("name") or (args[0] if args else None)
+                    res = self.get_registered_model(id_name)
+                    if not res:
+                        print(f"Model '{id_name}' not exist or does not have permission to operate")
+                        return
+                    project_tag = res.tags.get("wedata.project")
+                    data_science_type = res.tags.get("wedata.datascience.type")
+                else:
+                    id_name = kwargs.get("run_id") or (args[0] if args else None)
+                    res = self.get_run(id_name)
+                    if not res:
+                        print(f"run: '{id_name}' not exist or does not have permission to operate")
+                        return
+                    project_tag = res.data.tags.get("wedata.project")
+                    data_science_type = res.data.tags.get("wedata.datascience.type")
+                # print(f"query result:{res}")
+                # 检查标签是否匹配
+                if project_tag != project or data_science_type != 'MACHINE_LEARNING':
+                    print(f"Unauthorized operation:{method_name} ({id_name})")
+                    return  # 不执行删除
+
+                # print(method_name)
+                # 操作标签的操作需要确认不会影响内置标签wedata.project
+                if method_name in ("update_tag", "delete_tags",
+                                   "set_registered_model_tag",
+                                   "delete_registered_model_tag",
+                                   "delete_model_version_tag", "set_experiment_tag"):
+                    # 获取 key 参数的值
+                    key_value = kwargs.get("key") or (args[1] if args else None)
+                    print(key_value)
+                    if key_value == "wedata.project":
+                        print(f"No permission to operate protected tags: {key_value}")
+                        return
+                # 标签匹配，执行删除
+                return func(self, *args, **kwargs)
+
+            return wrapper
+
+        # 1. 应用装饰器，过滤条件filter_str 中添加tag
+        MlflowClient.search_experiments = inject_project_filter(MlflowClient.search_experiments)
+        MlflowClient.search_runs = inject_project_filter(MlflowClient.search_runs)
+        MlflowClient.search_registered_models = inject_project_filter(MlflowClient.search_registered_models)
+        MlflowClient.search_model_versions = inject_project_filter(MlflowClient.search_model_versions)
+        MlflowClient.create_experiment = inject_project_tag(MlflowClient.create_experiment)
+        MlflowClient.create_registered_model = inject_project_tag(MlflowClient.create_registered_model)
+        MlflowClient.create_model_version = inject_project_tag(MlflowClient.create_model_version)
+        # 2. 后置返回结果过滤wedata_project tag
+        MlflowClient.get_experiment = validate_wedata_tag(MlflowClient.get_experiment)
+        MlflowClient.get_experiment_by_name = validate_wedata_tag(MlflowClient.get_experiment_by_name)
+        MlflowClient.get_run = validate_wedata_tag(MlflowClient.get_run)
+        MlflowClient.get_parent_run = validate_wedata_tag(MlflowClient.get_parent_run)
+        MlflowClient.get_registered_model = validate_wedata_tag(MlflowClient.get_registered_model)
+        TrackingServiceClient.set_terminated = log_after_terminated(TrackingServiceClient.set_terminated)
+        # MlflowClient.get_model_version = validate_wedata_tag(MlflowClient.get_model_version)
+        # MlflowClient.get_model_version_download_uri = validate_wedata_tag(MlflowClient.get_model_version_download_uri)
+        # MlflowClient.get_latest_versions = validate_wedata_tag(MlflowClient.get_latest_versions)
+        # 4. 操作前校验,参数experment_id
+        MlflowClient.delete_experiment = validate_wedata_before_operation(MlflowClient.delete_experiment)
+        MlflowClient.restore_experiment = validate_wedata_before_operation(MlflowClient.restore_experiment)
+        MlflowClient.rename_experiment = validate_wedata_before_operation(MlflowClient.rename_experiment)
+        MlflowClient.set_experiment_tag = validate_wedata_before_operation(MlflowClient.set_experiment_tag)
+        # 操作前校验 参数run_id
+        MlflowClient.set_tag = validate_wedata_before_operation(MlflowClient.set_tag)
+        MlflowClient.delete_tag = validate_wedata_before_operation(MlflowClient.delete_tag)
+        MlflowClient.update_run = validate_wedata_before_operation(MlflowClient.update_run)
+        MlflowClient.download_artifacts = validate_wedata_before_operation(MlflowClient.download_artifacts)
+        MlflowClient.list_artifacts = validate_wedata_before_operation(MlflowClient.list_artifacts)
+        MlflowClient.delete_run = validate_wedata_before_operation(MlflowClient.delete_run)
+        MlflowClient.restore_run = validate_wedata_before_operation(MlflowClient.restore_run)
+        # 操作前校验 参数name
+        MlflowClient.rename_registered_model = validate_wedata_before_operation(MlflowClient.rename_registered_model)
+        MlflowClient.update_registered_model = validate_wedata_before_operation(MlflowClient.update_registered_model)
+        MlflowClient.delete_registered_model = validate_wedata_before_operation(MlflowClient.delete_registered_model)
+        MlflowClient.update_model_version = validate_wedata_before_operation(MlflowClient.update_model_version)
+        MlflowClient.delete_model_version = validate_wedata_before_operation(MlflowClient.delete_model_version)
+        MlflowClient.set_model_version_tag = validate_wedata_before_operation(MlflowClient.set_model_version_tag)
+        MlflowClient.delete_model_version_tag = validate_wedata_before_operation(MlflowClient.delete_model_version_tag)
+        MlflowClient.set_registered_model_alias = validate_wedata_before_operation(
+            MlflowClient.set_registered_model_alias)
+        MlflowClient.delete_registered_model_alias = validate_wedata_before_operation(
+            MlflowClient.delete_registered_model_alias)
+
+        # TOOD：设置tag相关需要校验设置的key是否为wedata_project
+        MlflowClient.set_registered_model_tag = validate_wedata_before_operation(MlflowClient.set_registered_model_tag)
+        MlflowClient.delete_registered_model_tag = validate_wedata_before_operation(
+            MlflowClient.delete_registered_model_tag)

wedata_pre_code-1.0.0/src/wedata_pre_code/wedata3/client.py

@@ -0,0 +1,241 @@
+from wedata_pre_code.common.base_client import BaseClient
+import types
+
+
+class Wedata3PreCodeClient(BaseClient):
+    def __init__(self, workspace_id: str = None, mlflow_tracking_uri: str = None, base_url: str = None,
+                 region: str = None, run_context_data: str = None):
+        self.workspace_id = workspace_id
+        self.mlflow_tracking_uri = mlflow_tracking_uri
+        self.base_url = base_url
+        self.region = region
+        self.run_context_data = run_context_data
+        self.check_required_properties("workspace_id", "mlflow_tracking_uri", "base_url", "run_context_data")
+        self.init_pre_code()
+
+    def init_pre_code(self):
+        import os
+        import json
+        import mlflow
+        from mlflow.tracking._tracking_service.client import TrackingServiceClient
+        from mlflow.tracking import MlflowClient
+        from mlflow.store.tracking.rest_store import RestStore
+        import logging
+        from functools import wraps
+        import inspect
+        from mlflow.models.model import Model
+        os.environ["MLFLOW_RUN_CONTEXT"] = self.run_context_data
+        os.environ["WEDATA_WORKSPACE_ID"] = self.workspace_id
+
+        mlflow.set_tracking_uri(getattr(self, "mlflow_tracking_uri", "http://127.0.0.1:5000"))
+        if self.region:
+            # 日志输出装饰器
+            base_url = self.base_url
+            workspace_id = self.workspace_id
+
+            def log_after_terminated(func):
+                @wraps(func)
+                def wrapper(self, run_id, *args, **kwargs):
+                    print("wedata log_after_terminated wrapper")
+                    result = func(self, run_id, *args, **kwargs)
+                    run_info = self.store.get_run(run_id).info
+                    run_name = run_info.run_name
+                    experiment_id = run_info.experiment_id
+                    experiment_url = f"${base_url}/datascience/experiments/experiments-single/{experiment_id}?o=${workspace_id}"
+                    run_url = f"${base_url}/datascience/experiments/task-detail-learn/{run_id}?o=${workspace_id}"
+                    print(f"View run {run_name} at :{run_url}")
+                    print(f"View experiment at:{experiment_url}")
+                    return result
+
+                return wrapper
+
+            TrackingServiceClient.set_terminated = log_after_terminated(TrackingServiceClient.set_terminated)
+
+        # 模型版本标签注入装饰器
+        def inject_model_version_tag(func):
+            @wraps(func)
+            def wrapper(*args, **kwargs):
+                print("wedata inject_model_version_tag wrapper")
+                registered_model_name = kwargs.get("registered_model_name")
+                if registered_model_name is None:
+                    sig = inspect.signature(func)
+                    params = list(sig.parameters.keys())
+                    if 'registered_model_name' in params:
+                        idx = params.index('registered_model_name') - 1
+                        if len(args) > idx:
+                            registered_model_name = args[idx]
+                result = func(*args, **kwargs)
+                model_version = result.registered_model_version
+                if registered_model_name and model_version:
+                    from mlflow import MlflowClient
+                    MlflowClient().set_model_version_tag(registered_model_name, model_version, "mlflow.user", "${uin}")
+                    MlflowClient().set_model_version_tag(registered_model_name, model_version, "wedata.workspace",
+                                                         "${workspaceId}")
+                    MlflowClient().set_model_version_tag(registered_model_name, model_version,
+                                                         "wedata.datascience.type", "MACHINE_LEARNING")
+                return result
+
+            return wrapper
+
+        Model.log = inject_model_version_tag(Model.log)
+
+        # 项目标签注入装饰器
+        def inject_workspace_tag(func):
+            @wraps(func)
+            def wrapper(self, *args, **kwargs):
+                workspace = os.getenv("WEDATA_WORKSPACE_ID")
+                args_list = list(args)
+                if workspace:
+                    if 'tags' in kwargs:
+                        tags = kwargs['tags'] or {}
+                        tags = tags.copy()
+                        # 如果传入的参数中有wedata.workspace和wedata.datascience.type，则不进行注入
+                        if "wedata.workspace" not in tags:
+                            tags["wedata.workspace"] = workspace
+                        if "wedata.datascience.type" not in tags:
+                            tags["wedata.datascience.type"] = "MACHINE_LEARNING"
+                        kwargs['tags'] = tags
+                    else:
+                        current_tags = None
+                        method_name = func.__name__
+                        if current_tags is None:
+                            if method_name in ('create_experiment', 'create_run'):
+                                if len(args_list) >= 3:
+                                    current_tags = args_list[2]
+                            elif method_name in ('create_registered_model'):
+                                if len(args_list) >= 2:
+                                    current_tags = args_list[1]
+                            elif method_name in ('create_model_version'):
+                                if len(args_list) >= 5:
+                                    current_tags = args_list[4]
+                        if current_tags is None:
+                            current_tags = {}
+                        else:
+                            current_tags = current_tags.copy()
+                        current_tags["wedata.workspace"] = workspace
+                        current_tags["wedata.datascience.type"] = "MACHINE_LEARNING"
+                        current_tags["mlflow.user"] = "${uin}"
+                        kwargs["tags"] = current_tags
+                return func(self, *args, **kwargs)
+
+            return wrapper
+
+        # 标签验证装饰器
+        def validate_wedata_tag(func):
+            @wraps(func)
+            def wrapper(*args, **kwargs):
+                workspace = os.getenv("WEDATA_WORKSPACE_ID")
+                obj = func(*args, **kwargs)
+                if obj is None:
+                    return obj
+                workspace_tag = None
+                datascience_type_tag = None
+                method_name = func.__name__
+                obj_name = 'object'
+                if 'run' in method_name:
+                    workspace_tag = obj.data.tags.get("wedata.workspace")
+                    datascience_type_tag = obj.data.tags.get("wedata.datascience.type")
+                    obj_name = 'run'
+                elif 'experiment' in method_name:
+                    obj_name = 'experiment'
+                    workspace_tag = obj.tags.get("wedata.workspace")
+                    datascience_type_tag = obj.tags.get("wedata.datascience.type")
+                elif 'model' in method_name:
+                    obj_name = 'model'
+                    workspace_tag = obj.tags.get("wedata.workspace")
+                    datascience_type_tag = obj.tags.get("wedata.datascience.type")
+                if workspace and workspace_tag != workspace:
+                    print(f"this workspace:{workspace},has no {obj_name}")
+                    return None
+                if datascience_type_tag not in ('MACHINE_LEARNING', 'DEEP_LEARNING'):
+                    print(
+                        "Only MACHINE_LEARNING and DEEP_LEARNING experiment/run/model can be operated in the notebook")
+                    return None
+                return obj
+
+            return wrapper
+
+        # 操作前验证装饰器
+        def validate_wedata_before_operation(func):
+            @wraps(func)
+            def wrapper(self, *args, **kwargs):
+                workspace = os.getenv("WEDATA_WORKSPACE_ID")
+                if not workspace:
+                    return func(self, *args, **kwargs)
+                method_name = func.__name__
+                id_name = None
+                res = None
+                workspace_tag = None
+                data_science_type = None
+                if 'experiment' in method_name:
+                    id_name = kwargs.get("experiment_id") or (args[0] if args else None)
+                    res = self.get_experiment(id_name)
+                    if not res:
+                        print(f"Experiment: '{id_name}' not exist or does not have permission to operate")
+                        return
+                    workspace_tag = res.tags.get("wedata.workspace")
+                    data_science_type = res.tags.get("wedata.datascience.type")
+                elif 'model' in method_name:
+                    id_name = kwargs.get("name") or (args[0] if args else None)
+                    res = self.get_registered_model(id_name)
+                    if not res:
+                        print(f"Model '{id_name}' not exist or does not have permission to operate")
+                        return
+                    workspace_tag = res.tags.get("wedata.workspace")
+                    data_science_type = res.tags.get("wedata.datascience.type")
+                else:
+                    id_name = kwargs.get("run_id") or (args[0] if args else None)
+                    res = self.get_run(id_name)
+                    if not res:
+                        print(f"run: '{id_name}' not exist or does not have permission to operate")
+                        return
+                    workspace_tag = res.data.tags.get("wedata.workspace")
+                    data_science_type = res.data.tags.get("wedata.datascience.type")
+                if workspace_tag != workspace or data_science_type not in ('MACHINE_LEARNING', 'DEEP_LEARNING'):
+                    print(f"Unauthorized operation:{method_name} ({id_name})")
+                    return
+                if method_name in (
+                        "update_tag", "delete_tags", "set_registered_model_tag", "delete_registered_model_tag",
+                        "delete_model_version_tag", "set_experiment_tag"):
+                    key_value = kwargs.get("key") or (args[1] if args else None)
+                    if key_value == "wedata.workspace":
+                        print(f"No permission to operate protected tags: {key_value}")
+                        return
+                return func(self, *args, **kwargs)
+
+            return wrapper
+
+        # 应用装饰器
+        MlflowClient.create_experiment = inject_workspace_tag(MlflowClient.create_experiment)
+        MlflowClient.create_registered_model = inject_workspace_tag(MlflowClient.create_registered_model)
+        MlflowClient.create_model_version = inject_workspace_tag(MlflowClient.create_model_version)
+        MlflowClient.get_experiment = validate_wedata_tag(MlflowClient.get_experiment)
+        MlflowClient.get_experiment_by_name = validate_wedata_tag(MlflowClient.get_experiment_by_name)
+        MlflowClient.get_run = validate_wedata_tag(MlflowClient.get_run)
+        MlflowClient.get_parent_run = validate_wedata_tag(MlflowClient.get_parent_run)
+        MlflowClient.get_registered_model = validate_wedata_tag(MlflowClient.get_registered_model)
+        MlflowClient.delete_experiment = validate_wedata_before_operation(MlflowClient.delete_experiment)
+        MlflowClient.restore_experiment = validate_wedata_before_operation(MlflowClient.restore_experiment)
+        MlflowClient.rename_experiment = validate_wedata_before_operation(MlflowClient.rename_experiment)
+        MlflowClient.set_experiment_tag = validate_wedata_before_operation(MlflowClient.set_experiment_tag)
+        MlflowClient.set_tag = validate_wedata_before_operation(MlflowClient.set_tag)
+        MlflowClient.delete_tag = validate_wedata_before_operation(MlflowClient.delete_tag)
+        MlflowClient.update_run = validate_wedata_before_operation(MlflowClient.update_run)
+        MlflowClient.download_artifacts = validate_wedata_before_operation(MlflowClient.download_artifacts)
+        MlflowClient.list_artifacts = validate_wedata_before_operation(MlflowClient.list_artifacts)
+        MlflowClient.delete_run = validate_wedata_before_operation(MlflowClient.delete_run)
+        MlflowClient.restore_run = validate_wedata_before_operation(MlflowClient.restore_run)
+        MlflowClient.rename_registered_model = validate_wedata_before_operation(MlflowClient.rename_registered_model)
+        MlflowClient.update_registered_model = validate_wedata_before_operation(MlflowClient.update_registered_model)
+        MlflowClient.delete_registered_model = validate_wedata_before_operation(MlflowClient.delete_registered_model)
+        MlflowClient.update_model_version = validate_wedata_before_operation(MlflowClient.update_model_version)
+        MlflowClient.delete_model_version = validate_wedata_before_operation(MlflowClient.delete_model_version)
+        MlflowClient.set_model_version_tag = validate_wedata_before_operation(MlflowClient.set_model_version_tag)
+        MlflowClient.delete_model_version_tag = validate_wedata_before_operation(MlflowClient.delete_model_version_tag)
+        MlflowClient.set_registered_model_alias = validate_wedata_before_operation(
+            MlflowClient.set_registered_model_alias)
+        MlflowClient.delete_registered_model_alias = validate_wedata_before_operation(
+            MlflowClient.delete_registered_model_alias)
+        MlflowClient.set_registered_model_tag = validate_wedata_before_operation(MlflowClient.set_registered_model_tag)
+        MlflowClient.delete_registered_model_tag = validate_wedata_before_operation(
+            MlflowClient.delete_registered_model_tag)

wedata_pre_code-1.0.0/src/wedata_pre_code.egg-info/PKG-INFO

@@ -0,0 +1,192 @@
+Metadata-Version: 2.4
+Name: wedata-pre-code
+Version: 1.0.0
+Summary: WeData平台的预执行代码库，为机器学习实验提供与MLflow的深度集成
+Author-email: WeData Team <wedata@tencent.com>
+License: MIT
+Project-URL: Homepage, https://wedata.tencent.com
+Project-URL: Documentation, https://wedata.tencent.com/docs
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+Requires-Dist: mlflow>=2.0.0
+Provides-Extra: dev
+Requires-Dist: pytest>=6.0.0; extra == "dev"
+Requires-Dist: black>=21.0.0; extra == "dev"
+Requires-Dist: flake8>=3.9.0; extra == "dev"
+
+# WeData Pre-Code Library
+
+WeData平台的预执行代码库，为机器学习实验提供与MLflow的深度集成和WeData平台的功能增强。
+
+## 项目概述
+
+本项目提供了两个版本的WeData客户端，用于在WeData平台上运行机器学习实验时提供以下功能：
+
+- **MLflow集成增强**：自动注入WeData平台特定的标签和过滤条件
+- **权限控制**：基于项目/工作空间的权限验证机制
+- **URL生成**：自动生成实验和运行的查看链接
+- **环境配置**：自动设置运行环境变量
+
+## 版本说明
+
+### Wedata2PreCodeClient (WeData 2.0版本)
+
+适用于WeData 2.0平台的客户端，主要特性：
+
+- 基于项目ID进行权限控制
+- 支持国内站和国际站URL模板
+- 自动注入项目标签和机器学习类型标签
+- 提供完整的MLflow客户端装饰器
+
+### Wedata3PreCodeClient (WeData 3.0版本)
+
+适用于WeData 3.0平台的客户端，主要特性：
+
+- 基于工作空间ID进行权限控制
+- 支持更灵活的配置选项
+- 增强的标签注入和验证机制
+- 支持机器学习和深度学习两种实验类型
+
+## 安装和使用
+
+### 安装依赖
+
+```bash
+pip install mlflow
+```
+
+### 使用Wedata2PreCodeClient
+
+```python
+from wedata_pre_code.wedata2.client import Wedata2PreCodeClient
+
+# 初始化客户端
+client = Wedata2PreCodeClient(
+    wedata_project_id="your_project_id",
+    wedata_notebook_engine="your_engine",
+    qcloud_uin="your_uin",
+    qcloud_subuin="your_subuin",
+    wedata_default_feature_store_database="your_db",
+    wedata_feature_store_databases="your_dbs",
+    qcloud_region="your_region",
+    mlflow_tracking_uri="your_tracking_uri",
+    kernel_task_name="task_name",
+    kernel_task_id="task_id",
+    kernel_region="region",
+    kernel_is_international=False
+)
+
+# 现在可以使用MLflow客户端，会自动应用WeData的增强功能
+import mlflow
+mlflow.start_run()
+# ... 你的实验代码
+```
+
+### 使用Wedata3PreCodeClient
+
+```python
+from wedata_pre_code.wedata3.client import Wedata3PreCodeClient
+
+# 初始化客户端
+client = Wedata3PreCodeClient(
+    workspace_id="your_workspace_id",
+    mlflow_tracking_uri="your_tracking_uri",
+    base_url="your_base_url",
+    region="your_region",
+    run_context_data="your_context_data"
+)
+
+# 现在可以使用MLflow客户端，会自动应用WeData的增强功能
+import mlflow
+mlflow.start_run()
+# ... 你的实验代码
+```
+
+## 功能特性
+
+### 自动标签注入
+
+- 自动为实验、运行和模型注入WeData平台标签
+- 包括项目ID、工作空间ID、机器学习类型等信息
+- 确保数据在平台上的可追溯性
+
+### 权限验证
+
+- 在执行敏感操作前验证权限
+- 防止跨项目/工作空间的未授权操作
+- 保护内置标签不被修改
+
+### URL生成
+
+- 自动生成实验和运行的查看URL
+- 在运行终止时显示访问链接
+- 方便用户快速访问实验结果
+
+### 环境配置
+
+- 自动设置MLflow跟踪URI
+- 配置运行上下文环境变量
+- 支持国际站和国内站的不同配置
+
+## 项目结构
+
+```
+pre-execute/
+├── src/
+│   └── wedata_pre_code/
+│       ├── __init__.py
+│       ├── client.py              # 主客户端入口
+│       ├── common/
+│       │   ├── __init__.py
+│       │   └── base_client.py     # 基础客户端类
+│       ├── wedata2/
+│       │   ├── __init__.py
+│       │   └── client.py          # WeData 2.0客户端
+│       └── wedata3/
+│           ├── __init__.py
+│           └── client.py          # WeData 3.0客户端
+├── docs/                          # 文档目录
+├── pyproject.toml                 # 项目配置
+├── requirement.txt                # 依赖文件
+└── README.md                     # 项目说明
+```
+
+## 开发指南
+
+### 添加新的装饰器
+
+要添加新的MLflow客户端方法装饰器，可以参考现有的实现模式：
+
+1. 在相应的客户端类中定义装饰器函数
+2. 使用`@wraps`保留原函数属性
+3. 在装饰器内部实现特定的逻辑
+4. 将装饰器应用到目标MLflow方法
+
+### 测试
+
+确保在修改代码后测试以下场景：
+
+- 正常创建实验和运行
+- 权限验证功能
+- 标签注入的正确性
+- URL生成的准确性
+
+## 注意事项
+
+- 确保MLflow服务器配置正确
+- 验证环境变量设置完整
+- 注意不同版本客户端的参数差异
+- 在生产环境使用前进行充分测试
+
+## 支持与反馈
+
+如有问题或建议，请联系WeData平台技术支持团队。

wedata_pre_code-1.0.0/src/wedata_pre_code.egg-info/SOURCES.txt

@@ -0,0 +1,15 @@
+README.md
+pyproject.toml
+src/wedata_pre_code/__init__.py
+src/wedata_pre_code/client.py
+src/wedata_pre_code.egg-info/PKG-INFO
+src/wedata_pre_code.egg-info/SOURCES.txt
+src/wedata_pre_code.egg-info/dependency_links.txt
+src/wedata_pre_code.egg-info/requires.txt
+src/wedata_pre_code.egg-info/top_level.txt
+src/wedata_pre_code/common/__init__.py
+src/wedata_pre_code/common/base_client.py
+src/wedata_pre_code/wedata2/__init__.py
+src/wedata_pre_code/wedata2/client.py
+src/wedata_pre_code/wedata3/__init__.py
+src/wedata_pre_code/wedata3/client.py

wedata_pre_code-1.0.0/src/wedata_pre_code.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

wedata_pre_code-1.0.0/src/wedata_pre_code.egg-info/requires.txt

@@ -0,0 +1,6 @@
+mlflow>=2.0.0
+
+[dev]
+pytest>=6.0.0
+black>=21.0.0
+flake8>=3.9.0

wedata_pre_code-1.0.0/src/wedata_pre_code.egg-info/top_level.txt

@@ -0,0 +1 @@
+wedata_pre_code