composabl-cli-dev 0.9.0.dev66__cp310-cp310-macosx_10_9_universal2.whl → 0.18.6.dev13__cp310-cp310-macosx_10_9_universal2.whl

composabl_cli/template/agent_composabl/agent.py

@@ -0,0 +1,90 @@
+# Copyright (C) Composabl, Inc - All Rights Reserved
+# Unauthorized copying of this file, via any medium is strictly prohibited
+# Proprietary and confidential
+
+import os
+from typing import Dict
+
+from composabl import Agent, MaintainGoal, Sensor, Skill, Trainer
+
+# Accept the EULA
+os.environ["COMPOSABL_EULA_AGREED"] = "1"
+
+# Set the license
+# os.environ["COMPOSABL_LICENSE"] = "YOUR_LICENSE_KEY"
+
+
+class BalanceTeacher(MaintainGoal):
+    def __init__(self, *args, **kwargs):
+        super().__init__(
+            "pole_theta", "Maintain pole to upright", target=0, stop_distance=0.418
+        )
+
+        # defaults the BL and BR
+
+    async def compute_action_mask(self, transformed_sensors: Dict, action):
+        # Cartpole might not use an action mask, so this can return None
+        return None
+
+    async def transform_sensors(self, sensors, action):
+        # For Cartpole, might just return sensors directly
+        return sensors
+
+    async def transform_action(self, transformed_sensors: Dict, action):
+        # No transformation needed for discrete action space
+        return action
+
+    async def filtered_sensor_space(self):
+        # Return relevant sensors
+        return ["cart_pos", "cart_vel", "pole_theta", "pole_alpha"]
+
+
+def main():
+    # Create the agent
+    a = Agent()
+
+    # https://gymnasium.farama.org/environments/classic_control/cart_pole/#observation-space
+    a.add_sensors(
+        [
+            Sensor(
+                "cart_pos",
+                "The Cart Position between [-4.8, 4.8]",
+                lambda sensors: sensors[0],
+            ),
+            Sensor(
+                "cart_vel",
+                "The Cart Position between  [-inf, inf]",
+                lambda sensors: sensors[1],
+            ),
+            Sensor(
+                "pole_theta",
+                "The Pole Angle [-0.418 rad, 0.418 rad]",
+                lambda sensors: sensors[2],
+            ),
+            Sensor(
+                "pole_alpha",
+                "The Pole Angular Velocity [-inf, inf]",
+                lambda sensors: sensors[3],
+            ),
+        ]
+    )
+
+    skill = Skill("pole-balance", BalanceTeacher)
+    a.add_skill(skill)
+
+    # Create trainer and train the agent
+    r = Trainer(
+        {
+            "target": {"composabl"},
+            "resources": {
+                "sim_count": 2,
+            },
+        }
+    )
+
+    r.train(a, train_cycles=5)
+    r.close()
+
+
+if __name__ == "__main__":
+    main()

composabl_cli/template/agent_docker/agent.py

