humalab 0.0.5__py3-none-any.whl → 0.0.6__py3-none-any.whl

humalab/__init__.py

@@ -1,9 +1,20 @@
 from humalab.humalab import init, finish, login
+from humalab import assets
+from humalab import metrics
+from humalab import scenarios
 from humalab.run import Run
+from humalab.constants import MetricDimType, GraphType
+# from humalab import evaluators
 
 __all__ = [
     "init",
     "finish",
     "login",
+    "assets",
+    "metrics",
+    "scenarios",
     "Run",
+    "MetricDimType",
+    "GraphType",
+#    "evaluators",
 ]

humalab/assets/__init__.py

@@ -1,4 +1,4 @@
-from .resource_manager import ResourceManager
+from .resource_operator import download, list_resources
 from .files import ResourceFile, URDFFile
 
-__all__ = ["ResourceManager", "ResourceFile", "URDFFile"]
+__all__ = ["download", "list_resources", "ResourceFile", "URDFFile"]

humalab/assets/files/resource_file.py

@@ -1,4 +1,17 @@
 from datetime import datetime
+from enum import Enum
+
+from humalab.constants import DEFAULT_PROJECT
+
+class ResourceType(Enum):
+    URDF = "urdf"
+    MJCF = "mjcf"
+    USD = "usd"
+    MESH = "mesh"
+    VIDEO = "video"
+    IMAGE = "image"
+    DATA = "data"
+
 
 
 class ResourceFile:
@@ -6,16 +19,22 @@ class ResourceFile:
                  name: str, 
                  version: int, 
                  filename: str,
-                 resource_type: str,
+                 resource_type: str | ResourceType,
+                 project: str = DEFAULT_PROJECT,
                  description: str | None = None,
                  created_at: datetime | None = None):
+        self._project = project
         self._name = name
         self._version = version
         self._filename = filename
-        self._resource_type = resource_type
+        self._resource_type = ResourceType(resource_type)
         self._description = description
         self._created_at = created_at
 
+    @property
+    def project(self) -> str:
+        return self._project
+    
     @property
     def name(self) -> str:
         return self._name
@@ -29,7 +48,7 @@ class ResourceFile:
         return self._filename
     
     @property
-    def resource_type(self) -> str:
+    def resource_type(self) -> ResourceType:
         return self._resource_type
 
     @property
@@ -39,3 +58,10 @@ class ResourceFile:
     @property
     def description(self) -> str | None:
         return self._description
+    
+    def __repr__(self) -> str:
+        return f"ResourceFile(project={self._project}, name={self._name}, version={self._version}, filename={self._filename}, resource_type={self._resource_type}, description={self._description}, created_at={self._created_at})"
+    
+    def __str__(self) -> str:
+        return self.__repr__()
+

humalab/assets/files/urdf_file.py

@@ -1,8 +1,10 @@
-from datetime import datetime
 import os
 import glob
-from humalab.assets.files.resource_file import ResourceFile
+from datetime import datetime
+
+from humalab.assets.files.resource_file import ResourceFile, ResourceType
 from humalab.assets.archive import extract_archive
+from humalab.constants import DEFAULT_PROJECT
 
 
 class URDFFile(ResourceFile):
@@ -10,30 +12,32 @@ class URDFFile(ResourceFile):
                  name: str, 
                  version: int,
                  filename: str,
+                 project: str = DEFAULT_PROJECT,
                  urdf_filename: str | None = None,
                  description: str | None = None,
                  created_at: datetime | None = None,):
