composabl-cli-dev 0.19.1.dev1__cp310-cp310-macosx_11_0_arm64.whl

composabl_cli/template/sim_docker/module/pyproject.toml

@@ -0,0 +1,20 @@
+[project]
+name = "{{NAME}}"
+version = "0.1.0"
+description = "{{DESCRIPTION}}"
+authors = [{ name = "John Doe", email = "john.doe@composabl.com" }]
+dependencies = [
+    "composabl-core"
+]
+
+[composabl]
+type = "sim"
+entrypoint = "{{NAME_MODULE}}.sim_impl:SimImpl"
+dependencies_system = [] # include additional apt-get packages to be installed
+
+# Include additional data files
+[tool.setuptools.packages.find]
+where = ["{{NAME_MODULE}}"]
+
+[tool.setuptools.package-data]
+"*" = ["*.json", "*.pkl"]

composabl_cli/template/sim_docker/module/{{NAME_MODULE}}/__init__.py

@@ -0,0 +1,3 @@
+# Copyright (C) Composabl, Inc - All Rights Reserved
+# Unauthorized copying of this file, via any medium is strictly prohibited
+# Proprietary and confidential

composabl_cli/template/sim_docker/module/{{NAME_MODULE}}/sim.py

@@ -0,0 +1,253 @@
+# Copyright (C) Composabl, Inc - All Rights Reserved
+# Unauthorized copying of this file, via any medium is strictly prohibited
+# Proprietary and confidential
+
+import math
+import random
+from typing import Optional
+
+import gymnasium as gym
+import numpy as np
+from composabl_core.agent.scenario import Scenario
+
+
+class Env(gym.Env):
+    def __init__(self):
+        self.obs_space_constraints = {
+            "x": {"low": -400, "high": 400},
+            "x_speed": {"low": -100, "high": 100},
+            "y": {"low": 0, "high": 1000},
+            "y_speed": {"low": -1000, "high": 1000},
+            "angle": {"low": -3.15 * 2, "high": 3.15 * 2},
+            "angle_speed": {"low": -3, "high": 3},
+        }
+
+        deg_to_rad = 0.01745329
+        self.max_gimble = 20 * deg_to_rad
+        self.min_gimble = -self.max_gimble
+
+        self.action_constraints = {
+            "angle": {"low": self.min_gimble, "high": self.max_gimble},
+            "thrust": {"low": 0.4, "high": 1},
+        }
+
+        low_list = [x["low"] for x in self.obs_space_constraints.values()]
+        high_list = [x["high"] for x in self.obs_space_constraints.values()]
+
+        self.sensor_space = gym.spaces.Box(
+            low=np.array(low_list), high=np.array(high_list)
+        )
+
+        low_act_list = [x["low"] for x in self.action_constraints.values()]
+        high_act_list = [x["high"] for x in self.action_constraints.values()]
+
+        self.action_space = gym.spaces.Box(
+            low=np.array(low_act_list), high=np.array(high_act_list)
+        )
+
+        self.state_models = {}
+        self.reward_models = {}
+        self.scenario: Scenario = None
+
+        self.x_obs0 = 0
+        self.x_speed0 = 0
+        self.y_obs0 = 1000
+        self.y_speed0 = -80
+        self.angle0 = -np.pi / 2
+        self.ang_speed0 = 0
+
+    def starship_simulation(self, x, u):
+        g = 9.8
+        m = 100000  # kg
+        min_thrust = 880 * 1000  # N
+        max_thrust = 1 * 2210 * 1000  # kN
+
+        length = 50  # m
+        width = 10
+
+        # Inertia for a uniform density rod
+        I = (1 / 12) * m * length**2
+
+        deg_to_rad = 0.01745329
+
+        max_gimble = 20 * deg_to_rad
+        min_gimble = -max_gimble
+
+        theta = x[4]
+
+        thrust = u[0]
+        thrust_angle = u[1]
+
+        # Horizontal force
+        F_x = max_thrust * thrust * math.sin(thrust_angle + theta)
+        x_dot = x[1]
+        x_dotdot = (F_x) / m
+
+        # Vertical force
+        F_y = max_thrust * thrust * math.cos(thrust_angle + theta)
+        y_dot = x[3]
+        y_dotdot = (F_y) / m - g
+
+        # Torque
+        T = -length / 2 * max_thrust * thrust * math.sin(thrust_angle)
+        theta_dot = x[5]
+        theta_dotdot = T / I
+
+        return [x_dot, x_dotdot, y_dot, y_dotdot, theta_dot, theta_dotdot]
+
+    def reset(
+        self,
+        *,
+        seed: Optional[int] = None,
+        options: Optional[dict] = None,
+        x_obs0: float = 0,
+        x_speed0: float = 0,
+        y_obs0: float = 1000,
+        y_speed0: float = -80,
+        angle0: float = -np.pi / 2,
+        ang_speed0: float = 0
+    ):
+        """
+        # x[0] = x position (m)
+        # x[1] = x velocity (m/)
+        # x[2] = y position (m)
+        # x[3] = y velocity (m/s)
+        # x[4] = angle (rad)
+        # x[5] = angular velocity (rad/s)
+
+        # u[0] = thrust (percent)
+        # u[1] = thrust angle (rad)
+
+        """
+        super().reset(seed=seed)
+        self.cnt = 0
+        self.min_thrust = 880 * 1000  # N
+        self.max_thrust = 1 * 2210 * 1000  # kN
+
+        # Define scenario in the simulation ******
+        if isinstance(self.scenario, Scenario):
+            sample = self.scenario.sample()
+
+            for key in list(sample.keys()):
+                setattr(self, key, sample[key])
+
+        # Set the number of steps and the timestep (dt)
+        steps = 400
+        self.t_step = 0.04
+        self.cnt = 0
+
+        self.x = np.zeros((steps + 1, 6))
+        self.u = np.zeros((steps + 1, 2))
+
+        self.x[0, :] = [
+            self.x_obs0,
+            self.x_speed0,
+            self.y_obs0,
+            self.y_speed0,
+            self.angle0,
+            self.ang_speed0,
+        ]
+        self.x[steps - 1, :] = [0, 0, 0, 0, 0, 0]
+
+        self.x_obs = self.x[self.cnt, 0]
+        self.x_speed = self.x[self.cnt, 1]
+        self.y_obs = self.x[self.cnt, 2]
+        self.y_speed = self.x[self.cnt, 3]
+        self.angle = self.x[self.cnt, 4]
+        self.ang_speed = self.x[self.cnt, 5]
+
+        self.t = 0.4
+        self.a = 0
+        self.reward_value = 0
+
+        self.obs = {
+            "x": self.x_obs,
+            "x_speed": self.x_speed,
+            "y": self.y_obs,
+            "y_speed": self.y_speed,
+            "angle": self.angle,
+            "angle_speed": self.ang_speed,
+        }
+
+        self.obs = np.array(list(self.obs.values()))
+        info = {}
+        return self.obs, info
+
+    def set_scenario(self, scenario):
+        self.scenario = scenario
+
+    def step(self, action):
+        terminated = False
+        discount = 0
+        reward = 0
+
+        def sumsqr(lt):
+            v = sum([x**2 for x in lt])
+            return v
+
+        angle = action[0]
+        thrust = action[1]
+
+        actuator_noise = 0
+        self.t = thrust + random.uniform(
+            -actuator_noise * thrust, actuator_noise * thrust
+        )
+        self.a = angle + random.uniform(-actuator_noise * angle, actuator_noise * angle)
+
+        self.t = np.clip(self.t, 0.4, 1)
+        self.a = np.clip(self.a, self.min_gimble, self.max_gimble)
+
+        # update u
+        self.u[self.cnt, 0] = self.t
+        self.u[self.cnt, 1] = self.a
+
+        res = self.starship_simulation(self.x[self.cnt, :], self.u[self.cnt, :])
+        res = [v * self.t_step for v in res]
+
+        self.x[self.cnt + 1, :] = [
+            sum(value) for value in zip(self.x[self.cnt, :], res)
+        ]
+
+        # Increase time
+        self.cnt += 1
+        # update values
+        self.x_obs = self.x[self.cnt, 0]
+        self.x_speed = self.x[self.cnt, 1]
+        self.y_obs = self.x[self.cnt, 2]
+        self.y_speed = self.x[self.cnt, 3]
+        self.angle = self.x[self.cnt, 4]
+        self.ang_speed = self.x[self.cnt, 5]
+
+        # update obs with new state values
+        self.obs = {
+            "x": self.x_obs,
+            "x_speed": self.x_speed,
+            "y": self.y_obs,
+            "y_speed": self.y_speed,
+            "angle": self.angle,
+            "angle_speed": self.ang_speed,
+        }
+        # add noise
+        for key in list(self.obs.keys()):
+            val = float(self.obs[key])
+            sensor_noise = 0.0
+            self.obs[key] = val + random.uniform(
+                -val * sensor_noise, val * sensor_noise
+            )
+
+        # end the simulation
+        if self.y_obs < 0:
+            terminated = True
+        elif (
+            not self.obs_space_constraints["x"]["low"]
+            <= self.x_obs
+            <= self.obs_space_constraints["x"]["high"]
+        ):
+            terminated = True
+
+        self.obs = np.array(list(self.obs.values()))
+        info = {}
+        return self.obs, reward, terminated, False, info
+
+    def render(self, mode="auto"):
+        pass