@@ -0,0 +1,99 @@
+# Copyright (C) Composabl, Inc - All Rights Reserved
+# Unauthorized copying of this file, via any medium is strictly prohibited
+# Proprietary and confidential
+
+import os
+from typing import Dict
+
+from composabl import Agent, MaintainGoal, Sensor, Skill, Trainer
+
+# Accept the EULA
+os.environ["COMPOSABL_EULA_AGREED"] = "1"
+
+# Set the license
+# os.environ["COMPOSABL_LICENSE"] = "YOUR_LICENSE_KEY"
+
+
+class BalanceTeacher(MaintainGoal):
+    def __init__(self, *args, **kwargs):
+        super().__init__(
+            "pole_theta", "Maintain pole to upright", target=0, stop_distance=0.418
+        )
+
+        # defaults the BL and BR
+
+    async def compute_action_mask(self, transformed_sensors: Dict, action):
+        # Cartpole might not use an action mask, so this can return None
+        return None
+
+    async def transform_sensors(self, sensors, action):
+        # For Cartpole, might just return sensors directly
+        return sensors
+
+    async def transform_action(self, transformed_sensors: Dict, action):
+        # No transformation needed for discrete action space
+        return action
+
+    async def filtered_sensor_space(self):
+        # Return relevant sensors
+        return ["cart_pos", "cart_vel", "pole_theta", "pole_alpha"]
+
+
+def main():
+    # Create the agent
+    a = Agent()
+
+    # https://gymnasium.farama.org/environments/classic_control/cart_pole/#observation-space
+    a.add_sensors(
+        [
+            Sensor(
+                "cart_pos",
+                "The Cart Position between [-4.8, 4.8]",
+                lambda sensors: sensors[0],
+            ),
+            Sensor(
+                "cart_vel",
+                "The Cart Position between  [-inf, inf]",
+                lambda sensors: sensors[1],
+            ),
+            Sensor(
+                "pole_theta",
+                "The Pole Angle [-0.418 rad, 0.418 rad]",
+                lambda sensors: sensors[2],
+            ),
+            Sensor(
+                "pole_alpha",
+                "The Pole Angular Velocity [-inf, inf]",
+                lambda sensors: sensors[3],
+            ),
+        ]
+    )
+
+    skill = Skill("pole-balance", BalanceTeacher)
+    a.add_skill(skill)
+
+    # Create trainer and train the agent
+    r = Trainer(
+        {
+            "target": {"docker": {"image": "composabl/sim-cartpole-dev:latest"}},
+            "resources": {
+                "sim_count": 2,
+            },
+            "post_processing": {
+                "record": {
+                    "is_enabled": True,
+                    "file_path": "/tmp/composabl/recordings",
+                    "avi_file_name": "output.avi",
+                    "gif_file_name": "output.gif",
+                    "max_frames": 24 * 5,
+                },
+            },
+        }
+    )
+
+    r.train(a, train_cycles=5)
+    r.close()
+
+
+if __name__ == "__main__":
+    main()

composabl_cli/template/agent_local/agent.py

@@ -0,0 +1,96 @@
+# Copyright (C) Composabl, Inc - All Rights Reserved
+# Unauthorized copying of this file, via any medium is strictly prohibited
+# Proprietary and confidential
+
+import os
+from typing import Dict
+
+from composabl import Agent, MaintainGoal, Sensor, Skill, Trainer
+
+# Accept the EULA
+os.environ["COMPOSABL_EULA_AGREED"] = "1"
+
+# Set the license
+# os.environ["COMPOSABL_LICENSE"] = "YOUR_LICENSE_KEY"
+
+
+class BalanceTeacher(MaintainGoal):
+    def __init__(self, *args, **kwargs):
+        super().__init__(
+            "pole_theta", "Maintain pole to upright", target=0, stop_distance=0.418
+        )
+
+        # defaults the BL and BR
+
+    async def compute_action_mask(self, transformed_sensors: Dict, action):
+        # Cartpole might not use an action mask, so this can return None
+        return None
+
+    async def transform_sensors(self, sensors, action):
+        # For Cartpole, might just return sensors directly
+        return sensors
+
+    async def transform_action(self, transformed_sensors: Dict, action):
+        # No transformation needed for discrete action space
+        return action
+
+    async def filtered_sensor_space(self):
+        # Return relevant sensors
+        return ["cart_pos", "cart_vel", "pole_theta", "pole_alpha"]
+
+
+def main():
+    # Create the agent
+    a = Agent()
+
+    # https://gymnasium.farama.org/environments/classic_control/cart_pole/#observation-space
+    a.add_sensors(
+        [
+            Sensor(
+                "cart_pos",
+                "The Cart Position between [-4.8, 4.8]",
+                lambda sensors: sensors[0],
+            ),
+            Sensor(
+                "cart_vel",
+                "The Cart Position between  [-inf, inf]",
+                lambda sensors: sensors[1],
+            ),
+            Sensor(
+                "pole_theta",
+                "The Pole Angle [-0.418 rad, 0.418 rad]",
+                lambda sensors: sensors[2],
+            ),
+            Sensor(
+                "pole_alpha",
+                "The Pole Angular Velocity [-inf, inf]",
+                lambda sensors: sensors[3],
+            ),
+        ]
+    )
+
+    skill = Skill("pole-balance", BalanceTeacher)
+    a.add_skill(skill)
+
+    # Create trainer and train the agent
+    r = Trainer(
+        {
+            "target": {"local": {"address": "localhost:1337"}},
+            "post_processing": {
+                "record": {
+                    "is_enabled": True,
+                    "file_path": "/tmp/composabl/recordings",
+                    "avi_file_name": "output.avi",
+                    "gif_file_name": "output.gif",
+                    "max_frames": 24 * 5,
+                },
+            },
+        }
+    )
+
+    r.train(a, train_cycles=5)
+    r.close()
+
+
+if __name__ == "__main__":
+    main()

