rccn-gen 1.0.3__tar.gz → 1.2.0__tar.gz

{rccn_gen-1.0.3 → rccn_gen-1.2.0}/.gitignore

@@ -2,7 +2,7 @@
 *.DS_Store
 *.ipynb
 *.pyc
-venv/
+.venv/
 examples/
 tests/
 *.diff
@@ -15,7 +15,7 @@ __pycache__/
 *.xml
 *.whl
 *.egg-info/
-/dist
+dist/
 rccn_usr_com_app/Cargo.toml
 .rccn_diffs/
 .rccn_snapshots/

rccn_gen-1.2.0/CHANGELOG.md

@@ -0,0 +1,29 @@
+# CHANGE LOG
+
+## [1.2.0] - 2025-05-05
+- Added argument hints for RCCNCommand, Service and RCCNContainer
+- New create_and_add_service() method for the Application
+- New create_and_add_command() method for the Service
+- Better error messages
+- Subtypes of RCCNCommands and RCCNContainers are defined automatically, if not specified by the user
+- General refactoring for more readable code
+- Added add_integer_parameter method to RCCNContainer
+- Bug fixes
+
+### [1.1.2] - 2025-04-23
+- The `export_directory` argument for the `Application` is now mandatory.  
+
+### [1.1.1] - 2025-04-22
+- Changed the user input checking to allow for multiple command with the same name and subtype, as long as they are associated to different services.
+
+## [1.1.0] - 2025-04-14
+- Added derive statements to the rust container structs in the telemetry.rs file.
+- Inherit subtype of a container from the `condition` argument, if given, or from the new (optional) `subtype` argument. If only the latter is given, condition is created from that. Subtype is included in the derive statements.
+- Added missing `use anyhow::Result` import and bug fixes in `main.rs` file. 
+- Added new dependencies in `cargo.toml` file.
+- Changed names of command structs to differentiate between trait names and struct names. 
+- Include bit number statement in enum declaration.
+- The `tc` parameter in the service.rs file is now mutable.
+- `System` of a command is obtained from the base command, if no system argument is given.
+- Added support for long and short descriptions of commands, arguments and supported telemetry parameters.
+- Bug fixes.

