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

humalab/assets/__init__.py

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

humalab/assets/files/__init__.py

@@ -0,0 +1,4 @@
+from .resource_file import ResourceFile
+from .urdf_file import URDFFile
+
+__all__ = ["ResourceFile", "URDFFile"]

humalab/assets/files/resource_file.py

@@ -0,0 +1,41 @@
+from datetime import datetime
+
+
+class ResourceFile:
+    def __init__(self, 
+                 name: str, 
+                 version: int, 
+                 filename: str,
+                 resource_type: str,
+                 description: str | None = None,
+                 created_at: datetime | None = None):
+        self._name = name
+        self._version = version
+        self._filename = filename
+        self._resource_type = resource_type
+        self._description = description
+        self._created_at = created_at
+
+    @property
+    def name(self) -> str:
+        return self._name
+    
+    @property
+    def version(self) -> int:
+        return self._version
+    
+    @property
+    def filename(self) -> str:
+        return self._filename
+    
+    @property
+    def resource_type(self) -> str:
+        return self._resource_type
+
+    @property
+    def created_at(self) -> datetime | None:
+        return self._created_at
+
+    @property
+    def description(self) -> str | None:
+        return self._description

humalab/assets/files/urdf_file.py

@@ -0,0 +1,65 @@
+from datetime import datetime
+import os
+import glob
+from humalab.assets.files.resource_file import ResourceFile
+from humalab.assets.archive import extract_archive
+
+
+class URDFFile(ResourceFile):
+    def __init__(self, 
+                 name: str, 
+                 version: int,
+                 filename: str,
+                 urdf_filename: str | None = None,
+                 description: str | None = None,
+                 created_at: datetime | None = None,):
+        super().__init__(name=name, 
+                         version=version,
+                         description=description,
+                         filename=filename,
+                         resource_type="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)
+            ext = ext.lstrip('.')  # Remove leading dot
+            if ext.lower() != "urdf":
+                extract_archive(self._filename, working_path)
+                try:
+                    os.remove(self._filename)
+                except Exception as 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}")
+        return local_filename, working_path
+
+    def search_resource_file(self, resource_filename: str | None, working_path: str) -> str | None:
+        found_filename = None
+        if resource_filename:
+            search_path = os.path.join(working_path, "**")
+            search_pattern = os.path.join(search_path, resource_filename)
+            files = glob.glob(search_pattern, recursive=True)
+            if len(files) > 0:
+                found_filename = files[0]
+        
+        if found_filename is None:
+            ext = "urdf"
+            search_pattern = os.path.join(working_path, "**", f"*.{ext}")
+            files = glob.glob(search_pattern, recursive=True)
+            if len(files) > 0:
+                found_filename = files[0]
+        return found_filename
+
+    @property
+    def urdf_filename(self) -> str | None:
+        return self._urdf_filename
+    
+    @property
+    def root_path(self) -> str:
+        return self._root_path

humalab/assets/resource_manager.py

@@ -0,0 +1,58 @@
+from humalab.assets.files.resource_file import ResourceFile
+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
+
+
+class ResourceManager:
+    def __init__(self,
+                 api_key: str | None = None,
+                 host: str | None = None,
+                 timeout: float | None = None):
+        self._humalab_config = HumalabConfig()
+        self._base_url = host or self._humalab_config.base_url
+        self._api_key = api_key or self._humalab_config.api_key
+        self._timeout = timeout or self._humalab_config.timeout
+
+        self._api_client = HumaLabApiClient(base_url=self._base_url,
+                                      api_key=self._api_key,
+                                      timeout=self._timeout)
+        
+    def _asset_dir(self, name: str, version: int) -> str:
+        return os.path.join(self._humalab_config.workspace_path, "assets", name, f"{version}")
+    
+    def _create_asset_dir(self, name: str, version: int) -> bool:
+        asset_dir = self._asset_dir(name, version)
+        if not os.path.exists(asset_dir):
+            os.makedirs(asset_dir, exist_ok=True)
+            return True
+        return False
+
+    def download(self,
+                 project: str,
+                 name: str, 
+                 version: int | None=None) -> Any:
+        resource = self._api_client.get_resource(project_name=project, name=name, version=version)
+        filename = os.path.basename(resource['resource_url'])
+        filename = os.path.join(self._asset_dir(name, resource["version"]), filename)
+        if self._create_asset_dir(name, resource["version"]):
+            file_content = self._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(name=resource["name"],
+                            version=resource["version"],
+                            description=resource.get("description"),
+                            filename=filename,
+                            urdf_filename=resource.get("filename"),
+                            created_at=resource.get("created_at"))
+
+        return ResourceFile(name=name, 
+                            version=resource["version"], 
+                            filename=filename,
+                            resource_type=resource["resource_type"],
+                            description=resource.get("description"),
+                            created_at=resource.get("created_at"))