composabl_cli/template/perceptor/pyproject.toml

@@ -4,9 +4,12 @@ version = "0.1.0"
 description = "{{DESCRIPTION}}"
 authors = [{ name = "John Doe", email = "john.doe@composabl.com" }]
 dependencies = [
-    "composabl-core"
+    "composabl-core{{COMPOSABL_DEV}}{{COMPOSABL_CORE_VERSION}}",
 ]
 
 [composabl]
 type = "perceptor"
+variables = [
+    "counter_derived"
+]
 entrypoint = "{{NAME_MODULE}}.perceptor:DemoPerceptor"

composabl_cli/template/selector_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 = "selector-controller"
+entrypoint = "{{NAME_MODULE}}.controller:Controller"

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

@@ -0,0 +1,52 @@
+# Copyright (C) Composabl, Inc - All Rights Reserved
+# Unauthorized copying of this file, via any medium is strictly prohibited
+# Proprietary and confidential
+
+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]:
+        """
+        Compute action in a programme selector is to select the best skill based in a rule or an optimization.
+        Let's supose that we have three skills:
+        1 - Decrease counter
+        2 - Increase counter
+        3 - Stop
+        """
+        # return Skill 1 = decrease
+        if self.counter > 10:
+            return [0]
+        # return Skill 2 = increase
+        elif self.counter < 10:
+            return [1]
+        # return Skill 3 = stop
+        else:
+            return [3]
+
+    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/selector_teacher/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_coach → selector_teacher}/pyproject.toml

@@ -8,5 +8,5 @@ dependencies = [
 ]
 
 [composabl]
-type = "skill-coach"
-entrypoint = "{{NAME_MODULE}}.coach:Coach"
+type = "selector-teacher"
+entrypoint = "{{NAME_MODULE}}.teacher:Teacher"

composabl_cli/template/{skill_teacher/my_skill → selector_teacher/{{NAME_MODULE}}}/teacher.py

@@ -49,7 +49,9 @@ class Teacher(SkillTeacher):
         else:
             return -2 * math.exp(-abs(counter - 10)) + 100
 
-    async def compute_action_mask(self, transformed_sensors: Dict, action) -> List[bool]:
+    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:
@@ -65,4 +67,4 @@ class Teacher(SkillTeacher):
         return action
 
     async def filtered_sensor_space(self) -> List[str]:
-        return [self.sensor_name]
+        return ["counter"]

composabl_cli/template/sim/pyproject.toml

@@ -4,7 +4,7 @@ version = "0.1.0"
 description = "{{DESCRIPTION}}"
 authors = [{ name = "John Doe", email = "john.doe@composabl.com" }]
 dependencies = [
-    "composabl-core"
+    "composabl-core{{COMPOSABL_DEV}}{{COMPOSABL_CORE_VERSION}}",
 ]
 
 [composabl]

composabl_cli/template/sim/{my_sim → {{NAME_MODULE}}}/sim.py

@@ -4,7 +4,7 @@
 
 import math
 import random
-from typing import Any, Dict, Optional, SupportsFloat, Tuple
+from typing import Optional
 
 import gymnasium as gym
 import numpy as np
@@ -22,9 +22,13 @@ class Env(gym.Env):
             "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 = {
