amesa-cli 0.1.0__tar.gz

amesa_cli-0.1.0/MANIFEST.in

@@ -0,0 +1,6 @@
+global-exclude *.py
+
+recursive-include amesa_cli/template *.toml
+recursive-include amesa_cli/template *.md
+recursive-include amesa_cli/template *.sh
+recursive-include amesa_cli/template *

amesa_cli-0.1.0/PKG-INFO

@@ -0,0 +1,49 @@
+Metadata-Version: 2.4
+Name: amesa-cli
+Version: 0.1.0
+Summary: the Amesa CLI
+Author-email: Hunter Park <hunter@amesa.com>
+Requires-Python: >=3.10, <3.13
+Description-Content-Type: text/markdown
+Requires-Dist: typer[all]==0.11.0
+Requires-Dist: click<8.2.0
+Requires-Dist: cython
+Requires-Dist: docker
+Requires-Dist: kubernetes
+Requires-Dist: jinja2
+Requires-Dist: amesa-core>=0.1.0
+Requires-Dist: amesa-train>=0.1.0
+Requires-Dist: amesa-api>=0.1.0
+Requires-Dist: ruff
+Requires-Dist: simple-term-menu
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: requires-python
+
+# Amesa
+
+Amesa helps you build Autonomous Agents! Through an easy SDK you get access to outscaled simulator training tools.
+
+## Licenses / Seats
+
+Amesa is an enterprise platform and requires an API key to use.
+
+We offer 3 types of licenses:
+
+- **Enterprise:** for enterprise projects and agent creations
+- **Personal:** for personal usage and testing (typically offered to System Integrators)
+- **Trial:** validate the Amesa platform (requires sales contact person)
+
+One key is needed per user (seat-based licensing)
+
+You can request an API Key through the following methods:
+
+- [Discord](https://discord.gg/EQ3BgJt9NC)
+- [Mail](mailto:sales@amesa.com?subject=REQUEST%20API%20KEY%20-%20COMPANY_NAME%20-%20NAME&body=Hi%2C%0D%0A%0D%0AI%20would%20like%20to%20request%20an%20API%20key%20for%20my%20company%20to%20get%20started%20with%20Amesa.%0D%0A%0D%0A*%20Company%20Name%3A%20COMPANY_NAME%0D%0A*%20Seats%3A%20NO_OF_SEATS%0D%0A*%20License%20Type%3A%20Enterprise%20%7C%20Personal%20%7C%20Trial%20%28keep%20what%20is%20required%29%0D%0A%0D%0AKind%20Regards%2C%0D%0ANAME%0D%0AFUNCTION)
+
+## Getting Started
+
+1. Download the Amesa SDK: `pip install amesa`
+2. Request an API Key
+3. Get a simulator or use one of the [prebuilt ones](https://hub.docker.com/u/amesa)
+4. Create an Agent or see our [examples](https://github.com/Amesa/examples.amesa.com)

amesa_cli-0.1.0/README.md

@@ -0,0 +1,27 @@
+# Amesa
+
+Amesa helps you build Autonomous Agents! Through an easy SDK you get access to outscaled simulator training tools.
+
+## Licenses / Seats
+
+Amesa is an enterprise platform and requires an API key to use.
+
+We offer 3 types of licenses:
+
+- **Enterprise:** for enterprise projects and agent creations
+- **Personal:** for personal usage and testing (typically offered to System Integrators)
+- **Trial:** validate the Amesa platform (requires sales contact person)
+
+One key is needed per user (seat-based licensing)
+
+You can request an API Key through the following methods:
+
+- [Discord](https://discord.gg/EQ3BgJt9NC)
+- [Mail](mailto:sales@amesa.com?subject=REQUEST%20API%20KEY%20-%20COMPANY_NAME%20-%20NAME&body=Hi%2C%0D%0A%0D%0AI%20would%20like%20to%20request%20an%20API%20key%20for%20my%20company%20to%20get%20started%20with%20Amesa.%0D%0A%0D%0A*%20Company%20Name%3A%20COMPANY_NAME%0D%0A*%20Seats%3A%20NO_OF_SEATS%0D%0A*%20License%20Type%3A%20Enterprise%20%7C%20Personal%20%7C%20Trial%20%28keep%20what%20is%20required%29%0D%0A%0D%0AKind%20Regards%2C%0D%0ANAME%0D%0AFUNCTION)
+
+## Getting Started
+
+1. Download the Amesa SDK: `pip install amesa`
+2. Request an API Key
+3. Get a simulator or use one of the [prebuilt ones](https://hub.docker.com/u/amesa)
+4. Create an Agent or see our [examples](https://github.com/Amesa/examples.amesa.com)

amesa_cli-0.1.0/amesa_cli/template/agent_amesa/agent.py

@@ -0,0 +1,90 @@
+# Copyright (C) Amesa, 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 amesa import Agent, MaintainGoal, Sensor, Skill, Trainer
+
+# Accept the EULA
+os.environ["AMESA_EULA_AGREED"] = "1"
+
+# Set the license
+# os.environ["AMESA_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": {"amesa"},
+            "resources": {
+                "sim_count": 2,
+            },
+        }
+    )
+
+    r.train(a, train_cycles=5)
+    r.close()
+
+
+if __name__ == "__main__":
+    main()

amesa_cli-0.1.0/amesa_cli/template/agent_docker/agent.py

@@ -0,0 +1,99 @@
+# Copyright (C) Amesa, 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 amesa import Agent, MaintainGoal, Sensor, Skill, Trainer
+
+# Accept the EULA
+os.environ["AMESA_EULA_AGREED"] = "1"
+
+# Set the license
+# os.environ["AMESA_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": "amesa/sim-cartpole-dev:latest"}},
+            "resources": {
+                "sim_count": 2,
+            },
+            "post_processing": {
+                "record": {
+                    "is_enabled": True,
+                    "file_path": "/tmp/amesa/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()

amesa_cli-0.1.0/amesa_cli/template/agent_local/agent.py

@@ -0,0 +1,96 @@
+# Copyright (C) Amesa, 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 amesa import Agent, MaintainGoal, Sensor, Skill, Trainer
+
+# Accept the EULA
+os.environ["AMESA_EULA_AGREED"] = "1"
+
+# Set the license
+# os.environ["AMESA_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/amesa/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()

amesa_cli-0.1.0/amesa_cli/template/perceptor/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 [amesa]
+```
+
+## PyProject [amesa] Section
+
+We add the `[amesa]` 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 Amesa CLI to determine the type of
+component and how to handle it.
+
+Example:
+
+```
+[amesa]
+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 amesa_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
+```

amesa_cli-0.1.0/amesa_cli/template/perceptor/pyproject.toml

@@ -0,0 +1,15 @@
+[project]
+name = "{{NAME}}"
+version = "0.1.0"
+description = "{{DESCRIPTION}}"
+authors = [{ name = "John Doe", email = "john.doe@amesa.com" }]
+dependencies = [
+    "amesa-core{{AMESA_DEV}}{{AMESA_CORE_VERSION}}",
+]
+
+[amesa]
+type = "perceptor"
+variables = [
+    "counter_derived"
+]
+entrypoint = "{{NAME_MODULE}}.perceptor:DemoPerceptor"

amesa_cli-0.1.0/amesa_cli/template/perceptor/{{NAME_MODULE}}/__init__.py

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

amesa_cli-0.1.0/amesa_cli/template/perceptor/{{NAME_MODULE}}/perceptor.py

@@ -0,0 +1,34 @@
+# Copyright (C) Amesa, Inc - All Rights Reserved
+# Unauthorized copying of this file, via any medium is strictly prohibited
+# Proprietary and confidential
+
+import time
+
+from amesa_core import PerceptorImpl
+
+
+class DemoPerceptor(PerceptorImpl):
+    def __init__(self, *args, **kwargs):
+        self.previous_value = None
+        self.previous_time = None
+
+    async def compute(self, obs_spec, obs):
+        current_value = obs["counter"]
+        current_time = time.time()  # Get current time
+        value_derived = 0
+
+        # Only calculate derivative if we have a previous sensors values
+        if self.previous_value is not None and self.previous_time is not None:
+            time_delta = current_time - self.previous_time
+
+            if time_delta > 0:  # Check to ensure time has passed
+                value_derived = (current_value - self.previous_value) / time_delta
+
+        # Update previous value and time for the next sensor values
+        self.previous_value = current_value
+        self.previous_time = current_time
+
+        return {"counter_derived": value_derived}
+
+    def filtered_sensor_space(self, obs):
+        return ["counter"]

amesa_cli-0.1.0/amesa_cli/template/selector_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 [amesa]
+```
+
+## PyProject [amesa] Section
+
+We add the `[amesa]` 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 Amesa CLI to determine the type of
+component and how to handle it.
+
+Example:
+
+```
+[amesa]
+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 amesa_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
+```

amesa_cli-0.1.0/amesa_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@amesa.com" }]
+dependencies = [
+    "amesa-core{{AMESA_DEV}}{{AMESA_CORE_VERSION}}",
+]
+
+[amesa]
+type = "selector-controller"
+entrypoint = "{{NAME_MODULE}}.controller:Controller"

amesa_cli-0.1.0/amesa_cli/template/selector_controller/{{NAME_MODULE}}/__init__.py

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

amesa_cli-0.1.0/amesa_cli/template/selector_controller/{{NAME_MODULE}}/controller.py

@@ -0,0 +1,52 @@
+# Copyright (C) Amesa, Inc - All Rights Reserved
+# Unauthorized copying of this file, via any medium is strictly prohibited
+# Proprietary and confidential
+
+from typing import Dict, List
+
+from amesa_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"]