-        super().__init__(name=name, 
+        super().__init__(project=project,
+                         name=name, 
                          version=version,
                          description=description,
                          filename=filename,
-                         resource_type="URDF", 
+                         resource_type=ResourceType.URDF, 
                          created_at=created_at)
         self._urdf_base_filename = urdf_filename
         self._urdf_filename, self._root_path = self._extract()
         self._urdf_filename = os.path.join(self._urdf_filename, self._urdf_filename)
         
     def _extract(self):
-        working_path = os.path.dirname(self._filename)
-        if os.path.exists(self._filename):
-            _, ext = os.path.splitext(self._filename)
+        working_path = os.path.dirname(self.filename)
+        if os.path.exists(self.filename):
+            _, ext = os.path.splitext(self.filename)
             ext = ext.lstrip('.')  # Remove leading dot
             if ext.lower() != "urdf":
-                extract_archive(self._filename, working_path)
+                extract_archive(self.filename, working_path)
                 try:
-                    os.remove(self._filename)
+                    os.remove(self.filename)
                 except Exception as e:
-                    print(f"Error removing saved file {self._filename}: {e}")
+                    print(f"Error removing saved file {self.filename}: {e}")
         local_filename = self.search_resource_file(self._urdf_base_filename, working_path)
         if local_filename is None:
             raise ValueError(f"Resource filename {self._urdf_base_filename} not found in {working_path}")

humalab/assets/resource_operator.py

@@ -0,0 +1,91 @@
+from humalab.constants import DEFAULT_PROJECT
+from humalab.assets.files.resource_file import ResourceFile, ResourceType
+from humalab.humalab_config import HumalabConfig
+from humalab.humalab_api_client import HumaLabApiClient
+from humalab.assets.files.urdf_file import URDFFile
+import os
+from typing import Any, Optional
+
+        
+def _asset_dir(humalab_config: HumalabConfig, name: str, version: int) -> str:
+    return os.path.join(humalab_config.workspace_path, "assets", name, f"{version}")
+
+def _create_asset_dir(humalab_config: HumalabConfig, name: str, version: int) -> bool:
+    asset_dir = _asset_dir(humalab_config, name, version)
+    if not os.path.exists(asset_dir):
+        os.makedirs(asset_dir, exist_ok=True)
+        return True
+    return False
+
+def download(name: str, 
+             version: int | None=None,
+             project: str = DEFAULT_PROJECT,
+             
+             host: str | None = None,
+             api_key: str | None = None,
+             timeout: float | None = None,
+             ) -> Any:
+    humalab_config = HumalabConfig()
+
+    api_client = HumaLabApiClient(base_url=host,
+                                  api_key=api_key,
+                                  timeout=timeout)
+
+    resource = api_client.get_resource(project_name=project, name=name, version=version)
+    filename = os.path.basename(resource['resource_url'])
+    filename = os.path.join(_asset_dir(humalab_config, name, resource["version"]), filename)
+    if _create_asset_dir(humalab_config, name, resource["version"]):
+        file_content = api_client.download_resource(project_name=project, name="lerobot")
+        with open(filename, "wb") as f:
+            f.write(file_content)
+    
+    if resource["resource_type"].lower() == "urdf":
+        return URDFFile(project=project,
+                        name=name,
+                        version=resource["version"],
+                        description=resource.get("description"),
+                        filename=filename,
+                        urdf_filename=resource.get("filename"),
+                        created_at=resource.get("created_at"))
+
+    return ResourceFile(project=project,
+                        name=name, 
+                        version=resource["version"], 
+                        filename=filename,
+                        resource_type=resource["resource_type"],
+                        description=resource.get("description"),
+                        created_at=resource.get("created_at"))
+
+def list_resources(project: str = DEFAULT_PROJECT,
+                   resource_types: Optional[list[str | ResourceType]] = None,
+                   limit: int = 20,
+                   offset: int = 0,
+                   latest_only: bool = True,
+                    
+                    host: str | None = None,
+                    api_key: str | None = None,
+                    timeout: float | None = None,) -> list[ResourceFile]:
+    api_client = HumaLabApiClient(base_url=host,
+                                  api_key=api_key,
+                                  timeout=timeout)
+
+    resource_type_string = None
+    if resource_types:
+        resource_type_strings = {rt.value if isinstance(rt, ResourceType) else rt for rt in resource_types}
+        resource_type_string = ",".join(resource_type_strings)
+    resp = api_client.get_resources(project_name=project,
+                                    resource_types=resource_type_string,
+                                    limit=limit,
+                                    offset=offset,
+                                    latest_only=latest_only)
+    resources = resp.get("resources", [])
+    ret_list = []
+    for resource in resources:
+        ret_list.append(ResourceFile(name=resource["name"],
+                                    version=resource.get("version"),
+                                    project=project,
+                                    filename=resource.get("filename"),
+                                    resource_type=resource.get("resource_type"),
+                                    description=resource.get("description"),
+                                    created_at=resource.get("created_at")))
+    return ret_list

humalab/constants.py

@@ -1,7 +1,41 @@
 from enum import Enum
 
-class EpisodeStatus(Enum):
-    PASS = "pass"
-    FAILED = "failed"
-    CANCELED = "canceled"
-    ERROR = "error"
+
+RESERVED_NAMES = {
+    "sceanario"
+}
+
+DEFAULT_PROJECT = "default"
+
+
+class ArtifactType(Enum):
+    """Types of artifacts that can be stored"""
+    METRICS = "metrics" # Run & Episode
+    SCENARIO_STATS = "scenario_stats" # Run only
+    PYTHON = "python" # Run & Episode
+    CODE = "code" # Run & Episode (YAML)
+
+
+class MetricType(Enum):
+    METRICS = ArtifactType.METRICS.value
+    SCENARIO_STATS = ArtifactType.SCENARIO_STATS.value
+
+
+class GraphType(Enum):
+    """Types of graphs supported by Humalab."""
+    NUMERIC = "numeric"
+    LINE = "line"
+    BAR = "bar"
+    SCATTER = "scatter"
+    HISTOGRAM = "histogram"
+    GAUSSIAN = "gaussian"
+    HEATMAP = "heatmap"
+    THREE_D_MAP = "3d_map"
+
+
+class MetricDimType(Enum):
+    """Types of metric dimensions"""
+    ZERO_D = "0d"
+    ONE_D = "1d"
+    TWO_D = "2d"
+    THREE_D = "3d"

humalab/dists/bernoulli.py

@@ -31,8 +31,9 @@ class Bernoulli(Distribution):
             return True
         if not isinstance(arg1, (int, float)):
             if isinstance(arg1, (list, np.ndarray)):
-                if len(arg1) > dimensions:
+                if len(arg1) != dimensions:
                     return False
+
         return True
 
     def _sample(self) -> int | float | np.ndarray:

humalab/dists/discrete.py

@@ -41,11 +41,11 @@ class Discrete(Distribution):
             return True
         if not isinstance(arg1, int):
             if isinstance(arg1, (list, np.ndarray)):
-                if len(arg1) > dimensions:
+                if len(arg1) != dimensions:
                     return False
         if not isinstance(arg2, int):
             if isinstance(arg2, (list, np.ndarray)):
-                if len(arg2) > dimensions:
+                if len(arg2) != dimensions:
                     return False
         return True
 

humalab/dists/gaussian.py

@@ -37,11 +37,11 @@ class Gaussian(Distribution):
             return True
         if not isinstance(arg1, (int, float)):
             if isinstance(arg1, (list, np.ndarray)):
-                if len(arg1) > dimensions:
+                if len(arg1) != dimensions:
                     return False
         if not isinstance(arg2, (int, float)):
             if isinstance(arg2, (list, np.ndarray)):
-                if len(arg2) > dimensions:
+                if len(arg2) != dimensions:
                     return False
         return True
 

humalab/dists/log_uniform.py

@@ -37,11 +37,11 @@ class LogUniform(Distribution):
             return True
         if not isinstance(arg1, (int, float)):
             if isinstance(arg1, (list, np.ndarray)):
-                if len(arg1) > dimensions:
+                if len(arg1) != dimensions:
                     return False
         if not isinstance(arg2, (int, float)):
             if isinstance(arg2, (list, np.ndarray)):
-                if len(arg2) > dimensions:
+                if len(arg2) != dimensions:
                     return False
         return True
 

humalab/dists/truncated_gaussian.py

@@ -49,19 +49,19 @@ class TruncatedGaussian(Distribution):
             return True
         if not isinstance(arg1, (int, float)):
             if isinstance(arg1, (list, np.ndarray)):
-                if len(arg1) > dimensions:
+                if len(arg1) != dimensions:
                     return False
         if not isinstance(arg2, (int, float)):
             if isinstance(arg2, (list, np.ndarray)):
-                if len(arg2) > dimensions:
+                if len(arg2) != dimensions:
                     return False
         if not isinstance(arg3, (int, float)):
             if isinstance(arg3, (list, np.ndarray)):
-                if len(arg3) > dimensions:
+                if len(arg3) != dimensions:
                     return False
         if not isinstance(arg4, (int, float)):
             if isinstance(arg4, (list, np.ndarray)):
-                if len(arg4) > dimensions:
+                if len(arg4) != dimensions:
                     return False
         return True
     

humalab/episode.py

@@ -1,20 +1,121 @@
+from humalab.constants import RESERVED_NAMES, ArtifactType
+from humalab.humalab_api_client import HumaLabApiClient, EpisodeStatus
+from humalab.metrics.code import Code
+from humalab.metrics.summary import Summary
+from humalab.metrics.metric import Metrics
+from omegaconf import DictConfig, ListConfig, OmegaConf
+from typing import Any
+import pickle
+import traceback
 
-from humalab.scenario import Scenario
-from omegaconf import DictConfig, OmegaConf
+from humalab.utils import is_standard_type
 
 
 class Episode:
-    def __init__(self, run_id: str, episode_id: str, scenario_conf: DictConfig):
-        self.run_id = run_id
-        self.episode_id = episode_id
-        self.scenario_conf = scenario_conf
+    def __init__(self, 
+                 run_id: str, 
+                 episode_id: str, 
+                 scenario_conf: DictConfig | ListConfig,
+                 episode_vals: dict | None = None,
+
+                 base_url: str | None = None,
+                 api_key: str | None = None,
+                 timeout: float | None = None,):
+        self._run_id = run_id
+        self._episode_id = episode_id
+        self._episode_status = EpisodeStatus.RUNNING
+        self._scenario_conf = scenario_conf
+        self._logs = {}
+        self._episode_vals = episode_vals or {}
+        self._is_finished = False
+
+        self._api_client = HumaLabApiClient(base_url=base_url,
+                                            api_key=api_key,
+                                            timeout=timeout)
+
+    @property
+    def run_id(self) -> str:
+        return self._run_id
+    
+    @property
+    def episode_id(self) -> str:
+        return self._episode_id
 
     @property
-    def scenario(self) -> DictConfig:
-        return self.scenario_conf
+    def scenario(self) -> DictConfig | ListConfig:
+        return self._scenario_conf
+    
+    @property
+    def status(self) -> EpisodeStatus:
+        return self._episode_status
+    
+    @property
+    def episode_vals(self) -> dict:
+        return self._episode_vals
+    
+    @property
+    def is_finished(self) -> bool:
+        return self._is_finished
+    
+    def __enter__(self):
+        return self
+
+    def __exit__(self, exception_type, exception_value, exception_traceback):
+        if self._is_finished:
+            return
+        if exception_type is not None:
+            err_msg = "".join(traceback.format_exception(exception_type, exception_value, exception_traceback))
+            self.finish(status=EpisodeStatus.ERRORED, err_msg=err_msg)
+        else:
+            self.finish(status=EpisodeStatus.SUCCESS)
 
-    def finish(self):
-        print(f"Finishing episode {self.episode_id} for scenario {self.scenario.name}")
+    def __getattr__(self, name: Any) -> Any:
+        if name in self._scenario_conf:
+            return self._scenario_conf[name]
+        raise AttributeError(f"'Scenario' object has no attribute '{name}'")
+
+    def __getitem__(self, key: Any) -> Any:
+        if key in self._scenario_conf:
+            return self._scenario_conf[key]
+        raise KeyError(f"'Scenario' object has no key '{key}'")
+
+    def add_metric(self, name: str, metric: Metrics) -> None:
+        if name in self._logs:
+            raise ValueError(f"{name} is a reserved name and is not allowed.")
+        self._logs[name] = metric
+    
+    def log_code(self, key: str, code_content: str) -> None:
+        """Log code content as an artifact.
+
+        Args:
+            key (str): The key for the code artifact.
+            code_content (str): The code content to log.
+        """
+        if key in RESERVED_NAMES:
+            raise ValueError(f"{key} is a reserved name and is not allowed.")
+        self._logs[key] = Code(
+            run_id=self._run_id,
+            key=key,
+            code_content=code_content,
+            episode_id=self._episode_id
+        )
+
+    def log(self, data: dict, x: dict | None = None, replace: bool = False) -> None:
+        for key, value in data.items():
+            if key in RESERVED_NAMES:
+                raise ValueError(f"{key} is a reserved name and is not allowed.")
+            if key not in self._logs:
+                self._logs[key] = value
+            else:
+                cur_val = self._logs[key]
+                if isinstance(cur_val, Metrics):
+                    cur_x = x.get(key) if x is not None else None
+                    cur_val.log(value, x=cur_x, replace=replace)
+                else:
+                    if replace:
+                        self._logs[key] = value
+                    else:
+                        raise ValueError(f"Cannot log value for key '{key}' as there is already a value logged.")
 
     @property
     def yaml(self) -> str:
@@ -23,4 +124,73 @@ class Episode:
         Returns:
             str: The current scenario as a YAML string.
         """
-        return OmegaConf.to_yaml(self.scenario_conf)
+        return OmegaConf.to_yaml(self._scenario_conf)
+    
+    def discard(self) -> None:
+        self._finish(EpisodeStatus.CANCELED)
+
+    def success(self) -> None:
+        self._finish(EpisodeStatus.SUCCESS)
+    
+    def fail(self) -> None:
+        self._finish(EpisodeStatus.FAILED)
+
+    def finish(self, status: EpisodeStatus, err_msg: str | None = None) -> None:
+        if self._is_finished:
+            return
+        self._is_finished = True
+        self._episode_status = status
+
+        self._api_client.upload_code(
+            artifact_key="scenario",
+            run_id=self._run_id,
+            episode_id=self._episode_id,
+            code_content=self.yaml
+        )
+
+        # TODO: submit final metrics
+        for key, value in self._logs.items():
+            if isinstance(value, Summary):
+                metric_val = value.finalize()
+                pickled = pickle.dumps(metric_val["value"])
+                self._api_client.upload_python(
+                    artifact_key=key,
+                    run_id=self._id,
+                    episode_id=self._episode_id,
+                    pickled_bytes=pickled
+                )
+            elif isinstance(value, Metrics):
+                metric_val = value.finalize()
+                pickled = pickle.dumps(metric_val)
+                self._api_client.upload_metrics(
+                    artifact_key=key,
+                    run_id=self._id,
+                    episode_id=self._episode_id,
+                    pickled_bytes=pickled,
+                    graph_type=value.graph_type.value,
+                    metric_dim_type=value.metric_dim_type.value
+                )
+            elif isinstance(value, Code):
+                self._api_client.upload_code(
+                    artifact_key=value.key,
+                    run_id=value.run_id,
+                    episode_id=value.episode_id,
+                    code_content=value.code_content
+                )
+            else:
+                if not is_standard_type(value):
+                    raise ValueError(f"Value for key '{key}' is not a standard type.")
+                pickled = pickle.dumps(value)
+                self._api_client.upload_python(
+                    artifact_key=key,
+                    run_id=self._run_id,
+                    episode_id=self._episode_id,
+                    pickled_bytes=pickled
+                )
+        
+        self._api_client.update_episode(
+            run_id=self._run_id,
+            episode_id=self._episode_id,
+            status=status,
+            err_msg=err_msg
+        )