humalab/dists/bernoulli.py

@@ -20,6 +20,21 @@ class Bernoulli(Distribution):
         self._p = p
         self._size = size
 
+    @staticmethod
+    def validate(dimensions: int, *args) -> bool:
+        arg1 = args[0]
+        if dimensions == 0:
+            if not isinstance(arg1, (int, float)):
+                return False
+            return True
+        if dimensions == -1:
+            return True
+        if not isinstance(arg1, (int, float)):
+            if isinstance(arg1, (list, np.ndarray)):
+                if len(arg1) > dimensions:
+                    return False
+        return True
+
     def _sample(self) -> int | float | np.ndarray:
         return self._generator.binomial(n=1, p=self._p, size=self._size)
 

humalab/dists/categorical.py

@@ -20,8 +20,15 @@ class Categorical(Distribution):
         super().__init__(generator=generator)
         self._choices = choices
         self._size = size
+        if weights is not None and not np.isclose(sum(weights), 1.0):
+            weight_sum = sum(weights)
+            weights = [w / weight_sum for w in weights]
         self._weights = weights
 
+    @staticmethod
+    def validate(dimensions: int, *args) -> bool:
+        return True
+
     def _sample(self) -> int | float | np.ndarray:
         return self._generator.choice(self._choices, size=self._size, p=self._weights)
 

humalab/dists/discrete.py

@@ -26,6 +26,28 @@ class Discrete(Distribution):
         self._high = np.array(high)
         self._size = size
         self._endpoint = endpoint if endpoint is not None else True
+    
+    @staticmethod
+    def validate(dimensions: int, *args) -> bool:
+        arg1 = args[0]
+        arg2 = args[1]
+        if dimensions == 0:
+            if not isinstance(arg1, int):
+                return False
+            if not isinstance(arg2, int):
+                return False
+            return True
+        if dimensions == -1:
+            return True
+        if not isinstance(arg1, int):
+            if isinstance(arg1, (list, np.ndarray)):
+                if len(arg1) > dimensions:
+                    return False
+        if not isinstance(arg2, int):
+            if isinstance(arg2, (list, np.ndarray)):
+                if len(arg2) > dimensions:
+                    return False
+        return True
 
     def _sample(self) -> int | float | np.ndarray:
         return self._generator.integers(self._low, self._high, size=self._size, endpoint=self._endpoint)

humalab/dists/gaussian.py

@@ -23,6 +23,28 @@ class Gaussian(Distribution):
         self._scale = scale
         self._size = size
 
+    @staticmethod
+    def validate(dimensions: int, *args) -> bool:
+        arg1 = args[0]
+        arg2 = args[1]
+        if dimensions == 0:
+            if not isinstance(arg1, (int, float)):
+                return False
+            if not isinstance(arg2, (int, float)):
+                return False
+            return True
+        if dimensions == -1:
+            return True
+        if not isinstance(arg1, (int, float)):
+            if isinstance(arg1, (list, np.ndarray)):
+                if len(arg1) > dimensions:
+                    return False
+        if not isinstance(arg2, (int, float)):
+            if isinstance(arg2, (list, np.ndarray)):
+                if len(arg2) > dimensions:
+                    return False
+        return True
+
     def _sample(self) -> int | float | np.ndarray:
         return self._generator.normal(loc=self._loc, scale=self._scale, size=self._size)
 

humalab/dists/log_uniform.py

