wedata-pre-code 1.0.8__py3-none-any.whl

wedata_pre_code/__init__.py

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

wedata_pre_code/client.py

@@ -0,0 +1,37 @@
+__doc__ = """
+Wedata 预执行代码客户端
+如果要初始化Wedata2的预执行代码客户端，请使用init_wedata2_pre_code方法
+如果要初始化Wedata3的预执行代码客户端，请使用init_wedata3_pre_code方法
+"""
+
+
+class PreCodeClient:
+    """
+    Wedata 预执行代码客户端
+    """
+
+    def init_wedata2_pre_code(self, **kwargs):
+        """
+        初始化Wedata2的预执行代码客户端
+        :param kwargs: Wedata2的预执行代码客户端的参数
+        :return: Wedata2PreCodeClient实例
+        """
+        from wedata_pre_code.wedata2.client import Wedata2PreCodeClient
+
+        client = Wedata2PreCodeClient(**kwargs)
+        client.init()
+
+        return client
+
+    def init_wedata3_pre_code(self, **kwargs):
+        """
+        初始化Wedata3的预执行代码客户端
+        :param kwargs: Wedata3的预执行代码客户端的参数
+        :return: Wedata3PreCodeClient实例
+        """
+        from wedata_pre_code.wedata3.client import Wedata3PreCodeClient
+
+        client = Wedata3PreCodeClient(**kwargs)
+        client.init()
+
+        return client

wedata_pre_code/common/base_client.py

@@ -0,0 +1,16 @@
+__doc__ = """
+基础客户端类
+"""
+
+from abc import abstractmethod
+from pydantic import BaseModel
+
+
+class BaseClient(BaseModel):
+    """
+    基础客户端类
+    """
+
+    @abstractmethod
+    def init(self):
+        pass

wedata_pre_code/wedata2/client.py