composabl_cli/template/sim_docker/module/{{NAME_MODULE}}/sim_impl.py

@@ -0,0 +1,115 @@
+# Copyright (C) Composabl, Inc - All Rights Reserved
+# Unauthorized copying of this file, via any medium is strictly prohibited
+# Proprietary and confidential
+
+from typing import Any, Dict, SupportsFloat, Tuple
+
+import composabl_core.utils.logger as logger_util
+import gymnasium as gym
+from composabl_core.agent.scenario import Scenario
+from composabl_core.networking.sim.server_composabl import ServerComposabl
+from gymnasium.envs.registration import EnvSpec
+
+from .sim import Env
+
+logger = logger_util.get_logger(__name__)
+
+
+class SimImpl(ServerComposabl):
+    def __init__(self):
+        self.env = Env()
+
+    async def make(self, env_id: str, env_init: dict) -> EnvSpec:
+        """
+        Make the environment
+
+        Args:
+        - env_id (str): Environment ID
+        - env_init (dict): Environment Initialization
+
+        Returns:
+        - EnvSpec: Environment Specification
+        """
+        spec = {"id": "starship", "max_episode_steps": 400}
+        return spec
+
+    async def sensor_space_info(self) -> gym.Space:
+        """
+        Get the sensor space information
+
+        Returns:
+        - Space: Sensor Space in Gymnasium Specification
+        """
+        return self.env.sensor_space
+
+    async def action_space_info(self) -> gym.Space:
+        """
+        Get the action space information
+
+        Returns:
+        - Space: Action Space in Gymnasium Specification
+        """
+        return self.env.action_space
+
+    async def action_space_sample(self) -> Any:
+        """
+        Get the action space sample
+
+        Returns:
+        - List[Any]: A list of samples
+        """
+        return self.env.action_space.sample()
+
+    async def reset(self) -> Tuple[Any, Dict[str, Any]]:
+        """
+        Reset the environment
+
+        Returns:
+        - Tuple[Any, Dict[str, Any]]: The observation and the info
+        """
+        sensors, info = self.env.reset()
+        return sensors, info
+
+    async def step(
+        self, action
+    ) -> Tuple[Any, SupportsFloat, bool, bool, Dict[str, Any]]:
+        """
+        Step the environment
+
+        Args:
+        - action: The action to take
+
+        Returns:
+        - Tuple[Any, SupportsFloat, bool, bool, Dict[str, Any]]: The observation, reward, is_truncated, is_done, info
+        """
+        return self.env.step(action)
+
+    async def close(self):
+        """
+        Close the environment
+        """
+        self.env.close()
+
+    async def set_scenario(self, scenario):
+        """
+        Set the scenario
+        """
+        self.env.scenario = scenario
+
+    async def get_scenario(self):
+        """
+        Get the scenario
+        """
+        if self.env.scenario is None:
+            return Scenario({"dummy": 0})
+
+        return self.env.scenario
+
+    async def get_render(self):
+        """
+        Get the render
+
+        Args:
+        - render_mode: The render mode
+        """
+        return self.env.get_render_frame()

