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

humalab/assets/__init__.py

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

humalab/assets/files/urdf_file.py

@@ -25,7 +25,7 @@ class URDFFile(ResourceFile):
         
     def _extract(self):
         working_path = os.path.dirname(self._filename)
-        if not os.path.exists(working_path):
+        if os.path.exists(self._filename):
             _, ext = os.path.splitext(self._filename)
             ext = ext.lstrip('.')  # Remove leading dot
             if ext.lower() != "urdf":

humalab/assets/resource_manager.py

@@ -31,13 +31,14 @@ class ResourceManager:
         return False
 
     def download(self,
+                 project: str,
                  name: str, 
                  version: int | None=None) -> Any:
-        resource = self._api_client.get_resource(name=name, version=version)
-        file_content = self._api_client.download_resource(name="lerobot")
+        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)
         

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

@@ -25,6 +25,10 @@ class Categorical(Distribution):
             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,15 +1,14 @@
 from contextlib import contextmanager
 
-from humalab.assets.files.resource_file import ResourceFile
-from humalab.assets.files.urdf_file import URDFFile
-from humalab.assets.resource_manager import ResourceManager
+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
 
@@ -18,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,
@@ -38,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 ""
@@ -58,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:
@@ -94,124 +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)
-
-        scenario_string = """
-        scenario:
-          cup:
-            position: "${uniform: [0.7, 0.7, 0.7], 
-                                [1.5, 1.3, 0.7], [2, 3]}"
-            orientation: "${uniform: 0.3, 0.7}"
-            asset: "${categorical: ['lerobot', 'apple2', 'apple3'], [0.1, 0.3, 0.5]}"
-            friction: "${gaussian: 0.3, 0.05}"
-          hello: 13
-          jkjk: test
-          num_objects: "${discrete: 5, 10}"
-          dfdjkjk: "hello"
-        """
-        with init(entity="default",
-            project="test",
-            name="my first run",
-            description="testing the humalab sdk",
-            tags=["tag1", "tag2"],
-            scenario=scenario_string,
-            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)
-
-        resource = ResourceManager()
-        urdf_file: URDFFile = resource.download(name="lerobot", version=1)
-        print("URDF File: ", urdf_file.filename)
-        print("URDF Description: ", urdf_file.description)
-        print("URDF Created At: ", urdf_file.created_at)
-        print("URDF Root Path: ", urdf_file._root_path)
-        print("URDF Root Path: ", urdf_file._urdf_filename)
-
-        urdf_file: URDFFile = resource.download(name="lerobot")
-        print("URDF File: ", urdf_file.filename)
-        print("URDF Description: ", urdf_file.description)
-        print("URDF Created At: ", urdf_file.created_at)
-        print("URDF Root Path: ", urdf_file._root_path)
-        print("URDF Root Path: ", urdf_file._urdf_filename)
-
-        atlas_file: ResourceFile = resource.download(name="atlas_description_test")
-        print("Atlas File: ", atlas_file.filename)
-        print("Atlas Description: ", atlas_file.description)
-        print("Atlas Created At: ", atlas_file.created_at)
-
-        
-        """
-        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}")
-        """