@@ -22,6 +22,28 @@ class LogUniform(Distribution):
         self._log_low = np.log(np.array(low))
         self._log_high = np.log(np.array(high))
         self._size = size
+    
+    @staticmethod
+    def validate(dimensions: int, *args) -> bool:
+        arg1 = args[0]
+        arg2 = args[1]
+        if dimensions == 0:
+            if not isinstance(arg1, (int, float)):
+                return False
+            if not isinstance(arg2, (int, float)):
+                return False
+            return True
+        if dimensions == -1:
+            return True
+        if not isinstance(arg1, (int, float)):
+            if isinstance(arg1, (list, np.ndarray)):
+                if len(arg1) > dimensions:
+                    return False
+        if not isinstance(arg2, (int, float)):
+            if isinstance(arg2, (list, np.ndarray)):
+                if len(arg2) > dimensions:
+                    return False
+        return True
 
     def _sample(self) -> int | float | np.ndarray:
         return np.exp(self._generator.uniform(self._log_low, self._log_high, size=self._size))

humalab/dists/truncated_gaussian.py

@@ -29,6 +29,42 @@ class TruncatedGaussian(Distribution):
         self._high = high
         self._size = size
 
+    @staticmethod
+    def validate(dimensions: int, *args) -> bool:
+        arg1 = args[0]
+        arg2 = args[1]
+        arg3 = args[2]
+        arg4 = args[3]
+        if dimensions == 0:
+            if not isinstance(arg1, (int, float)):
+                return False
+            if not isinstance(arg2, (int, float)):
+                return False
+            if not isinstance(arg3, (int, float)):
+                return False
+            if not isinstance(arg4, (int, float)):
+                return False
+            return True
+        if dimensions == -1:
+            return True
+        if not isinstance(arg1, (int, float)):
+            if isinstance(arg1, (list, np.ndarray)):
+                if len(arg1) > dimensions:
+                    return False
+        if not isinstance(arg2, (int, float)):
+            if isinstance(arg2, (list, np.ndarray)):
+                if len(arg2) > dimensions:
+                    return False
+        if not isinstance(arg3, (int, float)):
+            if isinstance(arg3, (list, np.ndarray)):
+                if len(arg3) > dimensions:
+                    return False
+        if not isinstance(arg4, (int, float)):
+            if isinstance(arg4, (list, np.ndarray)):
+                if len(arg4) > dimensions:
+                    return False
+        return True
+    
     def _sample(self) -> int | float | np.ndarray:
         samples = self._generator.normal(loc=self._loc, scale=self._scale, size=self._size)
         mask = (samples < self._low) | (samples > self._high)

humalab/dists/uniform.py

@@ -23,6 +23,28 @@ class Uniform(Distribution):
         self._high = np.array(high)
         self._size = size
 
+    @staticmethod
+    def validate(dimensions: int, *args) -> bool:
+        arg1 = args[0]
+        arg2 = args[1]
+        if dimensions == 0:
+            if not isinstance(arg1, (int, float)):
+                return False
+            if not isinstance(arg2, (int, float)):
+                return False
+            return True
+        if dimensions == -1:
+            return True
+        if not isinstance(arg1, (int, float)):
+            if isinstance(arg1, (list, np.ndarray)):
+                if len(arg1) > dimensions:
+                    return False
+        if not isinstance(arg2, (int, float)):
+            if isinstance(arg2, (list, np.ndarray)):
+                if len(arg2) > dimensions:
+                    return False
+        return True
+
     def _sample(self) -> int | float | np.ndarray:
         return self._generator.uniform(self._low, self._high, size=self._size)
 

humalab/episode.py

@@ -0,0 +1,26 @@
+
+from humalab.scenario import Scenario
+from omegaconf import DictConfig, OmegaConf
+
+
+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
+
+    @property
+    def scenario(self) -> DictConfig:
+        return self.scenario_conf
+
+    def finish(self):
+        print(f"Finishing episode {self.episode_id} for scenario {self.scenario.name}")
+
+    @property
+    def yaml(self) -> str:
+        """The current scenario configuration as a YAML string.
+
+        Returns:
+            str: The current scenario as a YAML string.
+        """
+        return OmegaConf.to_yaml(self.scenario_conf)