composabl_cli/template/skill_controller/README.md

@@ -0,0 +1,67 @@
+# README
+
+This is a template for creating a new Perceptor. A Perceptor is a component that is responsible for processing data and returning a result. This can be used for example in a Machine Learning model, where the Perceptor is responsible for processing the data and returning the prediction.
+
+## Tree Structure
+
+The template is structured as follows:
+
+```bash
+my-perceptor/           # Root folder
+├── my_perceptor/       # Main package folder
+│   ├── __init__.py     # Package init file
+│   └── perceptor.py    # Main perceptor file
+├── pyproject.toml      # Project configuration, containing [composabl]
+```
+
+## PyProject [composabl] Section
+
+We add the `[composabl]` section to the `pyproject.toml` file to specify the type of component we are creating as well as its entrypoint. This is used by the Composabl CLI to determine the type of
+component and how to handle it.
+
+Example:
+
+```
+[composabl]
+type = "teacher"
+entrypoint = "my_perceptor.perceptor:MyPerceptor"
+```
+
+## Development
+
+To work on the Perceptor, you can simply create a temporary file or main file that starts up and executes the `compute` method of the portable Perceptor. Example, we can create a `test.py` file with:
+
+```python
+from composabl_perceptor_my_perceptor.perceptor import MyPerceptor
+
+
+async def start():
+    p = MyPerceptor()
+    res = await t.compute(None, [1.0])
+    print(res)
+
+
+if __name__ == "__main__":
+    import asyncio
+
+    asyncio.run(start())
+```
+
+Which we can then run with
+
+```bash
+# Install the module
+pip install -e my-perceptor
+
+# Run the test file
+python my-perceptor/test.py
+```
+
+### Preparing for Upload
+
+Once we are ready for uploading, we can create a `.tar.gz` file that contains the version. This can be done with the following command:
+
+```bash
+# Tar GZ the plugin
+tar -czvf my-perceptor-0.0.1.tar.gz my-perceptor
+```

