code-loader 1.0.43__tar.gz → 1.0.43a0__tar.gz

{code_loader-1.0.43 → code_loader-1.0.43a0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: code-loader
-Version: 1.0.43
+Version: 1.0.43a0
 Summary: 
 Home-page: https://github.com/tensorleap/code-loader
 License: MIT
@@ -16,6 +16,8 @@ Classifier: Programming Language :: Python :: 3.11
 Requires-Dist: matplotlib (>=3.3,<3.4)
 Requires-Dist: numpy (>=1.22.3,<2.0.0)
 Requires-Dist: psutil (>=5.9.5,<6.0.0)
+Requires-Dist: pyyaml (>=6.0.2,<7.0.0)
+Requires-Dist: requests (>=2.32.3,<3.0.0)
 Project-URL: Repository, https://github.com/tensorleap/code-loader
 Description-Content-Type: text/markdown
 

{code_loader-1.0.43 → code_loader-1.0.43a0}/code_loader/__init__.py

@@ -1,2 +1,3 @@
 from code_loader.leaploader import LeapLoader
 from code_loader.inner_leap_binder import global_leap_binder as leap_binder
+from code_loader.rt_api import Epoch, Experiment

code_loader-1.0.43a0/code_loader/rt_api/__init__.py

@@ -0,0 +1,12 @@
+
+from code_loader.rt_api.experiment_context import ExperimentContext
+from code_loader.rt_api.epoch import Epoch
+from code_loader.rt_api.experiment import Experiment
+from code_loader.rt_api.api_client import ApiClient
+
+__all__ = [
+    'ExperimentContext',
+    'Epoch',
+    'Experiment',
+    'ApiClient'
+]

code_loader-1.0.43a0/code_loader/rt_api/api_client.py

@@ -0,0 +1,107 @@
+
+from dataclasses import dataclass
+from typing import Dict, List, Optional
+from code_loader.rt_api.types import ApiMetrics
+from code_loader.rt_api.utils import join_url, to_dict_no_none
+from .cli_config_utils import get_auth_config
+import requests
+
+
+@dataclass
+class StartExperimentRequest:
+    projectId: str
+    experimentName: str
+    description: str
+    removeUntaggedUploadedModels: bool = True
+    codeIntegrationVersionId: Optional[str] = None
+
+@dataclass
+class StartExperimentResponse:
+    projectId: str
+    versionId: str
+    experimentId: str
+
+@dataclass
+class GetUploadModelSignedUrlRequest:
+    epoch: int
+    experimentId: str
+    versionId: str
+    projectId: str
+    fileType: str
+    origin: Optional[str] = None
+
+@dataclass
+class GetUploadModelSignedUrlResponse:
+    url: str
+    fileName: str
+
+@dataclass
+class AddExternalEpochDataRequest:
+  projectId: str
+  experimentId: str
+  epoch: int
+  metrics: ApiMetrics
+  force: bool = False
+
+@dataclass
+class TagModelRequest:
+  projectId: str
+  experimentId: str
+  epoch: int
+  tags: List[str]
+
+@dataclass
+class SetExperimentNotesRequest:
+    projectId: str
+    experimentId: str
+    notes: Dict[str, any] # type: ignore[valid-type]
+
+class ApiClient:
+    def __init__(self, url: Optional[str] = None, token: Optional[str] = None):
+        if url is None or token is None:
+            configAuth = get_auth_config()
+            if configAuth is None:
+                raise Exception("No auth config found, either provide url and token or use `leap auth [url] [token]` to setup a config file")
+            url = configAuth.api_url
+            token = configAuth.api_key
+        
+        self.url = url
+        self.token = token
+
+    def __add_auth(self, headers: Dict[str, str]) -> Dict[str, str]:
+        headers['Authorization'] = f'Bearer {self.token}'
+        return headers
+    
+    def __post(self, post_path: str, data: any, headers: Dict[str, str] = {})-> requests.Response: # type: ignore[valid-type]
+        headers = self.__add_auth(headers)
+        if 'Content-Type' not in headers:
+            headers['Content-Type'] = 'application/json'
+        url = join_url(self.url, post_path)
+        json_data = to_dict_no_none(data)
+        return requests.post(url, json=json_data, headers=headers)
+    
+    def __check_response(self, response: requests.Response)-> None:
+        if response.status_code >= 400:
+            raise Exception(f"Error: {response.status_code} {response.text}")
+    
+    def start_experiment(self, data: StartExperimentRequest) -> StartExperimentResponse:
+        response = self.__post('/versions/startExperiment', data)
+        self.__check_response(response)
+        return StartExperimentResponse(**response.json())
+    
+    def get_attach_model_upload_signed_url(self, data: GetUploadModelSignedUrlRequest)-> GetUploadModelSignedUrlResponse:
+        response = self.__post('/versions/getUploadModelSignedUrl', data)
+        self.__check_response(response)
+        return GetUploadModelSignedUrlResponse(**response.json())
+    
+    def add_external_epoch_data(self, data: AddExternalEpochDataRequest)-> None:
+        response = self.__post('/externalepochdata/addExternalEpochData', data)
+        self.__check_response(response)
+    
+    def tag_model(self, data: TagModelRequest)-> None:
+        response = self.__post('/versions/tagModel', data)
+        self.__check_response(response)
+
+    def set_experiment_notes(self, data: SetExperimentNotesRequest)-> None:
+        response = self.__post('/versions/setExperimentNotes', data)
+        self.__check_response(response)

code_loader-1.0.43a0/code_loader/rt_api/cli_config_utils.py

@@ -0,0 +1,41 @@
+from dataclasses import dataclass
+import os
+from typing import Dict, Optional
+import yaml
+
+@dataclass
+class AuthConfig:
+    api_url: str
+    api_key: str
+
+@dataclass
+class Config:
+    current_env: str
+    envs: Dict[str, AuthConfig]
+
+def get_cli_conf_path()-> str:
+    cli_conf_path = os.getenv("TL_CLI_CONFIG_FILE") or os.path.join(os.path.expanduser("~"), ".config/tensorleap/config.yaml")
+    return cli_conf_path
+
+def get_cli_conf_file() -> Optional[Config]:
+    cli_conf_path = get_cli_conf_path()
+    if not os.path.exists(cli_conf_path):
+        return None
+    with open(cli_conf_path) as f:
+        y = yaml.safe_load(f)
+        envs_dict = y.get("envs")
+        if envs_dict is None:
+            return None
+        envs = dict()
+        for k, v in envs_dict.items():
+            envs[k] = AuthConfig(**v)
+        return Config(envs=envs, current_env=y["current_env"])
+    
+def get_auth_config() -> Optional[AuthConfig]:
+    cli_conf = get_cli_conf_file()
+    if cli_conf is None or cli_conf.current_env not in cli_conf.envs:
+        return None
+    return cli_conf.envs[cli_conf.current_env]
+
+
+    

code_loader-1.0.43a0/code_loader/rt_api/epoch.py

@@ -0,0 +1,63 @@
+
+from typing import List, Optional
+from code_loader.rt_api import ExperimentContext
+from code_loader.rt_api.types import Metrics
+from code_loader.rt_api.utils import to_api_metric_value, upload_file
+from .api_client import AddExternalEpochDataRequest, GetUploadModelSignedUrlRequest, TagModelRequest
+
+
+class Epoch:
+    def __init__(self, ctx: ExperimentContext, epoch: int):
+        self.experiment = ExperimentContext
+        self.epoch = epoch
+        self.metrics: Metrics = {}
+        self.ctx = ctx
+
+    def add_metric(self, name: str, value: float)-> None:
+        self.metrics[name] = value
+
+    def set_metrics(self, metrics: Metrics)-> None:
+        self.metrics = metrics
+
+    def upload_model(self, modelFilePath: str)-> None:
+        allowed_extensions = ["h5", "onnx"]
+        modelExtension = modelFilePath.split(".")[-1]
+        if modelExtension not in allowed_extensions:
+            raise Exception(f"Model file extension not allowed. Allowed extensions are {allowed_extensions}")
+        url = self.ctx.client.get_attach_model_upload_signed_url(GetUploadModelSignedUrlRequest(
+            epoch=self.epoch,
+            experimentId=self.ctx.experiment_id,
+            versionId=self.ctx.version_id,
+            projectId=self.ctx.project_id,
+            fileType=modelExtension
+        ))
+        print(f"Uploading epoch({self.epoch}) model file")
+        upload_file(url.url, modelFilePath)
+        print("Model file uploaded")
+    
+    def tag_model(self, tags: List[str])-> None:
+        print(f"Tagging epoch({self.epoch}) model")
+        self.ctx.client.tag_model(TagModelRequest(
+            experimentId=self.ctx.experiment_id,
+            projectId=self.ctx.project_id,
+            epoch=self.epoch,
+            tags=tags
+        ))
+
+    def save(self, modelFilePath: Optional[str] = None, tags: List[str] = ['latest'])-> None:
+        if modelFilePath is not None:
+            self.upload_model(modelFilePath)
+
+        print(f"Add metrics for epoch({self.epoch}) model")
+        api_metrics ={
+            key: to_api_metric_value(value) for key, value in self.metrics.items()
+        }
+        self.ctx.client.add_external_epoch_data(AddExternalEpochDataRequest(
+            experimentId=self.ctx.experiment_id,
+            projectId=self.ctx.project_id,
+            epoch=self.epoch,
+            metrics=api_metrics
+        ))
+        if modelFilePath is not None and len(tags) > 0:
+            self.tag_model(tags)
+   

code_loader-1.0.43a0/code_loader/rt_api/experiment.py

@@ -0,0 +1,47 @@
+
+from typing import Dict, List, Optional
+from code_loader.rt_api import Epoch, ExperimentContext
+from code_loader.rt_api.types import Metrics
+from code_loader.rt_api.workingspace_config_utils import load_workspace_config
+from .api_client import  SetExperimentNotesRequest, StartExperimentRequest, ApiClient
+
+        
+class Experiment:
+    def __init__(self, ctx: ExperimentContext):
+        self.ctx = ctx
+
+    def start_epoch(self, epoch: int) -> Epoch:
+        return Epoch(self.ctx, epoch)
+    
+    def add_epoch(self, epoch: int, metrics: Optional[Metrics] = None, model_path: Optional[str] = None, tags: List[str] = ['latest'])-> None:
+        epoch_o = self.start_epoch(epoch)
+        if metrics is not None:
+            epoch_o.set_metrics(metrics)
+        epoch_o.save(model_path, tags)
+
+    def set_notes(self, notes: Dict[str, any])-> None: # type: ignore[valid-type]
+        print(f"Setting experiment({self.ctx.experiment_id}) notes")
+        self.ctx.client.set_experiment_notes(SetExperimentNotesRequest(
+            experimentId=self.ctx.experiment_id,
+            projectId=self.ctx.project_id,
+            notes=notes
+        ))
+    
+    @staticmethod
+    def Start(experimentName: str, description: str, working_dir: Optional[str] = None, client: Optional[ApiClient] = None) -> 'Experiment':
+        
+        if client is None:
+            client = ApiClient()
+        
+        workspace_config = load_workspace_config(working_dir)
+        if workspace_config is None or workspace_config.projectId is None:
+            raise Exception("No leap workspace config found or projectId is missing, make sure you are in a leap workspace directory or provide a working_dir")
+
+        result = client.start_experiment(StartExperimentRequest(
+            projectId=workspace_config.projectId,
+            experimentName=experimentName,
+            description=description,
+            codeIntegrationVersionId=workspace_config.codeIntegrationId
+        ))
+        ctx = ExperimentContext(client, result.projectId, result.versionId, result.experimentId)
+        return Experiment(ctx)

code_loader-1.0.43a0/code_loader/rt_api/experiment_context.py

@@ -0,0 +1,10 @@
+from dataclasses import dataclass
+from code_loader.rt_api.api_client import ApiClient
+
+
+@dataclass
+class ExperimentContext:
+    client: ApiClient
+    project_id: str
+    version_id: str
+    experiment_id: str

code_loader-1.0.43a0/code_loader/rt_api/types.py

@@ -0,0 +1,25 @@
+
+from dataclasses import dataclass
+from typing import Dict, Union
+
+
+MetricValue = Union[str, float]
+Metrics = Dict[str, MetricValue]
+
+@dataclass
+class NumericMetricValue:
+    value: float
+    type: str = "number"
+
+@dataclass
+class StringMetricValue:
+    value: str
+    type: str = "string"
+
+@dataclass
+class ImageMetricValue:
+    value: str
+    type: str = "image"
+
+ApiMetricValue = Union[NumericMetricValue, StringMetricValue, ImageMetricValue]
+ApiMetrics = Dict[str, ApiMetricValue]

code_loader-1.0.43a0/code_loader/rt_api/utils.py

@@ -0,0 +1,34 @@
+from dataclasses import asdict, is_dataclass
+from typing import Dict
+from urllib.parse import urljoin
+from code_loader.rt_api.types import ApiMetricValue, MetricValue, NumericMetricValue, StringMetricValue
+import requests
+
+def upload_file(url: str, file_path: str)-> None:
+    with open(file_path, "rb") as f:
+        requests.put(url, data=f, timeout=12_000)
+
+def to_dict_no_none(data: any)-> Dict[str, any]: # type: ignore[valid-type]
+    if is_dataclass(data):
+        data = asdict(data)
+    if isinstance(data, dict):
+        return {k: to_dict_no_none(v) for k, v in data.items() if v is not None}
+    elif isinstance(data, list):
+        return [to_dict_no_none(item) for item in data if item is not None]
+    else:
+        return data
+
+def join_url(base_url: str, post_path: str)-> str:
+    if not base_url.endswith('/'):
+        base_url += '/'
+    if post_path.startswith('/'):
+        post_path = post_path[1:]
+    return urljoin(base_url, post_path)
+
+def to_api_metric_value(value: MetricValue) -> ApiMetricValue:
+    if isinstance(value, float) or isinstance(value, int):
+        return NumericMetricValue(value=value)
+    elif isinstance(value, str):
+        return StringMetricValue(value=value)
+    else:
+        raise Exception(f"Unsupported metric value type: {type(value)}")

code_loader-1.0.43a0/code_loader/rt_api/workingspace_config_utils.py

@@ -0,0 +1,27 @@
+from dataclasses import dataclass
+from os import path
+import os
+from typing import List, Optional
+import yaml
+
+
+@dataclass
+class LocalProjectConfig:
+    codeIntegrationId: Optional[str] = None
+    projectId: Optional[str] = None
+    secretId: Optional[str] = None
+    secretManagerId: Optional[str] = None
+    entryFile: Optional[str] = None
+    includePatterns: Optional[List[str]] = None
+
+# Loading workspace configuration from leap.yaml
+def load_workspace_config(workspace_dir: Optional[str] = None) -> Optional[LocalProjectConfig]:
+    if workspace_dir is None:
+        workspace_dir = os.getcwd()
+    elif not path.isabs(workspace_dir):
+        workspace_dir = path.join(os.getcwd(), workspace_dir)
+
+    file_path = path.join(workspace_dir, "leap.yaml")
+    with open(file_path) as f:
+        y = yaml.safe_load(f)
+        return LocalProjectConfig(**y)

{code_loader-1.0.43 → code_loader-1.0.43a0}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "code-loader"
-version = "1.0.43"
+version = "1.0.43a0"
 description = ""
 authors = ["dorhar <doron.harnoy@tensorleap.ai>"]
 license = "MIT"
@@ -16,6 +16,8 @@ python = ">=3.8,<3.12"
 numpy = "^1.22.3"
 psutil = "^5.9.5"
 matplotlib = ">=3.3,<3.4"
+requests = "^2.32.3"
+pyyaml = "^6.0.2"
 
 [tool.poetry.dev-dependencies]
 pytest = "^7.1.1"