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

humalab/metrics/scenario_stats.py

@@ -15,21 +15,55 @@ SCENARIO_STATS_NEED_FLATTEN = {
 }
 
 
+DISTRIBUTION_GRAPH_TYPE = {
+    # 0D distributions
+    "uniform": GraphType.HISTOGRAM,
+    "bernoulli": GraphType.BAR,
+    "categorical": GraphType.BAR,
+    "discrete": GraphType.BAR,
+    "log_uniform": GraphType.HISTOGRAM,
+    "gaussian": GraphType.GAUSSIAN,
+    "truncated_gaussian": GraphType.GAUSSIAN,
+
+    # 1D distributions
+    "uniform_1d": GraphType.HISTOGRAM,
+    "bernoulli_1d": GraphType.BAR,
+    "categorical_1d": GraphType.BAR,
+    "discrete_1d": GraphType.BAR,
+    "log_uniform_1d": GraphType.HISTOGRAM,
+    "gaussian_1d": GraphType.GAUSSIAN,
+    "truncated_gaussian_1d": GraphType.GAUSSIAN,
+
+    # 2D distributions
+    "uniform_2d": GraphType.SCATTER,
+    "gaussian_2d": GraphType.HEATMAP,
+    "truncated_gaussian_2d": GraphType.HEATMAP,
+
+    # 3D distributions
+    "uniform_3d": GraphType.THREE_D_MAP,
+    "gaussian_3d": GraphType.THREE_D_MAP,
+    "truncated_gaussian_3d": GraphType.THREE_D_MAP,
+}
+
 class ScenarioStats(Metrics):
-    """Metric to track scenario statistics such as total reward, length, and success.
+    """Metric to track scenario statistics across episodes.
+
+    This class logs sampled values from scenario distributions and tracks episode
+    statuses. It supports various distribution types and automatically handles
+    flattening for 1D distributions.
 
     Attributes:
+        name (str): The name of the scenario statistic.
+        distribution_type (str): The type of distribution (e.g., 'uniform', 'gaussian').
+        artifact_type (ArtifactType): The artifact type, always SCENARIO_STATS.
     """
 
     def __init__(self, 
                  name: str,
                  distribution_type: str,
-                 metric_dim_type: MetricDimType,
-                 graph_type: GraphType,
                  ) -> None:
         super().__init__(
-            metric_dim_type=metric_dim_type,
-            graph_type=graph_type
+            graph_type=DISTRIBUTION_GRAPH_TYPE[distribution_type]
         )
         self._name = name
         self._distribution_type = distribution_type
@@ -39,17 +73,43 @@ class ScenarioStats(Metrics):
 
     @property
     def name(self) -> str:
+        """The name of the scenario statistic.
+
+        Returns:
+            str: The statistic name.
+        """
         return self._name
-    
+
     @property
     def distribution_type(self) -> str:
+        """The type of distribution used for this statistic.
+
+        Returns:
+            str: The distribution type (e.g., 'uniform', 'gaussian').
+        """
         return self._distribution_type
 
     @property
     def artifact_type(self) -> ArtifactType:
+        """The artifact type, always SCENARIO_STATS.
+
+        Returns:
+            ArtifactType: The artifact type.
+        """
         return self._artifact_type
     
     def log(self, data: Any, x: Any = None, replace: bool = False) -> None:
+        """Log a sampled value from the scenario distribution.
+
+        Args:
+            data (Any): The sampled value to log.
+            x (Any | None): The key/identifier for this sample (typically episode_id).
+                If None, auto-incrementing step is used.
+            replace (bool): Whether to replace an existing value. Defaults to False.
+
+        Raises:
+            ValueError: If data for the given x already exists and replace is False.
+        """
         if x in self._values:
             if replace:
                 if self._distribution_type in SCENARIO_STATS_NEED_FLATTEN:
@@ -62,27 +122,35 @@ class ScenarioStats(Metrics):
                 data = data[0]
             self._values[x] = data
     
-    def log_status(self, 
+    def log_status(self,
                    episode_id: str,
-                   episode_status: EpisodeStatus, 
+                   episode_status: EpisodeStatus,
                    replace: bool = False) -> None:
-        """Log a new data point for the metric. The behavior depends on the granularity.    
+        """Log the status of an episode.
 
         Args:
-            data (Any): The data point to log.
-            x (Any | None): The x-axis value associated with the data point.
-                if None, the current step is used.
-            replace (bool): Whether to replace the last logged value.
+            episode_id (str): The unique identifier of the episode.
+            episode_status (EpisodeStatus): The status of the episode.
+            replace (bool): Whether to replace an existing status for this episode.
+                Defaults to False.
+
+        Raises:
+            ValueError: If status for the episode_id already exists and replace is False.
         """
         if episode_id in self._results:
             if replace:
-                self._results[episode_id] = episode_status
+                self._results[episode_id] = episode_status.value
             else:   
                 raise ValueError(f"Data for episode_id {episode_id} already exists. Use replace=True to overwrite.")
         else:
-            self._results[episode_id] = episode_status
+            self._results[episode_id] = episode_status.value
 
     def _finalize(self) -> dict:
+        """Finalize and return all collected scenario statistics.
+
+        Returns:
+            dict: Dictionary containing values, results, and distribution type.
+        """
         ret_val = {
             "values": self._values,
             "results": self._results,

humalab/metrics/summary.py

@@ -4,31 +4,46 @@ from humalab.constants import MetricDimType, GraphType
 
 
 class Summary(Metrics):
-    def __init__(self, 
+    """A metric that aggregates logged values into a single summary statistic.
+
+    Summary metrics collect values throughout a run or episode and compute a single
+    aggregated result. Supported aggregation methods include min, max, mean, first,
+    last, and none (no aggregation).
+
+    Attributes:
+        summary (str): The aggregation method used.
+    """
+    def __init__(self,
                  summary: str,
                  ) -> None:
         """
         A summary metric that captures a single value per episode or run.
 
         Args:
-            name (str): The name of the metric.
-            summary (str | None): Specify aggregate metrics added to summary.
+            summary (str): Specify the aggregation method for the summary.
                 Supported aggregations include "min", "max", "mean", "last",
-                "first", and "none". "none" prevents a summary
-                from being generated.
-            granularity (MetricGranularity): The granularity of the metric.
+                "first", and "none". "none" prevents a summary from being generated.
         """
         if summary not in {"min", "max", "mean", "last", "first", "none"}:
             raise ValueError(f"Unsupported summary type: {summary}. Supported types are 'min', 'max', 'mean', 'last', 'first', and 'none'.")
-        super().__init__(metric_dim_type= MetricDimType.ZERO_D, 
-                         graph_type=GraphType.NUMERIC)
+        super().__init__(graph_type=GraphType.NUMERIC)
         self._summary = summary
     
     @property
     def summary(self) -> str:
+        """The aggregation method for this summary metric.
+
+        Returns:
+            str: The summary type (e.g., 'min', 'max', 'mean').
+        """
         return self._summary
 
     def _finalize(self) -> dict:
+        """Compute the final aggregated value.
+
+        Returns:
+            dict: Dictionary containing the aggregated value and summary type.
+        """
         if not self._values:
             return {
                 "value": None,

humalab/run.py

@@ -16,6 +16,25 @@ from humalab.utils import is_standard_type
 from humalab.scenarios.scenario import Scenario
 
 class Run:
+    """Represents a run containing multiple episodes for a scenario.
+
+    A Run is a context manager that tracks experiments or evaluations using a specific
+    scenario. It manages episode creation, metric logging, and code artifacts. The run
+    can contain multiple episodes, each representing a single execution instance.
+
+    Use as a context manager to automatically handle run lifecycle:
+        with Run(scenario=my_scenario) as run:
+            # Your code here
+            pass
+
+    Attributes:
+        project (str): The project name under which the run is created.
+        id (str): The unique identifier for the run.
+        name (str): The name of the run.
+        description (str): A description of the run.
+        tags (list[str]): A list of tags associated with the run.
+        scenario (Scenario): The scenario associated with the run.
+    """
     def __init__(self,
                  scenario: Scenario,
                  project: str = DEFAULT_PROJECT,
@@ -110,9 +129,11 @@ class Run:
         return self._scenario
     
     def __enter__(self):
+        """Enter the run context."""
         return self
 
     def __exit__(self, exception_type, exception_value, exception_traceback):
+        """Exit the run context and finalize the run."""
         if self._is_finished:
             return
         if exception_type is not None:
@@ -122,10 +143,14 @@ class Run:
             self.finish()
 
     def create_episode(self, episode_id: str | None = None) -> Episode:
-        """Reset the run for a new episode.
+        """Create a new episode for this run.
 
         Args:
-            status (EpisodeStatus): The status of the current episode before reset.
+            episode_id (str | None): Optional unique identifier for the episode.
+                If None, a UUID is generated automatically.
+
+        Returns:
+            Episode: The newly created episode instance.
         """
         episode = None
         episode_id = episode_id or str(uuid.uuid4())
@@ -142,15 +167,22 @@ class Run:
         for metric_name, value in episode_vals.items():
             if metric_name not in self._logs:
                 stat = ScenarioStats(name=metric_name,
-                                    distribution_type=value["distribution"],
-                                    metric_dim_type=value["metric_dim_type"],
-                                    graph_type=value["graph_type"])
+                                    distribution_type=value["distribution"])
                 self._logs[metric_name] = stat
             self._logs[metric_name].log(data=value["value"],
                                         x=episode.episode_id)
         self._episodes[episode.episode_id] = episode
     
     def add_metric(self, name: str, metric: Metrics) -> None:
+        """Add a metric to track for this run.
+
+        Args:
+            name (str): The name of the metric.
+            metric (Metrics): The metric instance to add.
+
+        Raises:
+            ValueError: If the name is already used.
+        """
         if name in self._logs:
             raise ValueError(f"{name} is a reserved name and is not allowed.")
         self._logs[name] = metric
@@ -172,6 +204,16 @@ class Run:
 
         
     def log(self, data: dict, x: dict | None = None, replace: bool = False) -> None:
+        """Log data points or values for the run.
+
+        Args:
+            data (dict): Dictionary of key-value pairs to log.
+            x (dict | None): Optional dictionary of x-axis values for each key.
+            replace (bool): Whether to replace existing values. Defaults to False.
+
+        Raises:
+            ValueError: If a key is reserved or logging fails.
+        """
         for key, value in data.items():
             if key in RESERVED_NAMES:
                 raise ValueError(f"{key} is a reserved name and is not allowed.")
@@ -219,6 +261,12 @@ class Run:
             run_id=self._id,
             code_content=self.scenario.yaml
         )
+
+        self._api_client.upload_python(
+            artifact_key="seed",
+            run_id=self._id,
+            pickled_bytes=pickle.dumps(self.scenario.seed)
+        )
         # TODO: submit final metrics
         for key, value in self._logs.items():
             if isinstance(value, ScenarioStats):
@@ -235,7 +283,6 @@ class Run:
                     run_id=self._id,
                     pickled_bytes=pickled,
                     graph_type=value.graph_type.value,
-                    metric_dim_type=value.metric_dim_type.value
                 )
             elif isinstance(value, Summary):
                 metric_val = value.finalize()
@@ -253,7 +300,6 @@ class Run:
                     run_id=self._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(

humalab/scenarios/__init__.py

@@ -1,3 +1,10 @@
+"""Scenario management and configuration.
+
+This module provides the Scenario class and related utilities for managing scenario
+configurations with probabilistic distributions, supporting randomized scenario generation
+for robotics experiments.
+"""
+
 from .scenario import Scenario
 from .scenario_operator import list_scenarios, get_scenario
 

humalab/scenarios/scenario.py

@@ -163,64 +163,51 @@ SCENARIO_STATS_DIM_TYPE_MAP = {
     "truncated_gaussian_3d": MetricDimType.THREE_D,
 }
 
-DISTRIBUTION_GRAPH_TYPE = {
-    # 0D distributions
-    "uniform": GraphType.HISTOGRAM,
-    "bernoulli": GraphType.BAR,
-    "categorical": GraphType.BAR,
-    "discrete": GraphType.BAR,
-    "log_uniform": GraphType.HISTOGRAM,
-    "gaussian": GraphType.GAUSSIAN,
-    "truncated_gaussian": GraphType.GAUSSIAN,
-
-    # 1D distributions
-    "uniform_1d": GraphType.HISTOGRAM,
-    "bernoulli_1d": GraphType.BAR,
-    "categorical_1d": GraphType.BAR,
-    "discrete_1d": GraphType.BAR,
-    "log_uniform_1d": GraphType.HISTOGRAM,
-    "gaussian_1d": GraphType.GAUSSIAN,
-    "truncated_gaussian_1d": GraphType.GAUSSIAN,
+class Scenario:
+    """Manages scenario configurations with probabilistic distributions.
 
-    # 2D distributions
-    "uniform_2d": GraphType.SCATTER,
-    "gaussian_2d": GraphType.HEATMAP,
-    "truncated_gaussian_2d": GraphType.HEATMAP,
+    A Scenario encapsulates a configuration template that can contain distribution
+    resolvers (e.g., ${uniform:0,1}). When resolved, these distributions are sampled
+    to produce concrete scenario instances. Each resolution creates a new episode
+    with different sampled values.
 
-    # 3D distributions
-    "uniform_3d": GraphType.THREE_D_MAP,
-    "gaussian_3d": GraphType.THREE_D_MAP,
-    "truncated_gaussian_3d": GraphType.THREE_D_MAP,
-}
+    Supported distributions include uniform, gaussian, bernoulli, categorical,
+    discrete, log_uniform, and truncated_gaussian, with support for 0D-3D variants.
 
-class Scenario:
+    Attributes:
+        template (DictConfig | ListConfig): The template scenario configuration.
+        yaml (str): The current scenario configuration as a YAML string.
+    """
     dist_cache = {}
     def __init__(self) -> None:
         self._generator = np.random.default_rng()
         self._scenario_template = OmegaConf.create()
         self._cur_scenario = OmegaConf.create()
         self._scenario_id = None
+        self._seed = None
 
         self._episode_vals = {}
         self._lock = RLock()
 
     def init(self,
-             scenario: str | list | dict | None = None, 
-             seed: int | None=None, 
+             scenario: str | list | dict | None = None,
+             seed: int | None=None,
              scenario_id: str | None=None,
              # num_env: int | None = None
              ) -> None:
         """
         Initialize the scenario with the given parameters.
-        
+
         Args:
-            episode_id: The ID of the current episode.
-            scenario: The scenario configuration (YAML string, list, or dict).
-            seed: Optional seed for random number generation.
-            scenario_id: Optional scenario ID. If None, a new UUID is generated.
-            # num_env: Optional number of parallel environments.
+            scenario (str | list | dict | None): The scenario configuration. Can be a YAML
+                string, list, or dict. If None, an empty configuration is used.
+            seed (int | None): Optional seed for random number generation. If None, uses
+                a non-deterministic seed.
+            scenario_id (str | None): Optional scenario ID in the format 'id' or 'id:version'.
+                If None, a new UUID is generated.
         """
         self._num_env = None # num_env
+        self._seed = seed
 
         # Parse scenario id
         scenario_version = 1
@@ -328,8 +315,6 @@ class Scenario:
             self._episode_vals[key_path] = {
                     "value": ret_val,
                     "distribution": dist_name,
-                    "graph_type": DISTRIBUTION_GRAPH_TYPE[dist_name],
-                    "metric_dim_type": SCENARIO_STATS_DIM_TYPE_MAP[dist_name],
                 }
             return ret_val
 
@@ -353,6 +338,24 @@ class Scenario:
             episode_vals = copy.deepcopy(self._episode_vals)
             return cur_scenario, episode_vals
 
+    @property
+    def scenario_id(self) -> str | None:
+        """The scenario ID.
+
+        Returns:
+            str | None: The scenario ID, or None if not set.
+        """
+        return self._scenario_id
+
+    @property
+    def seed(self) -> int | None:
+        """The random seed for the scenario.
+
+        Returns:
+            int | None: The random seed, or None if not set.
+        """
+        return self._seed
+
     @property
     def template(self) -> Any:
         """The template scenario configuration.

humalab/scenarios/scenario_operator.py

@@ -1,3 +1,5 @@
+"""Operations for managing and retrieving scenarios."""
+
 from typing import Optional
 from dataclasses import dataclass
 
@@ -7,6 +9,17 @@ from humalab.constants import DEFAULT_PROJECT
 
 @dataclass
 class ScenarioMetadata:
+    """Metadata for a scenario stored in HumaLab.
+
+    Attributes:
+        id (str): Unique identifier for the scenario.
+        version (int): Version number of the scenario.
+        project (str): Project name the scenario belongs to.
+        name (str): Human-readable scenario name.
+        description (str | None): Optional scenario description.
+        created_at (str): ISO timestamp when scenario was created.
+        updated_at (str): ISO timestamp when scenario was last updated.
+    """
     id: str
     version: int
     project: str
@@ -18,7 +31,7 @@ class ScenarioMetadata:
 
 def list_scenarios(project: str = DEFAULT_PROJECT,
                    limit: int = 20,
-                   offset: int = 0,     
+                   offset: int = 0,
                    include_inactive: bool = False,
                    search: Optional[str] = None,
                    status_filter: Optional[str] = None,
@@ -26,18 +39,23 @@ def list_scenarios(project: str = DEFAULT_PROJECT,
                    base_url: str | None = None,
                    api_key: str | None = None,
                    timeout: float | None = None,
-                   ) -> list[dict]:
+                   ) -> list[ScenarioMetadata]:
     """
     List all scenarios for a given project.
-    
+
     Args:
-        project: The project name to list scenarios from.
-        base_url: The base URL of the HumaLab API.
-        api_key: The API key for authentication.
-        timeout: The timeout for API requests.
+        project (str): The project name to list scenarios from. Defaults to DEFAULT_PROJECT.
+        limit (int): Maximum number of scenarios to return. Defaults to 20.
+        offset (int): Number of scenarios to skip for pagination. Defaults to 0.
+        include_inactive (bool): Whether to include inactive scenarios. Defaults to False.
+        search (Optional[str]): Search query to filter scenarios by name or description. Defaults to None.
+        status_filter (Optional[str]): Filter scenarios by status. Defaults to None.
+        base_url (str | None): The base URL of the HumaLab API. If None, uses configured value.
+        api_key (str | None): The API key for authentication. If None, uses configured value.
+        timeout (float | None): The timeout for API requests in seconds. If None, uses configured value.
 
     Returns:
-        A list of scenario metadata dictionaries.
+        list[ScenarioMetadata]: A list of scenario metadata objects.
     """
     api_client = HumaLabApiClient(base_url=base_url,
                                   api_key=api_key,
@@ -64,10 +82,24 @@ def get_scenario(scenario_id: str,
                  version: int | None = None,
                  project: str = DEFAULT_PROJECT,
                  seed: int | None=None,
-                 
+
                  base_url: str | None = None,
                  api_key: str | None = None,
                  timeout: float | None = None,) -> Scenario:
+    """Retrieve and initialize a scenario from HumaLab.
+
+    Args:
+        scenario_id (str): The unique identifier of the scenario.
+        version (int | None): Optional specific version to retrieve.
+        project (str): The project name. Defaults to DEFAULT_PROJECT.
+        seed (int | None): Optional seed for scenario randomization.
+        base_url (str | None): Optional API host override.
+        api_key (str | None): Optional API key override.
+        timeout (float | None): Optional timeout override.
+
+    Returns:
+        Scenario: The initialized scenario instance.
+    """
     api_client = HumaLabApiClient(base_url=base_url,
                                   api_key=api_key,
                                   timeout=timeout)

{humalab-0.0.6.dist-info → humalab-0.0.7.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: humalab
-Version: 0.0.6
+Version: 0.0.7
 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.7.dist-info/RECORD

@@ -0,0 +1,39 @@
+humalab/__init__.py,sha256=AfQjlYd-KIqWdKaW77ZI86zU5tYXk-kdXaj14sY27is,1022
+humalab/constants.py,sha256=FuwO3FRREUYStXmly7dN6Phw2tIyyiCn8bbclibqh5I,1194
+humalab/episode.py,sha256=EZCsvv51rEZyl6aVIVviIRi6lR5KAjKSmn0_m5EUL28,10760
+humalab/humalab.py,sha256=_2wEGri-PEhi9WZ2XEHAVDPm8Iki8jZBG8nEmQSFuzo,8089
+humalab/humalab_api_client.py,sha256=3udeKwplpYty-Zp_5IkZXONCJUalj_3pKkqaOBAGaBo,29339
+humalab/humalab_config.py,sha256=GzC0W2-NGUrJGyJH5qst_iL4DfXJX5bD5eaT1XVvJjk,3792
+humalab/humalab_test.py,sha256=YMwOIH-sAOMnxwq8yR-Ut4vYk5Ksix9zS9yUIxi3GU8,20725
+humalab/run.py,sha256=hiJLIW5yO_c58dZdM9lncdd7x55HC5L_o7rBb-fTWt0,11753
+humalab/utils.py,sha256=KMIPoduAbQzha9wvnyX8OjE8X-3TaNpecx2o-kgHbdw,1161
+humalab/assets/__init__.py,sha256=dsBdfusLUNwXnnuGaqAwO83_JDghc4MKLARKGupfNhk,413
+humalab/assets/archive.py,sha256=PALZRnpNExDfXiURVNEj6xxWqcW4nd9UBZ7QIHa8mI8,3119
+humalab/assets/resource_operator.py,sha256=H2ERU2LuzF3nomR2L29Q6f5EuYwB_PgHlmDvZbCql5s,5961
+humalab/assets/files/__init__.py,sha256=9XF-Zp2nldx060v8A3tMTcB5o5vJCUTFKF9rrIFZE_s,111
+humalab/assets/files/resource_file.py,sha256=0h-WrQcwalEtKbS4ZJTkF3TciX7rqkTG_EVM8YshRHE,3763
+humalab/assets/files/urdf_file.py,sha256=6J6MGgMvwttyC2Ru_3nReoPW6kHjNYFgkoD24URvIBY,3960
+humalab/dists/__init__.py,sha256=IcVN1O4EOIcoOiWbiNWqeQOGBnEeVmjdaSpjR81WdTU,721
+humalab/dists/bernoulli.py,sha256=h7QX5pMo5R_LQFJGx-Z-X9mdiz54cnjATGn6U2LppnM,2825
+humalab/dists/categorical.py,sha256=tlpfmsnz4XrjxIqPlowHwBmYFRLYU_iENp_SbrOLXmk,3036
+humalab/dists/discrete.py,sha256=2tJXHPakyzj4HAlbWC3_AeUbBdfQzvtlgTxba3gZvLo,3848
+humalab/dists/distribution.py,sha256=wWm_bzfe-PHqBAOAszT2xW40CBkr7bDdSQbE_-Oztfw,1447
+humalab/dists/gaussian.py,sha256=HYQ8KHxJBY4Y_PifQh4QKjfPcrqaeBpiSfcn_84BW1Y,3493
+humalab/dists/log_uniform.py,sha256=6Bf-jkMYB0mFYiXX7mMMCAm0moYqfDvU99pOHrJiuLE,3586
+humalab/dists/truncated_gaussian.py,sha256=qAPTiWFsci48pfgEyipg0E2Yl8HQSAFfxVAki_BX7cc,5185
+humalab/dists/uniform.py,sha256=5_HOY7lU51v21Oyb3_VCGANMCatmZWeV97sTB57vu-A,3428
+humalab/metrics/__init__.py,sha256=gYTsYpOJjx6Ouxyy2iZyHBSfMw0A4C0ZbQSgnIO6D2g,423
+humalab/metrics/code.py,sha256=0cVlsC8nGta7Eb7-mr3ug5wgTy1FluyOtq252_fOEwE,1693
+humalab/metrics/metric.py,sha256=MJ8oJoFJU9e4KE1Y_dw7cvKumFm85n3gWMkVfbDHzZM,3181
+humalab/metrics/scenario_stats.py,sha256=SvbtEwOEeD-gNNqypfKZFDwsJ7bk8PNqw7LB-6h3R7k,5339
+humalab/metrics/summary.py,sha256=x_GL12stCI3UtUds8w1FoD3WYSk25fGnXBhstV1MD_I,2656
+humalab/scenarios/__init__.py,sha256=LRwueiMULXrEh37tZsKO9A4Obwoo5Zcsao_Wlk7j3vw,397
+humalab/scenarios/scenario.py,sha256=llukLnS-vRtsB9hIiLXWoTrb6ATMRPnyxF43bjaZRwk,12530
+humalab/scenarios/scenario_operator.py,sha256=PYAeUMQ3JPzNu5STfL543dYqcopO49td15QViybiTuw,4927
+humalab/scenarios/scenario_test.py,sha256=YYSzKfaeZVK0Kv09pVYgZvLP7Zrz02jgUOpQ-0btanc,24397
+humalab-0.0.7.dist-info/licenses/LICENSE,sha256=Gy0Nw_Z9pbrNSu-loW-PCDWJyrC8eWpIqqIGW-DFtp8,1064
+humalab-0.0.7.dist-info/METADATA,sha256=fYRvNcaWq5XDn3x8oxwdSHHopMsyIAtUfRaHvEKuTxU,1704
+humalab-0.0.7.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+humalab-0.0.7.dist-info/entry_points.txt,sha256=aY-hS7Kg8y5kGgYA14YmtTz5odBrgJIZ2fQMXAbVW_U,49
+humalab-0.0.7.dist-info/top_level.txt,sha256=hp7XXBDE40hi9T3Jx6mPFc6wJbAMzektD5VWXlSCW6o,8
+humalab-0.0.7.dist-info/RECORD,,

humalab-0.0.6.dist-info/RECORD

@@ -1,39 +0,0 @@
-humalab/__init__.py,sha256=d6RcDYAWf4HzzF_is-_nlTZXAg2UjLSoWRJegNOYz9U,416
-humalab/constants.py,sha256=gIdDoKnrAjfCMbnv4MnPncGYQXqELsaVYs3bQmH6k0s,852
-humalab/episode.py,sha256=WpWIxzkQSBm-YGCEnvjL2b5pEN5OQBzFZJb_b3f8mKM,6917
-humalab/humalab.py,sha256=FiC551LnCa1iQOvQ9tOUsbocs2Q2M3zy8gDgMAMFsJg,6712
-humalab/humalab_api_client.py,sha256=uy6Re-e4v-Z5lPhZnu_HeSOcxDfdxW1uaMOb5Dbu0JE,29549
-humalab/humalab_config.py,sha256=K-RC1MfAhuD_FCORySV7uyjKzW-bYf2tY6EOZslR0kg,2316
-humalab/humalab_test.py,sha256=YMwOIH-sAOMnxwq8yR-Ut4vYk5Ksix9zS9yUIxi3GU8,20725
-humalab/run.py,sha256=GSO_YrEkWqEBu7fvPjL1ru-xkEYMvXYXS2ReMm42V3k,10129
-humalab/utils.py,sha256=KMIPoduAbQzha9wvnyX8OjE8X-3TaNpecx2o-kgHbdw,1161
-humalab/assets/__init__.py,sha256=9WnZmRuS04q1GMAVfS8-SIjH5m50kmEnsKC2VAH1obA,167
-humalab/assets/archive.py,sha256=PALZRnpNExDfXiURVNEj6xxWqcW4nd9UBZ7QIHa8mI8,3119
-humalab/assets/resource_operator.py,sha256=YoKQ8_rfHDuvpn7zJsbaOIcouO5Oaehs0duFfB_rczg,4184
-humalab/assets/files/__init__.py,sha256=9XF-Zp2nldx060v8A3tMTcB5o5vJCUTFKF9rrIFZE_s,111
-humalab/assets/files/resource_file.py,sha256=HpPM4FVAya0kEggx8bFB__2S6CxyJyHyWZCQ6VcQLi4,1773
-humalab/assets/files/urdf_file.py,sha256=UehIGgF9qL5oFiMX81l3aolSca7rkzN_B6t6k3o51UE,2802
-humalab/dists/__init__.py,sha256=Q7zQbFGC_CnTgExMcnRtJdqJitqy1oBk4D6Qyvunlqc,387
-humalab/dists/bernoulli.py,sha256=4RSYBkeyTHkqOzkn-of4y_oNJPhhfkMOuW2APjNa8Eo,1975
-humalab/dists/categorical.py,sha256=plEIZIx5LRiaNreUCIk9EkhBD6eflxwMJy3XbseeUBw,2114
-humalab/dists/discrete.py,sha256=X2VufaTsI7x125ev7RL7Sc59JhWh51tlE2dXAD51XBU,2889
-humalab/dists/distribution.py,sha256=t0qTUjS_N0adiy_j2fdf-NHSlRs1pr0swpnszizs04I,1048
-humalab/dists/gaussian.py,sha256=eezw8qpcRIRpoSM7Vgnny8berqsbcfKm0v00Hxv9KI8,2592
-humalab/dists/log_uniform.py,sha256=mcJUYSoapxsIiynq_MZS_1NH1sxlC-Oupop2S3-EVHw,2626
-humalab/dists/truncated_gaussian.py,sha256=tB0BQHaiSDmB1eNb143dKHysbDEG3_pjuCzYBOy4ks8,4009
-humalab/dists/uniform.py,sha256=ouUAY8fvtu7azNCltU9g5t8jCw5OFQyYp8BlD7OWS5E,2545
-humalab/metrics/__init__.py,sha256=lI1QCl_8mws5yfxxrAHCoIj1n5WEtiTZB5mTGFqAPCo,200
-humalab/metrics/code.py,sha256=CybaYFX3KdJLFGshSY9Ss1jpkWwA5X2wD0hZNZJXUJw,713
-humalab/metrics/metric.py,sha256=3lw3386UE3-pWHsOcYXoEM_RBfFR38bqd8Ehzj7aByw,1970
-humalab/metrics/scenario_stats.py,sha256=lW-8tYrKh1nc_mclF7tg_o0UrhDoNgkVHPtabHgzdiQ,3004
-humalab/metrics/summary.py,sha256=Y6AbDJv7vF4N82JqkTmJuwyaJ9WnlgJ6aExT8SSqnGQ,2194
-humalab/scenarios/__init__.py,sha256=Q76ohPaMrU_NVwVVFQrxJIzIFjtibaOS60ljV1I54Os,148
-humalab/scenarios/scenario.py,sha256=SmknTAZ3f304DmOSAKIkaZljrZ-ucxHs062CQKtS7js,12326
-humalab/scenarios/scenario_operator.py,sha256=GxOB20UP-A6J5Y_ftHbWHpIrTMV6dx52r09Tr-WXfWU,3152
-humalab/scenarios/scenario_test.py,sha256=YYSzKfaeZVK0Kv09pVYgZvLP7Zrz02jgUOpQ-0btanc,24397
-humalab-0.0.6.dist-info/licenses/LICENSE,sha256=Gy0Nw_Z9pbrNSu-loW-PCDWJyrC8eWpIqqIGW-DFtp8,1064
-humalab-0.0.6.dist-info/METADATA,sha256=KqqLNrCKPoBkDNYRwUKxjZoS2jogk7pHLaKYBHcBjmE,1704
-humalab-0.0.6.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-humalab-0.0.6.dist-info/entry_points.txt,sha256=aY-hS7Kg8y5kGgYA14YmtTz5odBrgJIZ2fQMXAbVW_U,49
-humalab-0.0.6.dist-info/top_level.txt,sha256=hp7XXBDE40hi9T3Jx6mPFc6wJbAMzektD5VWXlSCW6o,8
-humalab-0.0.6.dist-info/RECORD,,