composabl_cli/template/skill_controller/pyproject.toml

@@ -0,0 +1,12 @@
+[project]
+name = "{{NAME}}"
+version = "0.1.0"
+description = "{{DESCRIPTION}}"
+authors = [{ name = "John Doe", email = "john.doe@composabl.com" }]
+dependencies = [
+    "composabl-core{{COMPOSABL_DEV}}{{COMPOSABL_CORE_VERSION}}",
+]
+
+[composabl]
+type = "skill-controller"
+entrypoint = "{{NAME_MODULE}}.controller:Controller"

composabl_cli/template/skill_controller/{{NAME_MODULE}}/__init__.py

@@ -0,0 +1,3 @@
+# Copyright (C) Composabl, Inc - All Rights Reserved
+# Unauthorized copying of this file, via any medium is strictly prohibited
+# Proprietary and confidential

composabl_cli/template/skill_controller/{{NAME_MODULE}}/controller.py

@@ -0,0 +1,40 @@
+# Copyright (C) Composabl, Inc - All Rights Reserved
+# Unauthorized copying of this file, via any medium is strictly prohibited
+# Proprietary and confidential
+
+from random import randint
+from typing import Dict, List
+
+from composabl_core import SkillController
+
+
+class Controller(SkillController):
+    """
+    We start at 10 reward and count down to 0 the goal is that the agent stays
+    above or equal to 0 this means it learned to cound +1 each time
+    """
+
+    def __init__(self, *args, **kwargs):
+        self.past_obs = None
+        self.counter = 10
+        self.sensor_name = "counter"
+
+    async def compute_action(self, transformed_sensors: Dict, action) -> List[float]:
+        # generate a random action between -5 and 5
+        action = [randint(-5, 5)]
+        return action
+
+    async def compute_success_criteria(self, transformed_sensors: Dict, action) -> bool:
+        return bool(transformed_sensors[self.sensor_name] >= 10)
+
+    async def compute_termination(self, transformed_sensors: Dict, action) -> bool:
+        return bool(transformed_sensors[self.sensor_name] <= -10)
+
+    async def transform_sensors(self, sensors, action) -> str:
+        return sensors
+
+    async def transform_action(self, transformed_sensors: Dict, action) -> float:
+        return action
+
+    async def filtered_sensor_space(self) -> List[str]:
+        return ["counter"]

composabl_cli/template/skill_coordinated_population/README.md