@@ -0,0 +1,433 @@
+from typing import Optional
+from wedata_pre_code.common.base_client import BaseClient
+
+
+class Wedata2PreCodeClient(BaseClient):
+    """
+    Wedata2预执行代码客户端
+    必传参数:
+        - wedata_project_id: 项目ID
+        - wedata_notebook_engine: 笔记本引擎
+        - qcloud_uin: 腾讯云uin
+        - qcloud_subuin: 腾讯云subuin
+        - wedata_default_feature_store_database: 默认特征存储数据库
+        - wedata_feature_store_databases: 特征存储数据库
+        - qcloud_region: 区域
+        - mlflow_tracking_uri: mlflow跟踪URI
+        - kernel_region: 区域
+        - feast_remote_address: feast远程地址
+    可选参数:
+        - kernel_task_name: 任务名称
+        - kernel_task_id: 任务ID
+        - kernel_submit_form_workflow: 任务提交表单工作流
+        - kernel_is_international: 是否国际站
+    """
+    wedata_project_id: str
+    wedata_notebook_engine: str
+    qcloud_uin: str
+    qcloud_subuin: str
+    wedata_default_feature_store_database: str
+    wedata_feature_store_databases: str
+    qcloud_region: str
+    mlflow_tracking_uri: str
+    kernel_region: str
+    kernel_task_name: Optional[str] = ""
+    kernel_task_id: Optional[str] = ""
+    kernel_submit_form_workflow: Optional[str] = ""
+    kernel_is_international: Optional[bool] = False
+
+    def __init__(self, *args, **kwargs):
+        super(Wedata2PreCodeClient, self).__init__(*args, **kwargs)
+        self.init()
+
+    def init(self):
+        import json
+        import os
+        from functools import wraps
+
+        from mlflow.tracking import MlflowClient
+        from mlflow.tracking._tracking_service.client import TrackingServiceClient
+
+        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
+        project_id = self.wedata_project_id
+        os.environ["WEDATA_PROJECT_ID"] = project_id
+        os.environ["KERNEL_SUBMIT_FORM_WORKFLOW"] = self.kernel_submit_form_workflow
+
+        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":  self.kernel_submit_form_workflow,
+            "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}'"
+                    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 not in ['MACHINE_LEARNING','AUTOML_REGRESSION',
+                                                'AUTOML_CLASSIFICATION','AUTOML_PREDICTION']:
+                    print(
+                        "Only ['MACHINE_LEARNING','AUTOML_REGRESSION','AUTOML_CLASSIFICATION','AUTOML_PREDICTION']"
+                        " 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 not in ['MACHINE_LEARNING','AUTOML_REGRESSION','AUTOML_CLASSIFICATION','AUTOML_PREDICTION']:
+                    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/wedata3/client.py

@@ -0,0 +1,425 @@
+from typing import Optional
+
+from wedata_pre_code.common.base_client import BaseClient
+
+__doc__ = """
+Wedata3预执行代码客户端
+"""
+
+PROXY_HEADER_KEY_IP = "X-Target-Service-IP"
+PROXY_HEADER_KEY_PORT = "X-Target-Service-PORT"
+
+FEAST_PROXY_ENV_KEY_IP = "FEAST_SERVICE_IP"
+FEAST_PROXY_ENV_KEY_PORT = "FEAST_SERVICE_PORT"
+
+MLFLOW_PROXY_ENV_KEY_IP = "MLFLOW_SERVICE_IP"
+MLFLOW_PROXY_ENV_KEY_PORT = "MLFLOW_SERVICE_PORT"
+
+KERNEL_WEDATA_PREFIX = "KERNEL_WEDATA_"
+
+
+def get_kernel_env_key(key):
+    """
+    设置Wedata特定的变量前缀，避免于系统内置变量冲突。
+    例如：key = "REGION" , 最终返回 "KERNEL_WEDATA_REGION"
+    :param key:
+    :return:
+    """
+    return KERNEL_WEDATA_PREFIX + key
+
+
+class Wedata3PreCodeClient(BaseClient):
+    """
+    Wedata3预执行代码客户端
+    必传参数:
+        - workspace_id: 工作空间ID
+        - mlflow_tracking_uri: mlflow跟踪URI
+        - base_url: 基础URL
+        - mlflow_gateway_url: mlflow基础serverless网关地址
+        - feast_gateway_url: feast基础serverless网关地址
+        - mlflow_proxy_ip: mlflow转发地址
+        - mlflow_proxy_port: mlflow转发端口
+        - feast_proxy_ip: feast转发地址
+        - feast_proxy_port: feast转发端口
+    可选参数:
+        - region: 区域
+        - ap_region_id: 区域ID
+        - kernel_task_name: Notebook路径名
+        - kernel_task_id:  Notebook文件ID
+        - kernel_submit_form_workflow: 任务提交表单工作流
+        - kernel_is_international: 是否国际站
+        - cloud_sdk_secret_id: 云SDK密钥ID
+        - cloud_sdk_secret_key: 云SDK密钥KEY
+        - cloud_sdk_secret_token: 云SDK密钥TOKEN
+        - qcloud_uin: 腾讯云uin
+        - qcloud_subuin: 腾讯云subuin
+    """
+
+    workspace_id: str
+    base_url: str
+    region: Optional[str] = ""
+    ap_region_id: Optional[int] = 0
+    # 基础serverless网关地址
+    mlflow_gateway_url: str
+    feast_gateway_url: str
+    # mlflow转发地址
+    mlflow_proxy_ip: str
+    mlflow_proxy_port: str
+    # feast转发地址
+    feast_proxy_ip: str
+    feast_proxy_port: str
+    # 系统内置变量
+    kernel_task_name: Optional[str]
+    kernel_task_id: Optional[str]
+    kernel_submit_form_workflow: Optional[str] = ""
+    # SDK相关
+    cloud_sdk_secret_id: Optional[str] = ""
+    cloud_sdk_secret_key: Optional[str] = ""
+    cloud_sdk_secret_token: Optional[str] = ""
+    # 帐号相关
+    qcloud_uin: Optional[str] = ""
+    qcloud_subuin: Optional[str] = ""
+
+    def init(self):
+        import inspect
+        import json
+        import os
+        from functools import wraps
+
+        import feast
+        import feast.infra.registry.remote
+        import grpc
+        import mlflow
+        from feast.errors import FeastError
+        from feast.protos.feast.registry import RegistryServer_pb2_grpc
+        from mlflow.models.model import Model
+        from mlflow.tracking import MlflowClient
+        from mlflow.tracking._tracking_service.client import TrackingServiceClient
+
+        mlflow_tracking_uri = f"http://{self.mlflow_proxy_ip}:{self.mlflow_proxy_port}"
+        feast_remote_address = f"{self.feast_proxy_ip}:{self.feast_proxy_port}"
+
+        if self.mlflow_gateway_url:
+            mlflow_tracking_uri = f"http://{self.mlflow_gateway_url}"
+            os.environ[MLFLOW_PROXY_ENV_KEY_IP] = self.mlflow_proxy_ip
+            os.environ[MLFLOW_PROXY_ENV_KEY_PORT] = self.mlflow_proxy_port
+
+        if self.feast_gateway_url:
+            feast_remote_address = self.feast_gateway_url
+            os.environ[FEAST_PROXY_ENV_KEY_IP] = self.feast_proxy_ip
+            os.environ[FEAST_PROXY_ENV_KEY_PORT] = self.feast_proxy_port
+
+        # os.environ["MLFLOW_RUN_CONTEXT"] = self.run_context_data
+        os.environ["WEDATA_WORKSPACE_ID"] = self.workspace_id
+        os.environ["MLFLOW_TRACKING_URI"] = mlflow_tracking_uri
+        os.environ[get_kernel_env_key("REGION")] = self.region
+
+        os.environ["KERNEL_FEAST_REMOTE_ADDRESS"] = feast_remote_address
+
+        # 设置系统内置变量
+        os.environ[get_kernel_env_key("TASK_NAME")] = self.kernel_task_name
+        os.environ[get_kernel_env_key("TASK_ID")] = self.kernel_task_id
+        os.environ[get_kernel_env_key("SUBMIT_FORM_WORKFLOW")] = self.kernel_submit_form_workflow
+        os.environ[get_kernel_env_key("CLOUD_SDK_SECRET_ID")] = self.cloud_sdk_secret_id
+        os.environ[get_kernel_env_key("CLOUD_SDK_SECRET_KEY")] = self.cloud_sdk_secret_key
+        os.environ[get_kernel_env_key("CLOUD_SDK_SECRET_TOKEN")] = self.cloud_sdk_secret_token
+        os.environ[get_kernel_env_key("QCLOUD_UIN")] = self.qcloud_uin
+        os.environ[get_kernel_env_key("QCLOUD_SUBUIN")] = self.qcloud_subuin
+
+        mlflow.set_tracking_uri(mlflow_tracking_uri)
+
+        if not os.environ.get("MLFLOW_RUN_CONTEXT"):
+            # 避免重复设置
+            run_context_data = {
+                "mlflow.source.name": self.kernel_task_name,
+                "mlflow.user": self.qcloud_uin,
+                "wedata.taskId": self.kernel_task_id,
+                "wedata.workflowId": self.kernel_submit_form_workflow,
+                "wedata.datascience.type": "MACHINE_LEARNING",
+                "wedata.workspace": self.workspace_id,
+            }
+            run_context_value = json.dumps(run_context_data, indent=None)
+
+            os.environ["MLFLOW_RUN_CONTEXT"] = run_context_value
+
+        if self.region:
+            # 日志输出装饰器
+            base_url = self.base_url
+            workspace_id = self.workspace_id
+            ap_region_id = self.ap_region_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}&r={ap_region_id}"
+                    run_url = f"${base_url}/datascience/experiments/task-detail-learn/{run_id}?o=${workspace_id}&r={ap_region_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)
+
+        _original_remote_registry = feast.infra.registry.remote.RemoteRegistry
+
+        def add_feast_proxy_header():
+            def func(*args, **kwargs):
+                registry = _original_remote_registry(*args, **kwargs)
+                proxy_header_interceptor = GrpcClientProxyHeaderInterceptor()
+                registry.channel = grpc.intercept_channel(registry.channel, proxy_header_interceptor)
+                registry.stub = RegistryServer_pb2_grpc.RegistryServerStub(registry.channel)
+                return registry
+
+            return func
+
+        class GrpcClientProxyHeaderInterceptor(
+            grpc.UnaryUnaryClientInterceptor,
+            grpc.UnaryStreamClientInterceptor,
+            grpc.StreamUnaryClientInterceptor,
+            grpc.StreamStreamClientInterceptor,
+        ):
+            def __init__(self):
+                self.proxy_ip = os.environ.get(FEAST_PROXY_ENV_KEY_IP)
+                self.proxy_port = os.environ.get(FEAST_PROXY_ENV_KEY_PORT)
+                if not self.proxy_ip:
+                    raise FeastError(f"Environment variable `{FEAST_PROXY_ENV_KEY_IP}` is not set")
+                if not self.proxy_port:
+                    raise FeastError(f"Environment variable `{FEAST_PROXY_ENV_KEY_PORT}` is not set")
+
+            def intercept_unary_unary(self, continuation, client_call_details, request_iterator):
+                return self._handle_call(continuation, client_call_details, request_iterator)
+
+            def intercept_unary_stream(self, continuation, client_call_details, request_iterator):
+                return self._handle_call(continuation, client_call_details, request_iterator)
+
+            def intercept_stream_unary(self, continuation, client_call_details, request_iterator):
+                return self._handle_call(continuation, client_call_details, request_iterator)
+
+            def intercept_stream_stream(self, continuation, client_call_details, request_iterator):
+                return self._handle_call(continuation, client_call_details, request_iterator)
+
+            def _handle_call(self, continuation, client_call_details, request_iterator):
+                client_call_details = self._append_proxy_header_metadata(client_call_details)
+                result = continuation(client_call_details, request_iterator)
+                if result.exception() is not None:
+                    mapped_error = FeastError.from_error_detail(result.exception().details())
+                    if mapped_error is not None:
+                        raise mapped_error
+                return result
+
+            def _append_proxy_header_metadata(self, client_call_details):
+                metadata = client_call_details.metadata or []
+                metadata.append((PROXY_HEADER_KEY_IP.lower(), self.proxy_ip))
+                metadata.append((PROXY_HEADER_KEY_PORT.lower(), self.proxy_port))
+                client_call_details = client_call_details._replace(metadata=metadata)
+                return client_call_details
+
+        feast.infra.registry.remote.RemoteRegistry = add_feast_proxy_header()