humalab/evaluators/__init__.py

@@ -0,0 +1,16 @@
+import random
+
+def evaluate(video_path: str | list, task: str | list) -> dict | list[dict]:
+    """
+    Evaluate the video and return metrics.
+    """
+    # Placeholder implementation
+    if isinstance(video_path, list):
+        return [{"video_path": vp, "task": t, 
+                 "score": random.uniform(0, 1),
+                 "confidence": random.uniform(0, 1)} for vp, t in zip(video_path, task)]
+    else:
+        return {"video_path": video_path, "task": task, "score": random.uniform(0, 1),
+                "confidence": random.uniform(0, 1)}
+    
+__all__ = ["evaluate"]

humalab/humalab.py

@@ -1,11 +1,14 @@
 from contextlib import contextmanager
+
+from omegaconf import OmegaConf
+
 from humalab.run import Run
 from humalab.humalab_config import HumalabConfig
 from humalab.humalab_api_client import HumaLabApiClient
 from humalab.constants import EpisodeStatus
+import requests
 
 import uuid
-import os
 
 from collections.abc import Generator
 
@@ -14,16 +17,24 @@ from humalab.scenario import Scenario
 _cur_run: Run | None = None
 
 def _pull_scenario(client: HumaLabApiClient,
+                   project_name: str,
                    scenario: str | list | dict | None = None,
                    scenario_id: str | None = None,) -> str | list | dict | None:
     if scenario_id is not None:
-        scenario_response = client.get_scenario(uuid=scenario_id)
+        scenario_arr = scenario_id.split(":")
+        if len(scenario_arr) < 1:
+            raise ValueError("Invalid scenario_id format. Expected 'scenario_id' or 'scenario_name:version'.")
+        scenario_real_id = scenario_arr[0]
+        scenario_version = int(scenario_arr[1]) if len(scenario_arr) > 1 else None
+
+        scenario_response = client.get_scenario(
+            project_name=project_name,
+            uuid=scenario_real_id, version=scenario_version)
         return scenario_response["yaml_content"]
     return scenario
 
 @contextmanager