{rccn_gen-1.0.3 → rccn_gen-1.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: rccn_gen
-Version: 1.0.3
+Version: 1.2.0
 Summary: A python based generator for RACCOON OS source files in Rust from yamcs-pymdb config files.
 Project-URL: Homepage, https://gitlab.com/rccn/pymdb_code_generation
 Project-URL: Issues, https://gitlab.com/rccn/pymdb_code_generation/issues
@@ -16,19 +16,18 @@ Description-Content-Type: text/markdown
 
 # RCCN Code Generator
 This generator is used to generate Rust files to deploy on the RACCOON OS satellite based on the pymdb config files used to generate the ground station XTCE files.
+
+To see whats new, see the [CHANGELOG](CHANGELOG.md).
 ## Setup
-- Pull the repo
 - Set up a virtual python environment with `python3` and activate:
     ```zsh
     python -m venv .venv
     source .venv/bin/activate
     ```
-- Install pymdb with `pip install yamcs-pymdb`
+- Install with `pip install rccn-gen`
 
 ## Using the Generator
 The generator is based on [`pymdb`](https://github.com/yamcs/pymdb) and uses the same structure. Where `pymdb` gives the user freedom in defining systems, subsystems and their respective relations, the definitions for rust code generation is more restricted. For the rust generation, the user is bound to the following classes:
-- Application,
-- Service, and
 - `Application`,
 - `Service`, and
 - `RCCNCommand`.
@@ -45,7 +44,7 @@ An application can be defined with the following statement.
 ```python
 app = Application(system=root_system, name="ExampleApp", apid=42)
 ```
-It has the obligatory arguments **system**, **name** and **apid**. After all Applications, Services and RCCNCommands are defined, the rust code generator can be called on the application with `app.generate_rccn_code()`.
+It has the obligatory arguments **system**, **name**, **apid** and **export_directory**. After all Applications, Services and RCCNCommands are defined, the rust code generator can be called on the application with `app.generate_rccn_code(export_directory='.')`.
 
 ### Service
 
@@ -53,7 +52,13 @@ A service may be defined with the following command.
 ```python
 service = Service(name="ExampleService", system=app, service_id = 131)
 ```
-It has the obligatory arguments **name** and **system**. The system corresponds to the application where the service is associated to. Note that each service has one associated app. A service cannot be associated to more than one apps. You may think of the Application-Service-Command structure as a mathematical tree, where merging branches are not allowed. However, you can create multiple instances of the same service and associate them to different applications, or create multiple identical command instances and associate them to different services. 
+Or like this:
+```python
+service = Service(name="ExampleService", service_id = 131)
+app.add_service(service)
+```
+
+It has the obligatory arguments **name** and **system**. The system corresponds to the application where the service is associated to. Note that each service has one associated app. A service cannot be associated to more than one app. You may think of the Application-Service-Command structure as a mathematical tree, where merging branches are not allowed. However, you can create multiple instances of the same service and associate them to different applications, or create multiple identical command instances and associate them to different services. 
 
 ### RCCNCommand
 An RCCNCommand can be defined with the following statement.
@@ -65,7 +70,33 @@ RCCNCommand(
     arguments=[StringArgument("name", encoding=StringEncoding())],
 )
 ```
-Obligatory arguments are **system**, **base**, **name** and **arguments**. The latter can be an empty list. The definition must contain a subtype definition in the assignment property, like shown in the example. 
+
+Or like this:
+```python
+my_command = RCCNCommand(
+    assignments={"subtype": 2},
+    name="StopProcess",
+    arguments=[StringArgument("name", encoding=StringEncoding())],
+)
+service.add_command(my_command)
+```
+
+The only obligatory arguments are **name** and a **subtype assignment**, like shown in the example. The connection to a service can also be achieved with base commands, where every base command must be unique to a service. For example:
+
+```python
+base_cmd = RCCNCommand(
+    system=service,
+    assignments={"type": service.service_id},
+    name="base",
+    base="/PUS/pus-tc"
+)
+my_command = RCCNCommand(
+    base=base_cmd,
+    assignments={"subtype": 2},
+    name="StopProcess",
+    arguments=[StringArgument("name", encoding=StringEncoding())],
+)
+```
 
 ## Output
 From the python configuration, the `main.rs`, `service.rs`, `command.rs`, `mod.rs`, `Cargo.toml` and `telemetry.rs` files are generated and are structured accordingly:
@@ -124,4 +155,4 @@ Snapshots of the .rs files in the export directory are stored in `/user/`. These
 app.keep_snapshots = 15 # Whatever value you want
 ```
 
-With the sequence from above, it becomes apperant that changes to the .rs file in the export directory always trump changes to the pymdb config. If for example, a main.rs file is generated for an application with and APID of 42, and this apid is changed in the main.rs file to 45, this change will persist after regenerating from the python config. Even if changes to the pymdb config where made after the changes to the main.rs file. 
+With the sequence from above, it becomes apperant that changes to the .rs file in the export directory always trump changes to the pymdb config. If for example, a main.rs file is generated for an application with and APID of 42, and this apid is changed in the main.rs file to 45, this change will persist after regenerating from the python config. Even if changes to the pymdb config where made after the changes to the main.rs file. 

{rccn_gen-1.0.3 → rccn_gen-1.2.0}/README.md

@@ -1,18 +1,17 @@
 # RCCN Code Generator
 This generator is used to generate Rust files to deploy on the RACCOON OS satellite based on the pymdb config files used to generate the ground station XTCE files.
+
+To see whats new, see the [CHANGELOG](CHANGELOG.md).
 ## Setup
-- Pull the repo
 - Set up a virtual python environment with `python3` and activate:
     ```zsh
     python -m venv .venv
     source .venv/bin/activate
     ```
-- Install pymdb with `pip install yamcs-pymdb`
+- Install with `pip install rccn-gen`
 
 ## Using the Generator
 The generator is based on [`pymdb`](https://github.com/yamcs/pymdb) and uses the same structure. Where `pymdb` gives the user freedom in defining systems, subsystems and their respective relations, the definitions for rust code generation is more restricted. For the rust generation, the user is bound to the following classes:
-- Application,
-- Service, and
 - `Application`,
 - `Service`, and
 - `RCCNCommand`.
@@ -29,7 +28,7 @@ An application can be defined with the following statement.
 ```python
 app = Application(system=root_system, name="ExampleApp", apid=42)
 ```
-It has the obligatory arguments **system**, **name** and **apid**. After all Applications, Services and RCCNCommands are defined, the rust code generator can be called on the application with `app.generate_rccn_code()`.
+It has the obligatory arguments **system**, **name**, **apid** and **export_directory**. After all Applications, Services and RCCNCommands are defined, the rust code generator can be called on the application with `app.generate_rccn_code(export_directory='.')`.
 
 ### Service
 
@@ -37,7 +36,13 @@ A service may be defined with the following command.
 ```python
 service = Service(name="ExampleService", system=app, service_id = 131)
 ```
-It has the obligatory arguments **name** and **system**. The system corresponds to the application where the service is associated to. Note that each service has one associated app. A service cannot be associated to more than one apps. You may think of the Application-Service-Command structure as a mathematical tree, where merging branches are not allowed. However, you can create multiple instances of the same service and associate them to different applications, or create multiple identical command instances and associate them to different services. 
+Or like this:
+```python
+service = Service(name="ExampleService", service_id = 131)
+app.add_service(service)
+```
+
+It has the obligatory arguments **name** and **system**. The system corresponds to the application where the service is associated to. Note that each service has one associated app. A service cannot be associated to more than one app. You may think of the Application-Service-Command structure as a mathematical tree, where merging branches are not allowed. However, you can create multiple instances of the same service and associate them to different applications, or create multiple identical command instances and associate them to different services. 
 
 ### RCCNCommand
 An RCCNCommand can be defined with the following statement.
@@ -49,7 +54,33 @@ RCCNCommand(
     arguments=[StringArgument("name", encoding=StringEncoding())],
 )
 ```
-Obligatory arguments are **system**, **base**, **name** and **arguments**. The latter can be an empty list. The definition must contain a subtype definition in the assignment property, like shown in the example. 
+
+Or like this:
+```python
+my_command = RCCNCommand(
+    assignments={"subtype": 2},
+    name="StopProcess",
+    arguments=[StringArgument("name", encoding=StringEncoding())],
+)
+service.add_command(my_command)
+```
+
+The only obligatory arguments are **name** and a **subtype assignment**, like shown in the example. The connection to a service can also be achieved with base commands, where every base command must be unique to a service. For example:
+
+```python
+base_cmd = RCCNCommand(
+    system=service,
+    assignments={"type": service.service_id},
+    name="base",
+    base="/PUS/pus-tc"
+)
+my_command = RCCNCommand(
+    base=base_cmd,
+    assignments={"subtype": 2},
+    name="StopProcess",
+    arguments=[StringArgument("name", encoding=StringEncoding())],
+)
+```
 
 ## Output
 From the python configuration, the `main.rs`, `service.rs`, `command.rs`, `mod.rs`, `Cargo.toml` and `telemetry.rs` files are generated and are structured accordingly:
@@ -108,4 +139,4 @@ Snapshots of the .rs files in the export directory are stored in `/user/`. These
 app.keep_snapshots = 15 # Whatever value you want
 ```
 
-With the sequence from above, it becomes apperant that changes to the .rs file in the export directory always trump changes to the pymdb config. If for example, a main.rs file is generated for an application with and APID of 42, and this apid is changed in the main.rs file to 45, this change will persist after regenerating from the python config. Even if changes to the pymdb config where made after the changes to the main.rs file. 
+With the sequence from above, it becomes apperant that changes to the .rs file in the export directory always trump changes to the pymdb config. If for example, a main.rs file is generated for an application with and APID of 42, and this apid is changed in the main.rs file to 45, this change will persist after regenerating from the python config. Even if changes to the pymdb config where made after the changes to the main.rs file. 

{rccn_gen-1.0.3 → rccn_gen-1.2.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "rccn_gen"
-version = "1.0.3"
+version = "1.2.0"
 authors = [
   { name="Fabian Krech", email="f.krech@tu-berlin.de" },
 ]

rccn_gen-1.2.0/rccn_usr_bi_x1_cntrl_app/Cargo.toml

@@ -0,0 +1,17 @@
+[package]
+name = "rccn_usr_example_app"
+version = "0.1.0"
+edition = "2021"
+
+[dependencies]
+anyhow = "1.0.91"
+binary_serde = "1.0.24"
+crossbeam-channel = "0.5.13"
+futures = "0.3.31"
+rccn_usr = { version = "0.1.0", path = "../rccn_usr" }
+satrs = "0.2.1"
+spacepackets = "0.12.0"
+tokio = "1.41.1"
+env_logger = { version = "0.11.7", default-features = false, features = ["color", "humantime"] }
+num-derive = "0.4"
+num-traits = "0.2"

{rccn_gen-1.0.3 → rccn_gen-1.2.0}/src/rccn_gen/systems.py

@@ -1,10 +1,11 @@
-from yamcs.pymdb import System, Subsystem, Command, Container
+from yamcs.pymdb import *
 import shutil
 import difflib
 import datetime
 from caseconverter import *
 from importlib.resources import files
 from .utils import *
+from collections.abc import Mapping, Sequence
 
 class Application(Subsystem):
     """
@@ -16,9 +17,9 @@ class Application(Subsystem):
         name: str,
         apid: int,
         vcid: int = 0,
-        export_file_path = '.',
-        snapshot_file_path = './.rccn_snapshots',
-        diff_file_path = './.rccn_diffs',
+        export_directory = '.',
+        snapshot_directory = './.rccn_snapshots',
+        diff_directory = './.rccn_diffs',
         snapshots = True,
         *args,
         **kwargs
@@ -27,15 +28,13 @@ class Application(Subsystem):
 
         self.apid = apid
         self.vcid = vcid
+        self.export_directory = export_directory
         system._subsystems_by_name[name] = self
-        self.export_file_path = export_file_path
-        self.snapshot_file_path = snapshot_file_path
-        self.snapshot_generated_file_path = os.path.join(snapshot_file_path, 'auto_generated')
-        self.diff_file_path = diff_file_path
+        self.snapshot_directory = snapshot_directory
+        self.snapshot_generated_file_path = os.path.join(snapshot_directory, 'auto_generated')
+        self.diff_directory = diff_directory
         self.text_modules_path = files('rccn_gen').joinpath('text_modules')
-        print(self.text_modules_path)
         self.text_modules_main_path = os.path.join(self.text_modules_path, 'main')
-        print(self.text_modules_main_path)
         self.snapshots = snapshots
         self.keep_snapshots = 10
     
@@ -43,27 +42,52 @@ class Application(Subsystem):
         if not isinstance(service, Service):
             raise TypeError('Service '+service.name+' is not a RCCNCommand.')
         service.add_to_application(self)
-    
+
+    def create_and_add_service(
+            self,
+            name: str,
+            service_id: int,
+            aliases: Mapping[str, str] | None = None,
+            short_description: str | None = None,
+            long_description: str | None = None,
+            extra: Mapping[str, str] | None = None,
+            *args, 
+            **kwargs
+    ):
+        if 'system' not in kwargs:
+            kwargs['system'] = self
+        else:
+            raise ValueError('RCCN-Error: \'create_and_add_service\' function can not be called with a \'system\' argument.')
+        Service(
+            name=name, 
+            service_id=service_id, 
+            aliases=aliases, 
+            short_description=short_description, 
+            long_description=long_description, 
+            *args, 
+            **kwargs
+        )
+
     def file_paths(self):
         paths = {
-            'main': os.path.join(self.export_file_path, 'rccn_usr_'+snakecase(self.name), 'src', 'main.rs'),
-            'main_generated_snapshot': os.path.join(self.snapshot_file_path, 'generated', 'rccn_usr_'+snakecase(self.name), 'src', 'main.rs'),
+            'main': os.path.join(self.export_directory, 'rccn_usr_'+snakecase(self.name), 'src', 'main.rs'),
+            'main_generated_snapshot': os.path.join(self.snapshot_directory, 'generated', 'rccn_usr_'+snakecase(self.name), 'src', 'main.rs'),
             'main_user_snapshot': os.path.join(self.user_snapshot_path(), 'rccn_usr_'+snakecase(self.name), 'src', 'main.rs'),
-            'main_diff': os.path.join(self.diff_file_path, 'rccn_usr_'+snakecase(self.name), 'src', 'main.diff'),
+            'main_diff': os.path.join(self.diff_directory, 'rccn_usr_'+snakecase(self.name), 'src', 'main.diff'),
             'main_template': os.path.join(self.text_modules_main_path, 'main.txt'),
-            'cargo_toml': os.path.join(self.export_file_path, 'rccn_usr_'+snakecase(self.name), 'Cargo.toml'),
+            'cargo_toml': os.path.join(self.export_directory, 'rccn_usr_'+snakecase(self.name), 'Cargo.toml'),
             'cargo_toml_template': os.path.join(self.text_modules_path, 'cargo_toml', 'cargo.txt'),
         }
         return paths
 
     def user_snapshot_path(self):
-        return os.path.join(self.snapshot_file_path, 'user', datetime.datetime.now().strftime("%Y-%m-%d_%H-%M-%S"))
+        return os.path.join(self.snapshot_directory, 'user', datetime.datetime.now().strftime("%Y-%m-%d_%H-%M-%S"))
 
     def services(self):
         return [subsystem for subsystem in self.subsystems if isinstance(subsystem, Service)]
 
     def create_rccn_directories(self):
-        app_src_dir = os.path.join(self.export_file_path, 'rccn_usr_'+snakecase(self.name), 'src')
+        app_src_dir = os.path.join(self.export_directory, 'rccn_usr_'+snakecase(self.name), 'src')
         if not os.path.exists(app_src_dir):
             os.makedirs(app_src_dir)
         for service in self.services():
@@ -111,8 +135,20 @@ class Application(Subsystem):
         text = delete_all_keywords(text)
         return text 
     
-    def generate_rccn_code(self, rebase_changes=True, check=True, export_file_path='.'):
-        self.export_file_path = export_file_path
+    def generate_rccn_code(self, export_directory:str, snapshot_directory='', diff_directory='', rebase_changes=True, check=True):
+        # Update export, snapshot and diff directory for the Application and all Services
+        self.export_directory = export_directory
+        if snapshot_directory == '':
+            snapshot_directory = os.path.join(self.export_directory, '.rccn-snapshots')
+        if diff_directory == '':
+            diff_directory = os.path.join(self.export_directory, '.rccn-diffs')
+        self.snapshot_directory = snapshot_directory
+        self.diff_directory = diff_directory
+        for service in self.services():
+            service.export_directory = self.export_directory
+            service.diff_directory = self.diff_directory
+            service.snapshot_directory = self.snapshot_directory
+        
         if check:
             self.check_user_input()
         self.rebase_changes = rebase_changes
@@ -122,12 +158,12 @@ class Application(Subsystem):
         if not os.path.exists(self.file_paths()['cargo_toml']):
             self.generate_cargo_toml_file()
         for service in self.services():
-            service.export_file_path = self.export_file_path
+            service.export_directory = self.export_directory
             service.generate_rccn_service_file()
             if not os.path.exists(service.file_paths()['mod']):
                 service.generate_mod_file()
             service.generate_telemetry_file()
-            service.generate_rccn_command_file(os.path.join(self.export_file_path, 'rccn_usr_'+snakecase(self.name), 'src'), os.path.join(self.text_modules_path, 'command'))
+            service.generate_rccn_command_file(os.path.join(self.export_directory, 'rccn_usr_'+snakecase(self.name), 'src'), os.path.join(self.text_modules_path, 'command'))
         self.delete_old_snapshots()
 
     def generate_snapshot(self, current_file_reference, snapshot_file_reference):
@@ -146,37 +182,37 @@ class Application(Subsystem):
             diff_file.write(diff_text)
     
     def delete_old_snapshots(self):
-        if os.path.exists(os.path.join(self.snapshot_file_path, 'user')):
-            user_snapshots_path = os.path.join(self.snapshot_file_path, 'user')
+        if os.path.exists(os.path.join(self.snapshot_directory, 'user')):
+            user_snapshots_path = os.path.join(self.snapshot_directory, 'user')
             snapshots = [os.path.join(user_snapshots_path, d) for d in os.listdir(user_snapshots_path) if os.path.isdir(os.path.join(user_snapshots_path, d))]
             snapshots.sort(key=os.path.getctime)
             while len(snapshots) > self.keep_snapshots:
                 shutil.rmtree(snapshots.pop(0))
     
     def check_user_input(self):
-        # Check if all services have unique names
+        # Check if all services in the application have unique names
         service_names = [service.name for service in self.services()]
         if len(service_names) != len(set(service_names)):
-            raise ValueError('All services must have unique names.')
+            raise ValueError('RCCN-Error: App \''+self.name+'\' has multiple services with the same name.')
         
-        # Check if all services have unique service_ids
+        # Check if all services in the application have unique service_ids
         service_ids = [service.service_id for service in self.services()]
         if len(service_ids) != len(set(service_ids)):
-            raise ValueError('All services must have unique service_ids.')
+            raise ValueError('RCCN-Error: App \''+self.name+'\' has multiple services with the same ID.')
         
-        # Check if all commands have unique names
-        command_names = []
+        # Check if all commands in each service have unique names
         for service in self.services():
+            command_names = []
             command_names += [command.name for command in service.rccn_commands()]
-        if len(command_names) != len(set(command_names)):
-            raise ValueError('All commands must have unique names.')
+            if len(command_names) != len(set(command_names)):
+                raise ValueError('RCCN-Error: Service \''+service.name+'\' has multiple commands with the same name.')
         
-        # Check if all commands have unique subtypes
-        command_subtypes = []
+        # Check if all commands in each service have unique subtypes
         for service in self.services():
+            command_subtypes = []
             command_subtypes += [command.assignments['subtype'] for command in service.rccn_commands()]
-        if len(command_subtypes) != len(set(command_subtypes)):
-            raise ValueError('All commands must have unique subtypes.')
+            if len(command_subtypes) != len(set(command_subtypes)):
+                raise ValueError('RCCN-Error: Service \''+service.name+'\' has multiple commands with the same subtype.')
         
     def generate_cargo_toml_file(self):
         with open(self.file_paths()['cargo_toml_template'], 'r') as file:
@@ -189,7 +225,7 @@ class Service(Subsystem):
     def __init__(
         self,
         name: str,
-        service_id: int = None,
+        service_id: int,
         *args,
         **kwargs
     ):
@@ -218,10 +254,7 @@ class Service(Subsystem):
                 name=self.name,
                 *self.init_args, **self.init_kwargs
             )
-        self.export_file_path = self.system.export_file_path
-        self.snapshot_file_path = self.system.snapshot_file_path
         self.snapshots = self.system.snapshots
-        self.diff_file_path = self.system.diff_file_path
     
     def add_container(self, container):
         if not isinstance(container, RCCNContainer):
@@ -235,28 +268,28 @@ class Service(Subsystem):
     
     def file_paths(self):
         paths = {
-            'service': os.path.join(self.export_file_path, 'rccn_usr_'+snakecase(self.system.name), 'src', snakecase(self.name), 'service.rs'),
-            'service_generated_snapshot': os.path.join(self.snapshot_file_path, 'generated', 'rccn_usr_'+snakecase(self.system.name), 'src', snakecase(self.name), 'service.rs'),
-            'service_user_snapshot': os.path.join(self.snapshot_file_path, 'user', datetime.datetime.now().strftime("%Y-%m-%d_%H-%M-%S"), 'rccn_usr_'+snakecase(self.system.name), 'src', snakecase(self.name), 'service.rs'),
-            'service_diff': os.path.join(self.diff_file_path, 'rccn_usr_'+snakecase(self.system.name), 'src', snakecase(self.name), 'service.diff'),
+            'service': os.path.join(self.export_directory, 'rccn_usr_'+snakecase(self.system.name), 'src', snakecase(self.name), 'service.rs'),
+            'service_generated_snapshot': os.path.join(self.snapshot_directory, 'generated', 'rccn_usr_'+snakecase(self.system.name), 'src', snakecase(self.name), 'service.rs'),
+            'service_user_snapshot': os.path.join(self.snapshot_directory, 'user', datetime.datetime.now().strftime("%Y-%m-%d_%H-%M-%S"), 'rccn_usr_'+snakecase(self.system.name), 'src', snakecase(self.name), 'service.rs'),
+            'service_diff': os.path.join(self.diff_directory, 'rccn_usr_'+snakecase(self.system.name), 'src', snakecase(self.name), 'service.diff'),
             'service_template': os.path.join(self.text_modules_service_path, 'service.txt'),
-            'command': os.path.join(self.export_file_path, 'rccn_usr_'+snakecase(self.system.name), 'src', snakecase(self.name), 'command.rs'),
-            'command_generated_snapshot': os.path.join(self.snapshot_file_path, 'generated', 'rccn_usr_'+snakecase(self.system.name), 'src', snakecase(self.name), 'command.rs'),
-            'command_user_snapshot': os.path.join(self.snapshot_file_path, 'user', datetime.datetime.now().strftime("%Y-%m-%d_%H-%M-%S"), 'rccn_usr_'+snakecase(self.system.name), 'src', snakecase(self.name), 'command.rs'),
-            'command_diff': os.path.join(self.diff_file_path, 'rccn_usr_'+snakecase(self.system.name), 'src', snakecase(self.name), 'command.diff'),
+            'command': os.path.join(self.export_directory, 'rccn_usr_'+snakecase(self.system.name), 'src', snakecase(self.name), 'command.rs'),
+            'command_generated_snapshot': os.path.join(self.snapshot_directory, 'generated', 'rccn_usr_'+snakecase(self.system.name), 'src', snakecase(self.name), 'command.rs'),
+            'command_user_snapshot': os.path.join(self.snapshot_directory, 'user', datetime.datetime.now().strftime("%Y-%m-%d_%H-%M-%S"), 'rccn_usr_'+snakecase(self.system.name), 'src', snakecase(self.name), 'command.rs'),
+            'command_diff': os.path.join(self.diff_directory, 'rccn_usr_'+snakecase(self.system.name), 'src', snakecase(self.name), 'command.diff'),
             'command_template': os.path.join(self.text_modules_command_path, 'command.txt'),
-            'mod': os.path.join(self.export_file_path, 'rccn_usr_'+snakecase(self.system.name), 'src', snakecase(self.name), 'mod.rs'),
+            'mod': os.path.join(self.export_directory, 'rccn_usr_'+snakecase(self.system.name), 'src', snakecase(self.name), 'mod.rs'),
             'mod_template': os.path.join(self.text_modules_path, 'mod', 'mod.txt'),
-            'telemetry': os.path.join(self.export_file_path, 'rccn_usr_'+snakecase(self.system.name), 'src', snakecase(self.name), 'telemetry.rs'),
-            'telemetry_generated_snapshot': os.path.join(self.snapshot_file_path, 'generated', 'rccn_usr_'+snakecase(self.system.name), 'src', snakecase(self.name), 'telemetry.rs'),
-            'telemetry_user_snapshot': os.path.join(self.snapshot_file_path, 'user', datetime.datetime.now().strftime("%Y-%m-%d_%H-%M-%S"), 'rccn_usr_'+snakecase(self.system.name), 'src', snakecase(self.name), 'command.rs'),
-            'telemetry_diff': os.path.join(self.diff_file_path, 'rccn_usr_'+snakecase(self.system.name), 'src', snakecase(self.name), 'telemetry.diff'),
+            'telemetry': os.path.join(self.export_directory, 'rccn_usr_'+snakecase(self.system.name), 'src', snakecase(self.name), 'telemetry.rs'),
+            'telemetry_generated_snapshot': os.path.join(self.snapshot_directory, 'generated', 'rccn_usr_'+snakecase(self.system.name), 'src', snakecase(self.name), 'telemetry.rs'),
+            'telemetry_user_snapshot': os.path.join(self.snapshot_directory, 'user', datetime.datetime.now().strftime("%Y-%m-%d_%H-%M-%S"), 'rccn_usr_'+snakecase(self.system.name), 'src', snakecase(self.name), 'command.rs'),
+            'telemetry_diff': os.path.join(self.diff_directory, 'rccn_usr_'+snakecase(self.system.name), 'src', snakecase(self.name), 'telemetry.diff'),
             'telemetry_template': os.path.join(self.text_modules_telemetry_path, 'telemetry.txt'),
         } 
         return paths
 
     def rccn_commands(self):
-        return [command for command in self.commands if isinstance(command, RCCNCommand)]
+        return [command for command in self.commands if isinstance(command, RCCNCommand) and command.name != 'base']
 
     def find_and_replace_keywords(self, text, text_modules_path):
         # Find and replace service module keywords
@@ -272,16 +305,13 @@ class Service(Subsystem):
             replacement_text = (self.find_and_replace_keywords(module_text, text_modules_path) + '\n')
             text = insert_before_with_indentation(text, service_module_keyword, replacement_text)
         
-        # Call keyword replacement for all associated commands (Later, there needs to be checking to account for user changes to the generated files)
-        if len(self.rccn_commands()) == 0:
-            print('RCCN-Gen: Service '+self.name+' does not have any commands associated with it.')
         for command in self.rccn_commands():
             text = command.find_and_replace_keywords(text, text_modules_path)
         
         # Find and replace service variable keywords
         var_keywords = get_var_keywords(text)
         service_var_translation = {
-            '<<VAR_SERVICE_NAME>>': lambda: self.name,
+            '<<VAR_SERVICE_NAME>>': lambda: snakecase(self.name),
             '<<VAR_SERVICE_ID>>': lambda: str(self.service_id),
             '<<VAR_SERVICE_NAME_UCASE>>': lambda: pascalcase(self.name),
             '<<VAR_SERVICE_TELEMETRY>>': lambda: self.generate_rust_telemetry_definition(),
@@ -325,13 +355,13 @@ class Service(Subsystem):
             self.generate_snapshot('command', 'command_user_snapshot')
         # Generate command.rs file
         if len(self.rccn_commands()) == 0:
-            print('RCCN-Gen: Service '+self.name+' has no implemented commands. Generation of command.rs file will be skipped.')
+            print('RCCN-Information: Service \''+self.name+'\' has no commands other than base command. Generation of command.rs file will be skipped.')
             return
         command_file_path = self.file_paths()['command_template']
         with open(command_file_path, 'r') as file:
             command_file_text = file.read()
-        command_export_file_path = os.path.join(export_file_dir, snakecase(self.name), 'command.rs')
-        with open(command_export_file_path, 'w') as file:
+        command_export_directory = os.path.join(export_file_dir, snakecase(self.name), 'command.rs')
+        with open(command_export_directory, 'w') as file:
             file.write(self.find_and_replace_keywords(command_file_text, text_modules_path))
         # Create snapshot of command.rs if instructed
         if self.snapshots:
@@ -387,30 +417,116 @@ class Service(Subsystem):
                 container.__class__ = RCCNContainer
             telemetry_definition_text += container.generate_rccn_telemetry()
         return telemetry_definition_text
+    
+    def create_and_add_command(
+            self,
+            name: str,
+            *,
+            aliases: Mapping[str, str] | None = None,
+            short_description: str | None = None,
+            long_description: str | None = None,
+            extra: Mapping[str, str] | None = None,
+            abstract: bool = False,
+            base: Command | str | None = None,
+            assignments: Mapping[str, Any] | None = None,
+            arguments: Sequence[Argument] | None = None,
+            entries: Sequence[CommandEntry] | None = None,
+            level: CommandLevel = CommandLevel.NORMAL,
+            warning_message: str | None = None,
+            constraint: (
+                Union[TransmissionConstraint, Sequence[TransmissionConstraint]] | None
+            ) = None,
+    ):
+        Command(
+            name=name,
+            system=self,
+            aliases=aliases,
+            short_description=short_description,
+            long_description=long_description,
+            extra=extra,
+            abstract=abstract,
+            base=base,
+            assignments=assignments,
+            arguments=arguments,
+            entries=entries,
+            level=level,
+            warning_message=warning_message,
+            constraint=constraint
+        ) 
+    
+    def rccn_container(self):
+        return [container for container in self.containers if isinstance(container, RCCNContainer)]
 
 
 class RCCNCommand(Command):
-    def __init__(self, *args, **kwargs):
-        self.init_args = args
-        self.init_kwargs = kwargs
+    def __init__(
+        self,
+        name: str,
+        *,
+        aliases: Mapping[str, str] | None = None,
+        short_description: str | None = None,
+        long_description: str | None = None,
+        extra: Mapping[str, str] | None = None,
+        abstract: bool = False,
+        base: Command | str | None = None,
+        assignments: Mapping[str, Any] | None = None,
+        arguments: Sequence[Argument] | None = None,
+        entries: Sequence[CommandEntry] | None = None,
+        level: CommandLevel = CommandLevel.NORMAL,
+        warning_message: str | None = None,
+        constraint: (
+            Union[TransmissionConstraint, Sequence[TransmissionConstraint]] | None
+        ) = None,
+        **kwargs
+    ):
+        self.init_args = ()
+        self.init_kwargs = {
+            'name': name,
+            'aliases': aliases,
+            'short_description': short_description,
+            'long_description': long_description,
+            'extra': extra,
+            'abstract': abstract,
+            'base': base,
+            'assignments': assignments,
+            'arguments': arguments,
+            'entries': entries,
+            'level': level,
+            'warning_message': warning_message,
+            'constraint': constraint,
+            **kwargs
+        }
         if 'system' in kwargs and isinstance(kwargs['system'], Service):
             self.add_to_service(kwargs['system'])
+        elif base and (isinstance(base, Command) or isinstance(base, RCCNCommand)):
+            self.add_to_service(base.system)
 
     def add_to_service(self, service):
-        if not any(command.name == 'base' for command in service.commands):
-            base_command = Command(
+        if not 'base' in self.init_kwargs and not any(command.name == 'base' for command in service.commands):
+            print("RCCN-Information: Command \'"+self.init_kwargs['name']+"\' doesn\'t have a base argument and no base command was found in service \'"+service.name+"\'.\nStandard base command will be created with system = \'"+service.name+"\' and type = "+str(service.service_id)+".")
+            self.init_kwargs['base'] = Command(
                 system=service, 
                 name='base',
                 abstract=True,
                 base='/PUS/pus-tc',
                 assignments={'type': service.service_id}
             )
-            self.init_kwargs['base'] = base_command
+        elif not 'base' in self.init_kwargs and any(command.name == 'base' for command in service.commands):
+            print("RCCN-Information: Command \'"+self.init_kwargs['name']+"\' doesn\'t have a \'base\' argument. Existing base command for service \'"+service.name+"\' will be used.")
+            self.init_kwargs['base'] = next(command for command in service.commands if command.name == 'base')
         if 'system' in self.init_kwargs and isinstance(self.init_kwargs['system'], Service):
             super().__init__(*self.init_args, **self.init_kwargs)
         else:
             super().__init__(system=service, *self.init_args, **self.init_kwargs)
         self.assignments['apid'] = self.system.system.apid
+        if not 'subtype' in self.assignments and self.name is not 'base':
+            used_subtypes = [command.assignments['subtype'] if 'subtype' in command.assignments else None for command in self.system.rccn_commands()]
+            new_subtype = 1
+            while new_subtype in used_subtypes:
+                new_subtype = new_subtype + 1
+            print('RCCN-Information: Command \''+self.name+'\' has no subtype specified. Subtype will be set to '+str(new_subtype)+'.')
+            self.assignments['subtype'] = new_subtype
+        self.struct_name = self.name + 'Args'
 
     
     def find_and_replace_keywords(self, text, text_modules_path):
@@ -432,25 +548,26 @@ class RCCNCommand(Command):
         command_var_translation = {
             '<<VAR_COMMAND_NAME_UCASE>>': lambda: pascalcase(self.name),
             '<<VAR_COMMAND_NAME>>': lambda: self.name,
+            '<<VAR_COMMAND_STRUCT_NAME>>': lambda: self.struct_name,
             '<<VAR_COMMAND_SUBTYPE>>': lambda: str(self.assignments['subtype']),
-            '<<VAR_COMMAND_STRUCT>>': lambda: self.struct_definition()
+            '<<VAR_COMMAND_STRUCT>>': lambda: self.struct_definition(),
+            '<<VAR_SHORT_DESCRIPTION>>': lambda: "\n/// " + self.short_description if self.short_description is not None else "",
         }
         for command_var_keyword in command_var_keywords:
             if command_var_keyword in command_var_translation.keys():
                 text = replace_with_indentation(text, command_var_keyword, command_var_translation[command_var_keyword]())
         return text
     
-    def check_user_input(self):
-        if self.assignments['subtype'] == None and self.name != 'base':
-            raise ValueError('Command '+self.name+' does not have a subtype assigned to it.')
-    
     def user_snapshot_path(self):
-        return os.path.join(self.snapshot_file_path, 'user', datetime.datetime.now().strftime("%Y-%m-%d_%H-%M-%S"))
+        return os.path.join(self.snapshot_directory, 'user', datetime.datetime.now().strftime("%Y-%m-%d_%H-%M-%S"))
 
     def struct_definition(self):
+        struct_definition_text = ""
         if len(self.arguments) == 0:
             return ''
-        struct_definition_text = "#[derive(BitStruct, Debug, PartialEq)]\npub struct "+pascalcase(self.name)+" {\n"
+        if hasattr(self, 'long_description') and self.long_description is not None:
+            struct_definition_text += "/// "+str(self.long_description)+"\n"
+        struct_definition_text += "#[derive(BitStruct, Debug, PartialEq)]\npub struct "+pascalcase(self.struct_name)+" {\n"
         ins = ""
         append = ""
         for argument in self.arguments:
@@ -462,28 +579,147 @@ class RCCNCommand(Command):
         struct_definition_text += append
         return struct_definition_text
 
+
+
 class RCCNContainer(Container):
-    def __init__(self, base="/PUS/pus-tm", *args, **kwargs):
+    def __init__(
+        self,
+        base="/PUS/pus-tm", 
+        subtype = None,
+        *,
+        system: System = None, 
+        name: str = None,
+        entries: Sequence[ParameterEntry | ContainerEntry] | None = None,
+        abstract: bool = False,
+        condition: Expression | None = None,
+        aliases: Mapping[str, str] | None = None,
+        short_description: str | None = None,
+        long_description: str | None = None,
+        extra: Mapping[str, str] | None = None,
+        bits: int | None = None,
+        rate: float | None = None,
+        hint_partition: bool = False,
+    ):
         self.base = base
-        self.init_args = args
-        self.init_kwargs = kwargs
-        if 'system' in kwargs and isinstance(kwargs['system'], Service):
-            self.add_to_service(kwargs['system'])
+        self.subtype = subtype
+        self.init_kwargs = {
+            'system': system,
+            'name': name,
+            'entries': entries,
+            'base': base,
+            'abstract': abstract,
+            'condition': condition,
+            'aliases': aliases,
+            'short_description': short_description,
+            'long_description': long_description,
+            'extra': extra,
+            'bits': bits,
+            'rate': rate,
+            'hint_partition': hint_partition,
+        }
+        
+        if name is None:
+            raise ValueError('RCCN-Error: Container must have a name.')
+            
+        self.name = name
+        if system is not None and isinstance(system, Service):
+            self.add_to_service(system)
 
     def add_to_service(self, service):
+        self.type = service.service_id
+        condition_type = None
+        condition_subtype = None
+        if self.init_kwargs['condition'] is not None:
+            for eq_expression in self.init_kwargs['condition'].expressions:
+                if eq_expression.ref == self.base+'/type':
+                    condition_type = eq_expression.value
+                if eq_expression.ref == self.base+'/subtype':
+                    condition_subtype = eq_expression.value
+        if condition_type is not None and condition_type != self.type:
+            print('RCCN-Warning: Container '+self.name+' has a user-defined type of '+str(eq_expression.value)+', which does\'nt match the service ID. User-defined type will be used.')
+            self.type = condition_type
+        if condition_subtype is not None and self.subtype is not None and condition_subtype != self.subtype:
+            print('RCCN-Warning: Container '+self.name+' has an ambiguous user-defined subtype. \'subtype\' argument should match the \'condition\' argument.')
+        elif condition_subtype is not None:
+            self.subtype = condition_subtype
+        elif self.subtype is not None and self.init_kwargs['condition'] is not None:
+            self.init_kwargs['condition'] = AndExpression(
+                EqExpression(self.base+'/type', self.type),
+                EqExpression(self.base+'/subtype', self.subtype)
+                )
+        else:
+            used_subtypes = [container.subtype for container in service.rccn_container()]
+            new_subtype = 1
+            while new_subtype in used_subtypes:
+                new_subtype = new_subtype + 1
+            self.subtype = new_subtype
+            self.init_kwargs['condition'] = AndExpression(
+                EqExpression(self.base+'/type', self.type),
+                EqExpression(self.base+'/subtype', self.subtype)
+                )
+            print('RCCN-Information: Subtype for Container '+self.name+' is not specified through \'subtype\' or \'condition\' arguments. Subtype will be set to '+str(self.subtype)+'.')
+
         if 'system' in self.init_kwargs and isinstance(self.init_kwargs['system'], Service):
-            super().__init__(*self.init_args, **self.init_kwargs)
+            super().__init__(**self.init_kwargs)
         else:
-            super().__init__(system=service, *self.init_args, **self.init_kwargs)
+            super().__init__(system=service, **self.init_kwargs)
 
     def generate_rccn_telemetry(self):
-        rccn_telemetry_text = "pub struct " + self.name + " {\n"
+        rccn_telemetry_text = ""
+        if hasattr(self, 'short_description') and self.short_description is not None:
+            rccn_telemetry_text += "/// "+str(self.short_description)+"\n"
+        rccn_telemetry_text += "#[derive(ServiceTelemetry, BitStruct, Debug)]\n"
+        if hasattr(self, 'subtype') and self.subtype is not None:
+            rccn_telemetry_text += "#[subtype("+str(self.subtype)+")]\n"
+        rccn_telemetry_text += "pub struct " + self.name + " {\n"
         insert, append = ["",""]
         for parameter_entry in self.entries:
             par_def = rust_type_definition(parameter_entry.parameter)
             insert += par_def[0]
             append += par_def[1]
         rccn_telemetry_text += insert
-        rccn_telemetry_text += "}\n"
+        rccn_telemetry_text += "}\n\n"
         rccn_telemetry_text += append        
-        return rccn_telemetry_text
+        return rccn_telemetry_text
+    
+    def add_integer_parameter(
+            self,
+            name: str,
+            signed: bool = True,
+            bits: int = 32,
+            minimum: int | None = None,
+            maximum: int | None = None,
+            aliases: Mapping[str, str] | None = None,
+            data_source: DataSource = DataSource.TELEMETERED,
+            initial_value: Any = None,
+            persistent: bool = True,
+            short_description: str | None = None,
+            long_description: str | None = None,
+            extra: Mapping[str, str] | None = None,
+            units: str | None = None,
+            encoding: Encoding | None = None,
+            calibrator: Calibrator | None = None,
+            alarm: ThresholdAlarm | None = None,
+            context_alarms: Sequence[ThresholdContextAlarm] | None = None,
+     ):
+        int_parameter = IntegerParameter(
+            system=self,
+            name=name,
+            signed=signed,
+            bits=bits,
+            minimum=minimum,
+            maximum=maximum,
+            aliases=aliases,
+            data_source=data_source,
+            initial_value=initial_value,
+            persistent=persistent,
+            short_description=short_description,
+            long_description=long_description,
+            extra=extra,
+            units=units,
+            encoding=encoding,
+            calibrator=calibrator,
+            alarm=alarm,
+            context_alarms=context_alarms
+        )
+        self.entries.append(int_parameter)

{rccn_gen-1.0.3 → rccn_gen-1.2.0}/src/rccn_gen/text_modules/cargo_toml/cargo.txt

@@ -11,4 +11,7 @@ futures = "0.3.31"
 rccn_usr = { version = "0.1.0", path = "../rccn_usr" }
 satrs = "0.2.1"
 spacepackets = "0.12.0"
-tokio = "1.41.1"
+tokio = "1.41.1"
+env_logger = { version = "0.11.7", default-features = false, features = ["color", "humantime"] }
+num-derive = "0.4"
+num-traits = "0.2"

rccn_gen-1.2.0/src/rccn_gen/text_modules/command/command_module_enum.txt

@@ -0,0 +1,3 @@
+<<VAR_SHORT_DESCRIPTION>>
+#[subservice(<<VAR_COMMAND_SUBTYPE>>)]
+<<VAR_COMMAND_NAME_UCASE>>(<<VAR_COMMAND_STRUCT_NAME>>),

{rccn_gen-1.0.3 → rccn_gen-1.2.0}/src/rccn_gen/text_modules/main/main.txt

@@ -1,3 +1,4 @@
+use anyhow::Result;
 <<SERVICE_MODULE_IMPORT_SERVICE>>
 use rccn_usr::pus::app::PusApp;
 use rccn_usr::zenoh::key_expr::OwnedKeyExpr;

rccn_gen-1.2.0/src/rccn_gen/text_modules/main/service_module_import_service.txt

@@ -0,0 +1 @@
+use <<VAR_SERVICE_NAME>>::service::<<VAR_SERVICE_NAME_UCASE>>;

{rccn_gen-1.0.3 → rccn_gen-1.2.0}/src/rccn_gen/text_modules/service/service.txt

@@ -21,7 +21,7 @@ impl <<VAR_SERVICE_NAME_UCASE>> {
 impl PusService for <<VAR_SERVICE_NAME_UCASE>> {
     type CommandT = command::Command;
 
-    fn handle_tc(&mut self, tc: AcceptedTc, cmd: Self::CommandT) -> AcceptanceResult {
+    fn handle_tc(&mut self, mut tc: AcceptedTc, cmd: Self::CommandT) -> AcceptanceResult {
         println!("PUS-Service: Command received.");
         match cmd {
             <<COMMAND_MODULE_MATCH_CMD>>

{rccn_gen-1.0.3 → rccn_gen-1.2.0}/src/rccn_gen/utils.py

@@ -133,7 +133,9 @@ def rust_type_definition(pymdb_data_instance, parent_name="MyStruct"):
             pymdb_data_instance.name = singular_name
         print("RCCN-Gen: Information: An unnamed "+base_type+" has been named \""+pascalcase(pymdb_data_instance.name)+"\" in the generated RCCN code.")
     sc_instance_name = snakecase(pymdb_data_instance.name)
-
+    definition_text = ["",""]
+    if pymdb_data_instance.short_description is not None:
+        definition_text[0] += ("\n\t/// "+str(pymdb_data_instance.short_description)+"\n")
     if data_type == 'IntegerDataType':
         if pymdb_data_instance.encoding is None or pymdb_data_instance.encoding.bits is None:
             raw_bit_number = 8
@@ -143,42 +145,50 @@ def rust_type_definition(pymdb_data_instance, parent_name="MyStruct"):
         raw_bit_number_str = str(raw_bit_number)
         eng_bit_number = engineering_bit_number(raw_bit_number)
         eng_bit_number_str = str(eng_bit_number)
-        definition_text = ["\t#[bits("+raw_bit_number_str+")]\n"]
+        definition_text[0] += "\t#[bits("+raw_bit_number_str+")]\n"
         if pymdb_data_instance.signed:
             definition_text[0] += ("\tpub "+sc_instance_name+": i"+eng_bit_number_str+",\n")
         else:
             definition_text[0] += ("\tpub "+sc_instance_name+": u"+eng_bit_number_str+",\n")
-        definition_text.append("")
     
     elif data_type == 'BooleanDataType':
-        definition_text = ["\t#[bits(1)]\n\tpub "+sc_instance_name+": bool,\n"]
-        definition_text.append("")
+        definition_text[0] += ("\t#[bits(1)]\n\tpub "+sc_instance_name+": bool,\n")
     
     elif data_type == 'StringDataType':
-        definition_text = ["\t#[null_terminated]\n\tpub "+sc_instance_name+": String,\n", ""]
+        definition_text[0] += "\t#[null_terminated]\n\tpub "+sc_instance_name+": String,\n"
     
     elif data_type == 'ArrayDataType':
         definition_text = rust_type_definition(pymdb_data_instance.data_type, parent_name=pymdb_data_instance.name)
         definition_text[0] = definition_text[0].replace(': ', ': Vec<').replace(',\n', '>,\n')
+        if pymdb_data_instance.short_description is not None:
+            definition_text[0] = "\n\t/// "+pymdb_data_instance.short_description+"\n"+definition_text[0]
+        if pymdb_data_instance.long_description is not None:
+            definition_text[1] = "/// "+pymdb_data_instance.long_description+"\n" + definition_text[1]
     
     elif data_type == 'EnumeratedDataType':
-        definition_text = ["\tpub "+pymdb_data_instance.name+": "+pascalcase(pymdb_data_instance.name)+",\n"]
-        definition_text.append("pub enum "+pascalcase(pymdb_data_instance.name)+" {\n")
+        definition_text[0] += "\t#[bits("+str(pymdb_data_instance.encoding.bits)+")]\n"
+        definition_text[0] += "\tpub "+pymdb_data_instance.name+": "+pascalcase(pymdb_data_instance.name)+",\n"
+        definition_text[1] += ("#[derive(FromPrimative, ToPrimative, Debug)]\npub enum "+pascalcase(pymdb_data_instance.name)+" {\n")
         for choice in pymdb_data_instance.choices:
             definition_text[1] += "\t"+str(choice[1])+" = "+str(choice[0])+",\n"
-        definition_text[1] += "}\n"
+        definition_text[1] += "}\n\n"
+        if pymdb_data_instance.long_description is not None:
+            definition_text[1] = "/// "+pymdb_data_instance.long_description+"\n" + definition_text[1]
     
     elif data_type == 'AggregateDataType':
         struct_name = pascalcase(pymdb_data_instance.name)
-        definition_text = ["\tpub "+sc_instance_name+": "+struct_name+",\n"]
-        definition_text.append("pub struct "+struct_name+" {\n")
+        definition_text[0] += "\tpub "+sc_instance_name+": "+struct_name+",\n"
+        if pymdb_data_instance.long_description is not None:
+            definition_text[1] += "\t/// "+pymdb_data_instance.long_description+"\n"
+        definition_text[1] += ("#[derive(FromPrimative, ToPrimative, Debug)]\n")
+        definition_text[1] += ("pub struct "+struct_name+" {\n")
         insert, append = ["",""]
         for member in pymdb_data_instance.members:
             mem_def = rust_type_definition(member, parent_name=pymdb_data_instance.name)
             insert += mem_def[0]
             append += mem_def[1]
         definition_text[1] += insert
-        definition_text[1] += "}\n"
+        definition_text[1] += "}\n\n"
         definition_text[1] += append
     else:
         definition_text = ["\t// Please implement datatype "+data_type+" here.\n", ""]

rccn_gen-1.0.3/src/rccn_gen/text_modules/command/command_module_enum.txt

@@ -1,2 +0,0 @@
-#[subservice(<<VAR_COMMAND_SUBTYPE>>)]
-<<VAR_COMMAND_NAME_UCASE>>(<<VAR_COMMAND_NAME>>::Args),

rccn_gen-1.0.3/src/rccn_gen/text_modules/main/service_module_import_service.txt

@@ -1 +0,0 @@
-use picture_service::service::<<VAR_SERVICE_NAME_UCASE>>;