wedata_pre_code-1.0.8.dist-info/METADATA

@@ -0,0 +1,232 @@
+Metadata-Version: 2.3
+Name: wedata-pre-code
+Version: 1.0.8
+Summary: WeData平台的预执行代码库，为机器学习实验提供与MLflow的深度集成
+Author: WeData Team
+Author-email: WeData Team <wedata@tencent.com>
+License: MIT
+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-Dist: feast==0.49.0
+Requires-Dist: grpcio>=1.71.0
+Requires-Dist: mlflow>=2.0.0
+Requires-Dist: pydantic>=2.10.6
+Requires-Dist: mlflow>=2.0.0,<3.0.0 ; extra == 'mlflow-v2'
+Requires-Dist: wedata-mlflow-header-plugin>=0.1.2 ; extra == 'wedata-3'
+Requires-Python: >=3.9
+Project-URL: Documentation, https://wedata.tencent.com/docs
+Project-URL: Homepage, https://wedata.tencent.com
+Provides-Extra: mlflow-v2
+Provides-Extra: wedata-3
+Description-Content-Type: text/markdown
+
+# 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="{{WEDATA_PROJECT_ID}}",
+    wedata_notebook_engine="{{WEDATA_NOTEBOOK_ENGINE}}",
+    qcloud_uin="{{QCLOUD_UIN}}",
+    qcloud_subuin="{{QCLOUD_SUBUIN}}",
+    wedata_default_feature_store_database="{{WEDATA_DEFAULT_FEATURE_STORE_DATABASE}}",
+    wedata_feature_store_databases="{{WEDATA_FEATURE_STORE_DATABASES}}",
+    qcloud_region="{{QCLOUD_REGION}}",
+    mlflow_tracking_uri="{{KERNEL_MLFLOW_TRACKING_URI}}",
+    feast_remote_address="{{KERNEL_FEAST_REMOTE_ADDRESS}}",
+    kernel_submit_form_workflow="{{KERNEL_SUBMIT_FORM_WORKFLOW}}",
+    kernel_task_name="{{KERNEL_TASK_NAME}}",
+    kernel_task_id="{{KERNEL_TASK_ID}}",
+    kernel_region="ap-chongqing",
+    kernel_is_international=bool("{{KERNEL_IS_INTERNATIONAL}}")
+)
+
+# 现在可以使用MLflow客户端，会自动应用WeData的增强功能
+import mlflow
+mlflow.start_run()
+# ... 你的实验代码
+```
+
+### 使用Wedata3PreCodeClient
+
+```python
+%pip install wedata-pre-code
+from wedata_pre_code.wedata3.client import Wedata3PreCodeClient
+
+# 初始化客户端
+client = Wedata3PreCodeClient(
+    workspace_id="{{WorkspaceID}}",
+    base_url="{{BaseUrl}}",
+    region="{{Region}}",
+    ap_region_id=int("{{RegionId}}"),
+    mlflow_gateway_url="{{MlflowGatewayUrl}}",
+    feast_gateway_url="{{FeastGatewayUrl}}",
+    mlflow_proxy_ip="{{MlflowProxyIp}}",
+    mlflow_proxy_port="{{MlflowProxyPort}}",
+    feast_proxy_ip="{{FeastProxyIp}}",
+    feast_proxy_port="{{FeastProxyPort}}",
+    kernel_task_name="{{TaskName}}",
+    kernel_task_id="{{TaskId}}",
+    kernel_submit_form_workflow="{{SubmitFormWorkflow}}",
+    cloud_sdk_secret_id="{{CloudSdkSecretId}}",
+    cloud_sdk_secret_key="{{CloudSdkSecretKey}}",
+    cloud_sdk_secret_token="{{CloudSdkSecretToken}}",
+    qcloud_uin="{{QcloudUin}}",
+    qcloud_subuin="{{QcloudSubUin}}",
+)
+
+client.init()
+```
+
+* 必传参数:
+    - workspace_id: 工作空间ID
+    - mlflow_tracking_uri: mlflow跟踪URI
+    - base_url: 基础URL
+    - mlflow_gateway_url: mlflow基础serverless网关地址
+    - feast_gateway_url: feast基础serverless网关地址
+    - mlflow_proxy_ip: mlflow转发地址
+    - mlflow_proxy_port: mlflow转发端口
+    - feast_proxy_ip: feast转发地址
+    - feast_proxy_port: feast转发端口
+* 可选参数:
+    - region: 区域
+    - ap_region_id: 区域ID
+    - kernel_task_name: Notebook路径名
+    - kernel_task_id:  Notebook文件ID
+    - kernel_submit_form_workflow: 任务提交表单工作流
+    - kernel_is_international: 是否国际站
+    - cloud_sdk_secret_id: 云SDK密钥ID
+    - cloud_sdk_secret_key: 云SDK密钥KEY
+    - cloud_sdk_secret_token: 云SDK密钥TOKEN
+    - qcloud_uin: 腾讯云uin
+    - qcloud_subuin: 腾讯云subuin
+    - 
+## 功能特性
+
+### 自动标签注入
+
+- 自动为实验、运行和模型注入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.8.dist-info/RECORD

@@ -0,0 +1,11 @@
+wedata_pre_code/__init__.py,sha256=-p_dX-VDC0sAqqAwuWLLlnzRNAHad1LF7wOFJw2z_uk,240
+wedata_pre_code/client.py,sha256=IrcbswwI206_Qxxc9IzqXYKkGrWB2IDbIyBzZa1ex0E,1111
+wedata_pre_code/common/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+wedata_pre_code/common/base_client.py,sha256=Y9lQBOYaDOB7Zy3MR_bPvHSQjN5Onsn8TPOzcTmGMEc,224
+wedata_pre_code/wedata2/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+wedata_pre_code/wedata2/client.py,sha256=ScAQRrT-alc2CqatiwLCNAymYfEtWKWTnrCsLTbYEoM,19535
+wedata_pre_code/wedata3/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+wedata_pre_code/wedata3/client.py,sha256=CKuuHHU9JZXQeLORtPU3xXSAXzynBFN6jec8UBvrC_I,21228
+wedata_pre_code-1.0.8.dist-info/WHEEL,sha256=eycQt0QpYmJMLKpE3X9iDk8R04v2ZF0x82ogq-zP6bQ,79
+wedata_pre_code-1.0.8.dist-info/METADATA,sha256=3WpiDxxbZigT7G00pLE8nzOJWflPKCXmIMiLYGRGmTQ,7371
+wedata_pre_code-1.0.8.dist-info/RECORD,,

wedata_pre_code-1.0.8.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: uv 0.9.24
+Root-Is-Purelib: true
+Tag: py3-none-any