humalab 0.0.1__py3-none-any.whl

humalab/dists/truncated_gaussian.py

@@ -0,0 +1,64 @@
+from humalab_sdk.dists.distribution import Distribution
+from typing import Any
+import numpy as np
+
+
+class TruncatedGaussian(Distribution):
+    def __init__(self,
+                 generator: np.random.Generator,
+                 loc: float | Any,
+                 scale: float | Any,
+                 low: float | Any,
+                 high: float | Any,
+                 size: int | tuple[int, ...] | None = None) -> None:
+        """
+        Initialize the truncated Gaussian (normal) distribution.
+        
+        Args:
+            generator (np.random.Generator): The random number generator.
+            loc (float | Any): The mean of the distribution.
+            scale (float | Any): The standard deviation of the distribution.
+            low (float | Any): The lower truncation bound.
+            high (float | Any): The upper truncation bound.
+            size (int | tuple[int, ...] | None): The size of the output.
+        """
+        super().__init__(generator=generator)
+        self._loc = loc
+        self._scale = scale
+        self._low = low
+        self._high = high
+        self._size = size
+
+    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)
+        while np.any(mask):
+            samples[mask] = self._generator.normal(loc=self._loc, scale=self._scale, size=np.sum(mask))
+            mask = (samples < self._low) | (samples > self._high)
+        return samples
+
+    def __repr__(self) -> str:
+        return f"TruncatedGaussian(loc={self._loc}, scale={self._scale}, low={self._low}, high={self._high}, size={self._size})"
+    
+    @staticmethod
+    def create(generator: np.random.Generator, 
+               loc: float | Any, 
+               scale: float | Any, 
+               low: float | Any, 
+               high: float | Any, 
+               size: int | tuple[int, ...] | None = None) -> 'TruncatedGaussian':
+        """
+        Create a truncated Gaussian (normal) distribution.
+
+        Args:
+            generator (np.random.Generator): The random number generator.
+            loc (float | Any): The mean of the distribution.
+            scale (float | Any): The standard deviation of the distribution.
+            low (float | Any): The lower truncation bound.
+            high (float | Any): The upper truncation bound.
+            size (int | tuple[int, ...] | None): The size of the output.
+
+        Returns:
+            TruncatedGaussian: The created truncated Gaussian distribution.
+        """
+        return TruncatedGaussian(generator=generator, loc=loc, scale=scale, low=low, high=high, size=size)

humalab/dists/uniform.py

@@ -0,0 +1,49 @@
+from humalab_sdk.dists.distribution import Distribution
+
+from typing import Any
+import numpy as np
+
+class Uniform(Distribution):
+    def __init__(self, 
+                 generator: np.random.Generator,
+                 low: float | Any, 
+                 high: float | Any, 
+                 size: int | tuple[int, ...] | None = None, ) -> None:
+        """
+        Initialize the uniform distribution.
+        
+        Args:
+            generator (np.random.Generator): The random number generator.
+            low (float | Any): The lower bound (inclusive).
+            high (float | Any): The upper bound (exclusive).
+            size (int | tuple[int, ...] | None): The size of the output.
+        """
+        super().__init__(generator=generator)
+        self._low = np.array(low)
+        self._high = np.array(high)
+        self._size = size
+
+    def _sample(self) -> int | float | np.ndarray:
+        return self._generator.uniform(self._low, self._high, size=self._size)
+
+    def __repr__(self) -> str:
+        return f"Uniform(low={self._low}, high={self._high}, size={self._size})"
+    
+    @staticmethod
+    def create(generator: np.random.Generator, 
+               low: float | Any, 
+               high: float | Any, 
+               size: int | tuple[int, ...] | None = None) -> 'Uniform':
+        """
+        Create a uniform distribution.
+
+        Args:
+            generator (np.random.Generator): The random number generator.
+            low (float | Any): The lower bound (inclusive).
+            high (float | Any): The upper bound (exclusive).
+            size (int | tuple[int, ...] | None): The size of the output.
+
+        Returns:
+            Uniform: The created uniform distribution.
+        """
+        return Uniform(generator=generator, low=low, high=high, size=size)

