humalab 0.0.4__tar.gz → 0.0.5__tar.gz

humalab-0.0.5/.github/pull_request_template.md

@@ -0,0 +1,8 @@
+
+## Description
+<!--- Describe your changes in detail -->
+
+## Related Issue
+<!--- closes #<issue number> -->
+
+## Screenshots (if appropriate):

{humalab-0.0.4/humalab.egg-info → humalab-0.0.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: humalab
-Version: 0.0.4
+Version: 0.0.5
 Summary: Python SDK for HumaLab - A platform for adaptive AI validation.
 Home-page: https://github.com/humalab/humalab_sdk
 Author: HumaLab Team

humalab-0.0.5/VERSION

@@ -0,0 +1 @@
+0.0.5

humalab-0.0.5/humalab/assets/__init__.py

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

{humalab-0.0.4 → humalab-0.0.5}/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-0.0.4 → humalab-0.0.5}/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-0.0.4 → humalab-0.0.5}/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-0.0.4 → humalab-0.0.5}/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-0.0.4 → humalab-0.0.5}/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-0.0.4 → humalab-0.0.5}/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-0.0.4 → humalab-0.0.5}/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-0.0.4 → humalab-0.0.5}/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-0.0.4 → humalab-0.0.5}/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-0.0.5/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-0.0.5/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-0.0.5/humalab/humalab.py

@@ -0,0 +1,164 @@
+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
+
+from collections.abc import Generator
+
+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_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(project: str | None = None,
+         name: str | None = None,
+         description: str | None = None,
+         id: str | None = None,
+         tags: list[str] | None = None,
+         scenario: str | list | dict | None = None,
+         scenario_id: str | None = None,
+         base_url: str | None = None,
+         api_key: str | None = None,
+         seed: int | None=None,
+         timeout: float | 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()
+        project = project or "default"
+        name = name or ""
+        description = description or ""
+        id = id or str(uuid.uuid4())
+
+        base_url = base_url or humalab_config.base_url
+        api_key = api_key or humalab_config.api_key
+        timeout = timeout or humalab_config.timeout
+
+        api_client = HumaLabApiClient(base_url=base_url,
+                                      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
+                           )
+        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(
+            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:
+        if run:
+            run.finish()
+        
+
+def finish(status: EpisodeStatus = EpisodeStatus.PASS,
+           quiet: bool | None = None) -> None:
+    global _cur_run
+    if _cur_run:
+        _cur_run.finish(status=status, quiet=quiet)
+
+def login(api_key: str | None = None,
+          relogin: bool | None = None,
+          host: str | None = None,
+          force: bool | None = None,
+          timeout: float | None = None) -> bool:
+    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