-def init(entity: str | None = None,
-         project: str | None = None,
+def init(project: str | None = None,
          name: str | None = None,
          description: str | None = None,
          id: str | None = None,
@@ -34,13 +45,31 @@ def init(entity: str | None = None,
          api_key: str | None = None,
          seed: int | None=None,
          timeout: float | None = None,
-         num_env: int | None = None
+         # num_env: int | None = None,
+         auto_create_scenario: bool = False,
          ) -> Generator[Run, None, None]:
+    """
+    Initialize a new HumaLab run.
+    
+    Args:
+        project: The project name under which to create the run.
+        name: The name of the run.
+        description: A description of the run.
+        id: The unique identifier for the run. If None, a new UUID will be generated.
+        tags: A list of tags to associate with the run.
+        scenario: The scenario configuration as a string, list, or dict.
+        scenario_id: The unique identifier of a pre-defined scenario to use.
+        base_url: The base URL of the HumaLab server.
+        api_key: The API key for authentication.
+        seed: An optional seed for scenario randomization.
+        timeout: The timeout for API requests.
+        # num_env: The number of parallel environments to run. (Not supported yet.)
+        auto_create_scenario: Whether to automatically create the scenario if it does not exist.
+    """
     global _cur_run
     run = None
     try:
         humalab_config = HumalabConfig()
-        entity = entity or humalab_config.entity
         project = project or "default"
         name = name or ""
         description = description or ""
@@ -54,24 +83,62 @@ def init(entity: str | None = None,
                                       api_key=api_key,
                                       timeout=timeout)
         final_scenario = _pull_scenario(client=api_client, 
+                                        project_name=project,
                                         scenario=scenario, 
                                         scenario_id=scenario_id)
+        
+        project_resp = api_client.create_project(name=project)
+
         scenario_inst = Scenario()
         scenario_inst.init(run_id=id, 
                            scenario=final_scenario, 
                            seed=seed, 
                            episode_id=str(uuid.uuid4()),
-                           num_env=num_env)
+                           #num_env=num_env
+                           )
+        if scenario_id is None and scenario is not None and auto_create_scenario:
+            scenario_response = api_client.create_scenario(
+                project_name=project_resp['name'],
+                name=f"{name} scenario",
+                description="Auto-created scenario",
+                yaml_content=OmegaConf.to_yaml(scenario_inst.template),
+            )
+            scenario_id = scenario_response['uuid']
+        try:
+            run_response = api_client.get_run(run_id=id)
+            api_client.update_run(
+                run_id=run_response['run_id'],
+            )
+
+        except requests.HTTPError as e:
+            if e.response.status_code == 404:
+                # If not found then create a new run,
+                # so ignore not found error.
+                run_response = None
+            else:
+                # Otherwise re-raise the exception.
+                raise
+
+        if run_response is None:
+            run_response = api_client.create_run(name=name,
+                                                 project_name=project_resp['name'],
+                                                 description=description,
+                                                 tags=tags)
+            id = run_response['run_id']
+            api_client.update_run(
+                run_id=id,
+                description=description,
+            )
 
         run = Run(
-            entity=entity,
-            project=project,
-            name=name,
-            description=description,
-            id=id,
-            tags=tags,
+            project=project_resp['name'],
+            name=run_response["name"],
+            description=run_response.get("description"),
+            id=run_response['run_id'],
+            tags=run_response.get("tags"),
             scenario=scenario_inst,
         )
+
         _cur_run = run
         yield run
     finally:
@@ -90,60 +157,8 @@ def login(api_key: str | None = None,
           host: str | None = None,
           force: bool | None = None,
           timeout: float | None = None) -> bool:
-    # TODO: Validate api_key against host given.
-    # and retrieve entity information.
     humalab_config = HumalabConfig()
     humalab_config.api_key = api_key or humalab_config.api_key
     humalab_config.base_url = host or humalab_config.base_url
     humalab_config.timeout = timeout or humalab_config.timeout
     return True
-
-
-if __name__ == "__main__":
-    login(api_key="GSdIImnRJs1TQRpkN74PyIVHhX8_PISLOI9NVF6uO94",
-          host="http://localhost:8000")
-    
-    with init(entity="default",
-              project="test",
-              name="my first run",
-              description="testing the humalab sdk",
-              tags=["tag1", "tag2"],
-              scenario_id="cb9668c6-99fe-490c-a97c-e8c1f06b54a6",
-              num_env=None) as run:
-        print(f"Run ID: {run.id}")
-        print(f"Run Name: {run.name}")
-        print(f"Run Description: {run.description}")
-        print(f"Run Tags: {run.tags}")
-        print(f"Run Scenario YAML:\n{run.scenario.yaml}")
-
-        scenario = run.scenario
-        # Simulate some operations
-        print("CUP position: ", scenario.scenario.cup.position)
-        print("CUP orientation: ", scenario.scenario.cup.orientation)
-        print("Asset: ", scenario.scenario.cup.asset)
-        print("Friction: ", scenario.scenario.cup.friction)
-        print("Num Objects: ", scenario.scenario.num_objects)
-        scenario.reset()
-        print("======================SCENARIO RESET==========================")
-        print("CUP position: ", scenario.scenario.cup.position)
-        print("CUP orientation: ", scenario.scenario.cup.orientation)
-        print("Asset: ", scenario.scenario.cup.asset)
-        print("Friction: ", scenario.scenario.cup.friction)
-        print("Num Objects: ", scenario.scenario.num_objects)
-
-        humalab_config = HumalabConfig()
-        base_url = humalab_config.base_url
-        api_key = humalab_config.api_key
-        timeout = humalab_config.timeout
-
-        api_client = HumaLabApiClient(base_url=base_url,
-                                      api_key=api_key,
-                                      timeout=timeout)
-        resource = api_client.get_resource(name="lerobot", version=1)
-        print("Resource metadata: ", resource)
-        file_content = api_client.download_resource(name="lerobot")
-        filename = os.path.basename(resource['resource_url'])
-        filename = os.path.join(humalab_config.workspace_path, filename)
-        with open(filename, "wb") as f:
-            f.write(file_content)
-        print(f"Resource file downloaded: {filename}")