humalab/humalab.py

@@ -0,0 +1,149 @@
+from contextlib import contextmanager
+from humalab_sdk.run import Run
+from humalab_sdk.humalab_config import HumalabConfig
+from humalab_sdk.humalab_api_client import HumaLabApiClient
+from humalab_sdk.constants import EpisodeStatus
+
+import uuid
+import os
+
+from collections.abc import Generator
+
+from humalab_sdk.scenario import Scenario
+
+_cur_run: Run | None = None
+
+def _pull_scenario(client: HumaLabApiClient,
+                   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)
+        return scenario_response["yaml_content"]
+    return scenario
+
+@contextmanager
+def init(entity: str | None = None,
+         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
+         ) -> Generator[Run, None, None]:
+    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 ""
+        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, 
+                                        scenario=scenario, 
+                                        scenario_id=scenario_id)
+        scenario_inst = Scenario()
+        scenario_inst.init(run_id=id, 
+                           scenario=final_scenario, 
+                           seed=seed, 
+                           episode_id=str(uuid.uuid4()),
+                           num_env=num_env)
+
+        run = Run(
+            entity=entity,
+            project=project,
+            name=name,
+            description=description,
+            id=id,
+            tags=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:
+    # 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}")

humalab/humalab_api_client.py

@@ -0,0 +1,273 @@
+"""HTTP client for accessing HumaLab service APIs with API key authentication."""
+
+import os
+import requests
+from typing import Dict, Any, Optional, List
+from urllib.parse import urljoin
+
+
+class HumaLabApiClient:
+    """HTTP client for making authenticated requests to HumaLab service APIs."""
+    
+    def __init__(
+        self,
+        base_url: str | None = None,
+        api_key: str | None = None,
+        timeout: float | None = None
+    ):
+        """
+        Initialize the HumaLab API client.
+        
+        Args:
+            base_url: Base URL for the HumaLab service (defaults to localhost:8000)
+            api_key: API key for authentication (defaults to HUMALAB_API_KEY env var)
+            timeout: Request timeout in seconds
+        """
+        self.base_url = base_url or os.getenv("HUMALAB_SERVICE_URL", "http://localhost:8000")
+        self.api_key = api_key or os.getenv("HUMALAB_API_KEY")
+        self.timeout = timeout or 30.0  # Default timeout of 30 seconds
+        
+        # Ensure base_url ends without trailing slash
+        self.base_url = self.base_url.rstrip('/')
+        
+        if not self.api_key:
+            raise ValueError(
+                "API key is required. Set HUMALAB_API_KEY environment variable "
+                "or pass api_key parameter to HumaLabApiClient constructor."
+            )
+    
+    def _get_headers(self) -> Dict[str, str]:
+        """Get common headers for API requests."""
+        return {
+            "Authorization": f"Bearer {self.api_key}",
+            "Content-Type": "application/json",
+            "User-Agent": "HumaLab-SDK/1.0"
+        }
+    
+    def _make_request(
+        self,
+        method: str,
+        endpoint: str,
+        data: Optional[Dict[str, Any]] = None,
+        params: Optional[Dict[str, Any]] = None,
+        files: Optional[Dict[str, Any]] = None,
+        **kwargs
+    ) -> requests.Response:
+        """
+        Make an HTTP request to the HumaLab service.
+        
+        Args:
+            method: HTTP method (GET, POST, PUT, DELETE, etc.)
+            endpoint: API endpoint (will be joined with base_url)
+            data: JSON data for request body
+            params: Query parameters
+            files: Files for multipart upload
+            **kwargs: Additional arguments passed to requests
+            
+        Returns:
+            requests.Response object
+            
+        Raises:
+            requests.exceptions.RequestException: For HTTP errors
+        """
+        url = urljoin(self.base_url + "/", endpoint.lstrip('/'))
+        headers = self._get_headers()
+        
+        # If files are being uploaded, don't set Content-Type (let requests handle it)
+        if files:
+            headers.pop("Content-Type", None)
+        
+        response = requests.request(
+            method=method,
+            url=url,
+            json=data,
+            params=params,
+            files=files,
+            headers=headers,
+            timeout=self.timeout,
+            **kwargs
+        )
+        
+        # Raise an exception for HTTP error responses
+        response.raise_for_status()
+        
+        return response
+    
+    def get(self, endpoint: str, params: Optional[Dict[str, Any]] = None, **kwargs) -> requests.Response:
+        """Make a GET request."""
+        return self._make_request("GET", endpoint, params=params, **kwargs)
+    
+    def post(
+        self,
+        endpoint: str,
+        data: Optional[Dict[str, Any]] = None,
+        files: Optional[Dict[str, Any]] = None,
+        **kwargs
+    ) -> requests.Response:
+        """Make a POST request."""
+        return self._make_request("POST", endpoint, data=data, files=files, **kwargs)
+    
+    def put(self, endpoint: str, data: Optional[Dict[str, Any]] = None, **kwargs) -> requests.Response:
+        """Make a PUT request."""
+        return self._make_request("PUT", endpoint, data=data, **kwargs)
+    
+    def delete(self, endpoint: str, **kwargs) -> requests.Response:
+        """Make a DELETE request."""
+        return self._make_request("DELETE", endpoint, **kwargs)
+    
+    # Convenience methods for common API operations
+    
+    def get_resources(
+        self, 
+        resource_types: Optional[str] = None,
+        limit: int = 20,
+        offset: int = 0,
+        latest_only: bool = False
+    ) -> Dict[str, Any]:
+        """
+        Get list of all resources.
+        
+        Args:
+            resource_types: Comma-separated resource types to filter by
+            limit: Maximum number of resources to return
+            offset: Number of resources to skip
+            latest_only: If true, only return latest version of each resource
+            
+        Returns:
+            Resource list with pagination info
+        """
+        params = {
+            "limit": limit,
+            "offset": offset,
+            "latest_only": latest_only
+        }
+        if resource_types:
+            params["resource_types"] = resource_types
+            
+        response = self.get("/resources", params=params)
+        return response.json()
+    
+    def get_resource(self, name: str, version: Optional[int] = None) -> Dict[str, Any]:
+        """
+        Get a specific resource.
+        
+        Args:
+            name: Resource name
+            version: Specific version (defaults to latest)
+            
+        Returns:
+            Resource data
+        """
+        if version is not None:
+            endpoint = f"/resources/{name}/{version}"
+        else:
+            endpoint = f"/resources/{name}"
+        
+        response = self.get(endpoint)
+        return response.json()
+    
+    def download_resource(
+        self, 
+        name: str, 
+        version: Optional[int] = None
+    ) -> bytes:
+        """
+        Download a resource file.
+        
+        Args:
+            name: Resource name
+            version: Specific version (defaults to latest)
+            
+        Returns:
+            Resource file content as bytes
+        """
+        if version is not None:
+            endpoint = f"/resources/{name}/download?version={version}"
+        else:
+            endpoint = f"/resources/{name}/download"
+
+        response = self.get(endpoint)
+        return response.content
+    
+    def upload_resource(
+        self, 
+        name: str, 
+        file_path: str, 
+        resource_type: str,
+        description: Optional[str] = None,
+        filename: Optional[str] = None,
+        allow_duplicate_name: bool = False
+    ) -> Dict[str, Any]:
+        """
+        Upload a resource file.
+        
+        Args:
+            name: Resource name
+            file_path: Path to file to upload
+            resource_type: Type of resource (urdf, mjcf, etc.)
+            description: Optional description
+            filename: Optional custom filename
+            allow_duplicate_name: Allow creating new version with existing name
+            
+        Returns:
+            Created resource data
+        """
+        with open(file_path, 'rb') as f:
+            files = {'file': f}
+            data = {}
+            if description:
+                data['description'] = description
+            if filename:
+                data['filename'] = filename
+                
+            params = {
+                'resource_type': resource_type,
+                'allow_duplicate_name': allow_duplicate_name
+            }
+            
+            response = self.post(f"/resources/{name}/upload", files=files, params=params)
+            return response.json()
+    
+    def get_resource_types(self) -> List[str]:
+        """Get list of all available resource types."""
+        response = self.get("/resources/types")
+        return response.json()
+    
+    def delete_resource(self, name: str, version: Optional[int] = None) -> None:
+        """
+        Delete a resource.
+        
+        Args:
+            name: Resource name
+            version: Specific version to delete (if None, deletes all versions)
+        """
+        if version is not None:
+            endpoint = f"/resources/{name}/{version}"
+        else:
+            endpoint = f"/resources/{name}"
+        
+        self.delete(endpoint)
+    
+    def get_scenarios(self) -> List[Dict[str, Any]]:
+        """Get list of all scenarios."""
+        response = self.get("/scenarios")
+        return response.json()
+    
+    def get_scenario(self, uuid: str, version: Optional[int] = None) -> Dict[str, Any]:
+        """
+        Get a specific scenario.
+        
+        Args:
+            uuid: Scenario UUID
+            version: Specific version (defaults to latest)
+            
+        Returns:
+            Scenario data
+        """
+        if version is not None:
+            endpoint = f"/scenarios/{uuid}/{version}"
+        else:
+            endpoint = f"/scenarios/{uuid}"
+        
+        response = self.get(endpoint)
+        return response.json()

humalab/humalab_config.py

@@ -0,0 +1,86 @@
+from pathlib import Path
+import yaml
+import os
+
+class HumalabConfig:
+    def __init__(self):
+        self._config = {
+            "workspace_path": "",
+            "entity": "",
+            "base_url": "",
+            "api_key": "",
+            "timeout": 30.0,
+        }
+        self._workspace_path = ""
+        self._entity = ""
+        self._base_url = ""
+        self._api_key = ""
+        self._timeout = 30.0
+        self._load_config()
+
+    def _load_config(self):
+        home_path = Path.home()
+        config_path = home_path / ".humalab" / "config.yaml"
+        if not config_path.exists():
+            config_path.parent.mkdir(parents=True, exist_ok=True)
+            config_path.touch()
+        with open(config_path, "r") as f:
+            self._config = yaml.safe_load(f)
+        self._workspace_path = os.path.expanduser(self._config["workspace_path"]) if self._config and "workspace_path" in self._config else home_path
+        self._entity = self._config["entity"] if self._config and "entity" in self._config else ""
+        self._base_url = self._config["base_url"] if self._config and "base_url" in self._config else ""
+        self._api_key = self._config["api_key"] if self._config and "api_key" in self._config else ""
+        self._timeout = self._config["timeout"] if self._config and "timeout" in self._config else 30.0
+
+    def _save(self) -> None:
+        yaml.dump(self._config, open(Path.home() / ".humalab" / "config.yaml", "w"))
+
+    @property
+    def workspace_path(self) -> str:
+        return str(self._workspace_path)
+    
+    @workspace_path.setter
+    def workspace_path(self, path: str) -> None:
+        self._workspace_path = path
+        self._config["workspace_path"] = path
+        self._save()
+
+    @property
+    def entity(self) -> str:
+        return str(self._entity)
+
+    @entity.setter
+    def entity(self, entity: str) -> None:
+        self._entity = entity
+        self._config["entity"] = entity
+        self._save()
+
+    @property
+    def base_url(self) -> str:
+        return str(self._base_url)
+
+    @base_url.setter
+    def base_url(self, base_url: str) -> None:
+        self._base_url = base_url
+        self._config["base_url"] = base_url
+        self._save()
+
+    @property
+    def api_key(self) -> str:
+        return str(self._api_key)
+
+    @api_key.setter
+    def api_key(self, api_key: str) -> None:
+        self._api_key = api_key
+        self._config["api_key"] = api_key
+        self._save()
+
+    @property
+    def timeout(self) -> float:
+        return self._timeout
+
+    @timeout.setter
+    def timeout(self, timeout: float) -> None:
+        self._timeout = timeout
+        self._config["timeout"] = timeout
+        self._save()