@@ -0,0 +1,67 @@
+# README
+
+This is a template for creating a new Perceptor. A Perceptor is a component that is responsible for processing data and returning a result. This can be used for example in a Machine Learning model, where the Perceptor is responsible for processing the data and returning the prediction.
+
+## Tree Structure
+
+The template is structured as follows:
+
+```bash
+my-perceptor/           # Root folder
+├── my_perceptor/       # Main package folder
+│   ├── __init__.py     # Package init file
+│   └── perceptor.py    # Main perceptor file
+├── pyproject.toml      # Project configuration, containing [composabl]
+```
+
+## PyProject [composabl] Section
+
+We add the `[composabl]` section to the `pyproject.toml` file to specify the type of component we are creating as well as its entrypoint. This is used by the Composabl CLI to determine the type of
+component and how to handle it.
+
+Example:
+
+```
+[composabl]
+type = "teacher"
+entrypoint = "my_perceptor.perceptor:MyPerceptor"
+```
+
+## Development
+
+To work on the Perceptor, you can simply create a temporary file or main file that starts up and executes the `compute` method of the portable Perceptor. Example, we can create a `test.py` file with:
+
+```python
+from composabl_perceptor_my_perceptor.perceptor import MyPerceptor
+
+
+async def start():
+    p = MyPerceptor()
+    res = await t.compute(None, [1.0])
+    print(res)
+
+
+if __name__ == "__main__":
+    import asyncio
+
+    asyncio.run(start())
+```
+
+Which we can then run with
+
+```bash
+# Install the module
+pip install -e my-perceptor
+
+# Run the test file
+python my-perceptor/test.py
+```
+
+### Preparing for Upload
+
+Once we are ready for uploading, we can create a `.tar.gz` file that contains the version. This can be done with the following command:
+
+```bash
+# Tar GZ the plugin
+tar -czvf my-perceptor-0.0.1.tar.gz my-perceptor
+```

composabl_cli/template/skill_coordinated_population/pyproject.toml

@@ -0,0 +1,12 @@
+[project]
+name = "{{NAME}}"
+version = "0.1.0"
+description = "{{DESCRIPTION}}"
+authors = [{ name = "John Doe", email = "john.doe@composabl.com" }]
+dependencies = [
+    "composabl-core{{COMPOSABL_DEV}}{{COMPOSABL_CORE_VERSION}}",
+]
+
+[composabl]
+type = "skill-coordinated-population"
+entrypoint = "{{NAME_MODULE}}.coach:Coach"

composabl_cli/template/skill_coordinated_population/{{NAME_MODULE}}/__init__.py

@@ -0,0 +1,3 @@
+# Copyright (C) Composabl, Inc - All Rights Reserved
+# Unauthorized copying of this file, via any medium is strictly prohibited
+# Proprietary and confidential

composabl_cli/template/skill_coordinated_population/{{NAME_MODULE}}/coach.py

@@ -0,0 +1,70 @@
+# Copyright (C) Composabl, Inc - All Rights Reserved
+# Unauthorized copying of this file, via any medium is strictly prohibited
+# Proprietary and confidential
+
+import math
+from typing import Dict, List
+
+from composabl_core.agent.skill.skill_coach import SkillCoach
+
+
+class Coach(SkillCoach):
+    """
+    We start at 10 reward and count down to 0 the goal is that the agent stays
+    above or equal to 0 this means it learned to cound +1 each time
+    """
+
+    def __init__(self, *args, **kwargs):
+        self.past_obs = None
+        self.counter = 10
+        self.sensor_name = "counter"
+
+    async def compute_reward(self, transformed_sensors: Dict, action, sim_reward):
+        """
+        The reward increases the closer it gets to 10, but decreases the
+        further it gets from 10 it decreases faster the further it gets
+        note: we do this through a piecewise function, where the reward is
+        100 if the counter is 10 and 0 if the counter is 0 everything above
+        10 gets a steep decrease and everything below 10 gets a small increase
+        ASCII of the Piecewise Graph
+                      ***********
+                 *****           ***
+              ***                   **
+            **                        **
+         ***                            **
+        *                                 *
+                                           **
+                                             *
+                                              *
+                                               *
+        """
+        counter = transformed_sensors[self.sensor_name]
+
+        # Small build up if < 10
+        # given by e^(counter - 10) + 100
+        if counter < 10:
+            return math.exp(counter - 10) + 100
+        # else steep decent after max reward
+        # given by -2 * e^(-|counter - 10|) + 100
+        else:
+            return -2 * math.exp(-abs(counter - 10)) + 100
+
+    async def compute_action_mask(
+        self, transformed_sensors: Dict, action
+    ) -> List[bool]:
+        return None
+
+    async def compute_success_criteria(self, transformed_sensors: Dict, action) -> bool:
+        return bool(transformed_sensors[self.sensor_name] >= 10)
+
+    async def compute_termination(self, transformed_sensors: Dict, action) -> bool:
+        return bool(transformed_sensors[self.sensor_name] <= -10)
+
+    async def transform_sensors(self, sensors, action) -> str:
+        return sensors
+
+    async def transform_action(self, transformed_sensors: Dict, action) -> float:
+        return action
+
+    async def filtered_sensor_space(self) -> List[str]:
+        return ["counter"]