-            "delta_angle": {"low": -1, "high": 1},
-            "delta_thrust": {"low": -1, "high": 1},
+            "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()]
@@ -120,24 +124,12 @@ class Env(gym.Env):
         self.min_thrust = 880 * 1000  # N
         self.max_thrust = 1 * 2210 * 1000  # kN
 
-        deg_to_rad = 0.01745329
-
-        self.max_gimble = 20 * deg_to_rad
-        self.min_gimble = -self.max_gimble
-
         # 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])
-        else:
-            self.x_obs0 = x_obs0
-            self.x_speed0 = x_speed0
-            self.y_obs0 = y_obs0
-            self.y_speed0 = y_speed0
-            self.angle0 = angle0
-            self.ang_speed0 = ang_speed0
 
         # Set the number of steps and the timestep (dt)
         steps = 400
@@ -164,7 +156,7 @@ class Env(gym.Env):
         self.angle = self.x[self.cnt, 4]
         self.ang_speed = self.x[self.cnt, 5]
 
-        self.t = 0
+        self.t = 0.4
         self.a = 0
         self.reward_value = 0
 
@@ -193,16 +185,14 @@ class Env(gym.Env):
             v = sum([x**2 for x in lt])
             return v
 
-        thrust = action[0]
-        angle = action[1]
+        angle = action[0]
+        thrust = action[1]
 
         actuator_noise = 0
-        self.t += thrust + random.uniform(
+        self.t = thrust + random.uniform(
             -actuator_noise * thrust, actuator_noise * thrust
         )
-        self.a += angle + random.uniform(
-            -actuator_noise * angle, actuator_noise * angle
-        )
+        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)
@@ -228,9 +218,6 @@ class Env(gym.Env):
         self.angle = self.x[self.cnt, 4]
         self.ang_speed = self.x[self.cnt, 5]
 
-        # self.x_goal = obs['desired_goal'][0]
-        # self.y_goal = obs['desired_goal'][1]
-
         # update obs with new state values
         self.obs = {
             "x": self.x_obs,
@@ -243,7 +230,7 @@ class Env(gym.Env):
         # add noise
         for key in list(self.obs.keys()):
             val = float(self.obs[key])
-            sensor_noise = 0.0  # TODO: add noise as parameter
+            sensor_noise = 0.0
             self.obs[key] = val + random.uniform(
                 -val * sensor_noise, val * sensor_noise
             )

composabl_cli/template/sim/{my_sim → {{NAME_MODULE}}}/sim_impl.py

@@ -7,10 +7,10 @@ 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.server_composabl import ServerComposabl
+from composabl_core.networking.sim.server_composabl import ServerComposabl
 from gymnasium.envs.registration import EnvSpec
 
-from {{NAME_MODULE}}.sim import Env
+from .sim import Env
 
 logger = logger_util.get_logger(__name__)
 

composabl_cli/template/sim_docker/Dockerfile

@@ -0,0 +1,45 @@
+######################################################
+# Composabl Image
+######################################################
+FROM python:3.11-slim
+
+# Set working directory
+WORKDIR /opt/composabl
+
+# ######################################################
+# Install Dependencies
+# ######################################################
+RUN apt update; apt install -y unzip tree
+
+# ######################################################
+# Make `python3` available as `python`
+# ######################################################
+RUN ln -s /usr/bin/python3 /usr/bin/python
+
+# ######################################################
+# Install Composabl
+# ######################################################
+RUN pip install composabl-core
+
+# ######################################################
+# Install Python Module
+# ######################################################
+COPY module/ /opt/composabl/sim/
+RUN pip install /opt/composabl/sim/
+
+# ######################################################
+# Install Composabl Code and Docker scripts
+# ######################################################
+# Copy over the scripts
+COPY docker /docker
+RUN chmod +x /docker/*.sh
+
+# Copy over the main startup file
+# this file takes care of starting the Composabl server
+COPY *.py /opt/composabl/
+
+# ######################################################
+# Define run
+# ######################################################
+EXPOSE 1337
+CMD ["/docker/sim-start.sh", "/opt/composabl/sim"]