rccn-gen 1.2.0__py3-none-any.whl → 1.3.1__py3-none-any.whl

rccn_gen/systems.py

@@ -6,10 +6,32 @@ from caseconverter import *
 from importlib.resources import files
 from .utils import *
 from collections.abc import Mapping, Sequence
+from typing import Union, Any, Literal
+from yamcs.pymdb.alarms import EnumerationAlarm, ThresholdAlarm
+from yamcs.pymdb.alarms import EnumerationContextAlarm, ThresholdContextAlarm
+from yamcs.pymdb.datatypes import Epoch, Member, DataType, DynamicInteger
+from yamcs.pymdb.encodings import Encoding, TimeEncoding
+from yamcs.pymdb.calibrators import Calibrator
+from yamcs.pymdb.parameters import (
+    AbsoluteTimeParameter, AggregateParameter, ArrayParameter,
+    BinaryParameter, BooleanParameter, DataSource,
+    EnumeratedParameter, FloatParameter, IntegerParameter, Parameter,
+    StringParameter
+)
+from yamcs.pymdb.commands import Command, CommandLevel, CommandEntry, Argument, TransmissionConstraint
 
 class Application(Subsystem):
     """
     A PUS application.
+    
+    This class represents a Protocol Utilization Standard (PUS) application in the context 
+    of space systems. It extends the Subsystem class of pymdb and provides functionality for managing 
+    services, generating Rust code for the application, and handling snapshots and diffs of 
+    the generated code.
+    
+    The Application class is responsible for creating and organizing the directory structure 
+    for Rust code generation, managing services and their associated commands and telemetry,
+    and facilitating the generation of Rust code files for the entire application.
     """
     def __init__(
         self,
@@ -24,6 +46,30 @@ class Application(Subsystem):
         *args,
         **kwargs
     ):
+        """
+        Initialize a new PUS application.
+        
+        Parameters:
+        -----------
+        system : System
+            The parent system that this application belongs to.
+        name : str
+            The name of the application.
+        apid : int
+            The Application Process ID (APID) for this application.
+        vcid : int, optional
+            The Virtual Channel ID (VCID) for this application. Default is 0.
+        export_directory : str, optional
+            The directory where generated Rust code will be exported. Default is current directory.
+        snapshot_directory : str, optional
+            The directory where snapshots of generated code will be stored. Default is './.rccn_snapshots'.
+        diff_directory : str, optional
+            The directory where diffs between generated code versions will be stored. Default is './.rccn_diffs'.
+        snapshots : bool, optional
+            Whether to create snapshots of generated code. Default is True.
+        *args, **kwargs
+            Additional arguments and keyword arguments passed to the parent class constructor.
+        """
         super().__init__(system=system, name=name, *args, **kwargs)
 
         self.apid = apid
@@ -39,6 +85,19 @@ class Application(Subsystem):
         self.keep_snapshots = 10
     
     def add_service(self, service):
+        """
+        Add a service to this application.
+        
+        Parameters:
+        -----------
+        service : Service
+            The service to add to this application.
+            
+        Raises:
+        -------
+        TypeError
+            If the provided service is not an instance of Service.
+        """
         if not isinstance(service, Service):
             raise TypeError('Service '+service.name+' is not a RCCNCommand.')
         service.add_to_application(self)
@@ -54,6 +113,31 @@ class Application(Subsystem):
             *args, 
             **kwargs
     ):
+        """
+        Create a new service and add it to this application.
+        
+        Parameters:
+        -----------
+        name : str
+            The name of the service.
+        service_id : int
+            The service ID.
+        aliases : Mapping[str, str], optional
+            Alternative names for the service, keyed by namespace.
+        short_description : str, optional
+            A short description of the service.
+        long_description : str, optional
+            A longer description of the service.
+        extra : Mapping[str, str], optional
+            Arbitrary information about the service, keyed by name.
+        *args, **kwargs
+            Additional arguments and keyword arguments passed to the Service constructor.
+            
+        Raises:
+        -------
+        ValueError
+            If 'system' is provided in kwargs.
+        """
         if 'system' not in kwargs:
             kwargs['system'] = self
         else:
@@ -69,6 +153,14 @@ class Application(Subsystem):
         )
 
     def file_paths(self):
+        """
+        Get the file paths for various files used by this application.
+        
+        Returns:
+        --------
+        dict
+            A dictionary mapping file types to their absolute paths.
+        """
         paths = {
             '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'),
@@ -81,12 +173,34 @@ class Application(Subsystem):
         return paths
 
     def user_snapshot_path(self):
+        """
+        Get the path for user snapshots with current timestamp.
+        
+        Returns:
+        --------
+        str
+            The path where user snapshots are stored.
+        """
         return os.path.join(self.snapshot_directory, 'user', datetime.datetime.now().strftime("%Y-%m-%d_%H-%M-%S"))
 
     def services(self):
+        """
+        Get all services belonging to this application.
+        
+        Returns:
+        --------
+        list[Service]
+            A list of Service objects that are subsystems of this application.
+        """
         return [subsystem for subsystem in self.subsystems if isinstance(subsystem, Service)]
 
     def create_rccn_directories(self):
+        """
+        Create directory structure for Rust code generation.
+        
+        Creates the necessary directory structure for the application and its services
+        in the export directory.
+        """
         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)
@@ -96,6 +210,16 @@ class Application(Subsystem):
                 os.makedirs(service_dir)
 
     def generate_rccn_main_file(self):
+        """
+        Generate the main.rs file for the application.
+        
+        Performs several tasks:
+        1. Creates diff file if both current and snapshot files exist
+        2. Creates snapshot of current main.rs with user changes if snapshots are enabled
+        3. Generates new main.rs file from template
+        4. Creates snapshot of newly generated main.rs if snapshots are enabled
+        5. Applies user changes from diff file if rebase_changes is enabled
+        """
         # Create main.diff file
         if os.path.exists(self.file_paths()['main']) and os.path.exists(self.file_paths()['main_generated_snapshot']):
             os.makedirs(os.path.dirname(self.file_paths()['main_diff']), exist_ok=True)
@@ -117,6 +241,24 @@ class Application(Subsystem):
             os.system('patch '+self.file_paths()['main']+' <  '+self.file_paths()['main_diff'])
     
     def find_and_replace_keywords(self, text):
+        """
+        Replace template keywords with actual values.
+        
+        Parameters:
+        -----------
+        text : str
+            Template text containing keywords to be replaced.
+            
+        Returns:
+        --------
+        str
+            Text with all keywords replaced with actual values.
+            
+        Raises:
+        -------
+        KeyError
+            If a keyword in the template text is not found in the translation dictionary.
+        """
         # Call keyword replacement for all associated services (Later, there needs to be checking to account for user changes to the generated files)
         for service in self.services():
             text = service.find_and_replace_keywords(text, self.text_modules_main_path)
@@ -136,6 +278,22 @@ class Application(Subsystem):
         return text 
     
     def generate_rccn_code(self, export_directory:str, snapshot_directory='', diff_directory='', rebase_changes=True, check=True):
+        """
+        Generate Rust code for the application and its services.
+        
+        Parameters:
+        -----------
+        export_directory : str
+            Directory where the generated code will be exported.
+        snapshot_directory : str, optional
+            Directory where snapshots of generated code will be stored. Default is a subdirectory of export_directory.
+        diff_directory : str, optional
+            Directory where diffs between generated code versions will be stored. Default is a subdirectory of export_directory.
+        rebase_changes : bool, optional
+            Whether to apply user changes from diff files. Default is True.
+        check : bool, optional
+            Whether to perform checks on user input. Default is True.
+        """
         # Update export, snapshot and diff directory for the Application and all Services
         self.export_directory = export_directory
         if snapshot_directory == '':
@@ -167,10 +325,32 @@ class Application(Subsystem):
         self.delete_old_snapshots()
 
     def generate_snapshot(self, current_file_reference, snapshot_file_reference):
+        """
+        Create a snapshot of a file.
+        
+        Parameters:
+        -----------
+        current_file_reference : str
+            Reference to the current file in the file_paths dictionary.
+        snapshot_file_reference : str
+            Reference to the snapshot file in the file_paths dictionary.
+        """
         os.makedirs(os.path.dirname(self.file_paths()[snapshot_file_reference]), exist_ok=True)
         shutil.copyfile(self.file_paths()[current_file_reference], self.file_paths()[snapshot_file_reference])
     
     def generate_diff_file(self, current_file_reference, snapshot_file_reference, diff_file_reference):
+        """
+        Generate a diff file between current and snapshot files.
+        
+        Parameters:
+        -----------
+        current_file_reference : str
+            Reference to the current file in the file_paths dictionary.
+        snapshot_file_reference : str
+            Reference to the snapshot file in the file_paths dictionary.
+        diff_file_reference : str
+            Reference to the diff file in the file_paths dictionary.
+        """
         with open(self.file_paths()[current_file_reference], 'r') as current_file:
             current_text = current_file.readlines()
         with open(self.file_paths()[snapshot_file_reference], 'r') as snapshot_file:
@@ -182,6 +362,9 @@ class Application(Subsystem):
             diff_file.write(diff_text)
     
     def delete_old_snapshots(self):
+        """
+        Delete old user snapshots exceeding the keep_snapshots limit.
+        """
         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))]
@@ -190,6 +373,14 @@ class Application(Subsystem):
                 shutil.rmtree(snapshots.pop(0))
     
     def check_user_input(self):
+        """
+        Perform checks on user input to ensure consistency and uniqueness.
+        
+        Raises:
+        -------
+        ValueError
+            If there are duplicate service names, service IDs, command names, or command subtypes.
+        """
         # 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)):
@@ -215,6 +406,9 @@ class Application(Subsystem):
                 raise ValueError('RCCN-Error: Service \''+service.name+'\' has multiple commands with the same subtype.')
         
     def generate_cargo_toml_file(self):
+        """
+        Generate the Cargo.toml file for the application.
+        """
         with open(self.file_paths()['cargo_toml_template'], 'r') as file:
             cargo_toml_template_text = file.read()
         with open(self.file_paths()['cargo_toml'], 'w') as file:
@@ -222,6 +416,17 @@ class Application(Subsystem):
 
 
 class Service(Subsystem):
+    """
+    A PUS service that belongs to an Application.
+    
+    This class represents a Protocol Utilization Standard (PUS) service, which is a collection of 
+    related functionality within a space application. It extends the Subsystem class of pymdb and provides 
+    functionality for managing commands, telemetry containers, and generating Rust code.
+    
+    Each service has a unique service ID within its parent application and is responsible for
+    organizing related commands and telemetry into logical groups. The class facilitates the 
+    generation of Rust code files for the service: service.rs, command.rs, and telemetry.rs.
+    """
     def __init__(
         self,
         name: str,
@@ -229,6 +434,19 @@ class Service(Subsystem):
         *args,
         **kwargs
     ):
+        """
+        Initialize a new PUS service.
+        
+        Parameters:
+        -----------
+        name : str
+            The name of the service.
+        service_id : int
+            The unique service ID for this service within its parent application.
+        *args, **kwargs
+            Additional arguments and keyword arguments passed to the parent class constructor.
+            A 'system' parameter can be provided if the service is being created directly.
+        """
         self.init_args = args
         self.init_kwargs = kwargs
         self.init_args = args
@@ -243,6 +461,17 @@ class Service(Subsystem):
             self.add_to_application(kwargs['system'])
     
     def add_to_application(self, application):
+        """
+        Add this service to an Application.
+        
+        This method initializes the Service as a Subsystem and sets it as a child
+        of the provided application.
+        
+        Parameters:
+        -----------
+        application : Application
+            The parent application that this service will belong to.
+        """
         if 'system' in self.init_kwargs and isinstance(self.init_kwargs['system'], Application):
             super().__init__(
                 name=self.name,
@@ -257,16 +486,51 @@ class Service(Subsystem):
         self.snapshots = self.system.snapshots
     
     def add_container(self, container):
+        """
+        Add a container to this service.
+        
+        Parameters:
+        -----------
+        container : RCCNContainer
+            The container to add to this service.
+            
+        Raises:
+        -------
+        TypeError
+            If the provided container is not an instance of RCCNContainer.
+        """
         if not isinstance(container, RCCNContainer):
             raise TypeError('Container '+container.name+' is not a RCCNContainer.')
         container.add_to_service(self)
     
     def add_command(self, command):
+        """
+        Add a command to this service.
+        
+        Parameters:
+        -----------
+        command : RCCNCommand
+            The command to add to this service.
+            
+        Raises:
+        -------
+        TypeError
+            If the provided command is not an instance of RCCNCommand.
+        """
         if not isinstance(command, RCCNCommand):
             raise TypeError('Command '+command.name+' is not a RCCNCommand.')
         command.add_to_service(self)
     
     def file_paths(self):
+        """
+        Get the file paths for various files used by this service.
+        
+        Returns:
+        --------
+        dict
+            A dictionary mapping file types to their absolute paths, including
+            source files, generated snapshots, user snapshots, diff files, and templates.
+        """
         paths = {
             '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'),
@@ -289,9 +553,42 @@ class Service(Subsystem):
         return paths
 
     def rccn_commands(self):
+        """
+        Get all RCCNCommand objects belonging to this service, excluding base commands.
+        
+        Returns:
+        --------
+        list
+            A list of RCCNCommand objects that belong to this service but are not
+            named 'base'.
+        """
         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):
+        """
+        Replace template keywords with actual values specific to this service.
+        
+        This method processes the template text, replacing service-specific keywords,
+        including module keywords, variable keywords, and command keywords. It delegates
+        command-specific keyword replacement to each command's find_and_replace_keywords method.
+        
+        Parameters:
+        -----------
+        text : str
+            The template text containing keywords to be replaced.
+        text_modules_path : str
+            The path to the directory containing text module templates.
+            
+        Returns:
+        --------
+        str
+            The processed text with all keywords replaced with their actual values.
+            
+        Raises:
+        -------
+        FileExistsError
+            If a referenced text module file does not exist.
+        """
         # Find and replace service module keywords
         service_module_keywords = get_service_module_keywords(text)
         for service_module_keyword in service_module_keywords:
@@ -326,6 +623,15 @@ class Service(Subsystem):
         return text
     
     def generate_rccn_service_file(self):
+        """
+        Generate the service.rs file for this service.
+        
+        This method creates a diff file (if both current and snapshot files exist),
+        takes a snapshot of user-modified service.rs if snapshots are enabled,
+        generates the new service.rs from the template, takes a snapshot of the 
+        newly generated file, and applies user changes from the diff if rebase_changes
+        is enabled.
+        """
         # Create service.diff file
         if os.path.exists(self.file_paths()['service']) and os.path.exists(self.file_paths()['service_generated_snapshot']):
             os.makedirs(os.path.dirname(self.file_paths()['service_diff']), exist_ok=True)
@@ -346,6 +652,23 @@ class Service(Subsystem):
             os.system('patch '+self.file_paths()['service']+' <  '+self.file_paths()['service_diff'])
     
     def generate_rccn_command_file(self, export_file_dir='.', text_modules_path='./text_modules/command'):
+        """
+        Generate the command.rs file for this service.
+        
+        This method creates a diff file (if both current and snapshot files exist),
+        takes a snapshot of user-modified command.rs if snapshots are enabled,
+        generates the new command.rs from the template only if there are commands
+        in the service, takes a snapshot of the newly generated file, and applies
+        user changes from the diff if rebase_changes is enabled.
+        
+        Parameters:
+        -----------
+        export_file_dir : str, optional
+            The directory where the command.rs file will be exported. Default is current directory.
+        text_modules_path : str, optional
+            The path to the directory containing command text module templates. 
+            Default is './text_modules/command'.
+        """
         # Create command.diff file
         if os.path.exists(self.file_paths()['command']) and os.path.exists(self.file_paths()['command_generated_snapshot']):
             os.makedirs(os.path.dirname(self.file_paths()['command_diff']), exist_ok=True)
@@ -371,10 +694,32 @@ class Service(Subsystem):
             os.system('patch '+self.file_paths()['command']+' <  '+self.file_paths()['command_diff'])
     
     def generate_snapshot(self, current_file_reference, snapshot_file_reference):
+        """
+        Create a snapshot of a file.
+        
+        Parameters:
+        -----------
+        current_file_reference : str
+            Reference to the current file in the file_paths dictionary.
+        snapshot_file_reference : str
+            Reference to the snapshot file in the file_paths dictionary.
+        """
         os.makedirs(os.path.dirname(self.file_paths()[snapshot_file_reference]), exist_ok=True)
         shutil.copyfile(self.file_paths()[current_file_reference], self.file_paths()[snapshot_file_reference])
         
     def generate_diff_file(self, current_file_reference, snapshot_file_reference, diff_file_reference):
+        """
+        Generate a diff file between current and snapshot files.
+        
+        Parameters:
+        -----------
+        current_file_reference : str
+            Reference to the current file in the file_paths dictionary.
+        snapshot_file_reference : str
+            Reference to the snapshot file in the file_paths dictionary.
+        diff_file_reference : str
+            Reference to the diff file in the file_paths dictionary.
+        """
         with open(self.file_paths()[current_file_reference], 'r') as current_file:
             current_text = current_file.readlines()
         with open(self.file_paths()[snapshot_file_reference], 'r') as snapshot_file:
@@ -385,12 +730,26 @@ class Service(Subsystem):
             diff_file.write(diff_text)
     
     def generate_mod_file(self):
+        """
+        Generate the mod.rs file for this service.
+        
+        This file serves as the module definition file for the service in Rust,
+        defining what's exported from the service module.
+        """
         with open(self.file_paths()['mod_template'], 'r') as file:
             mod_template_text = file.read()
         with open(self.file_paths()['mod'], 'w') as file:
             file.write(mod_template_text)
     
     def generate_telemetry_file(self):
+        """
+        Generate the telemetry.rs file for this service.
+        
+        This method creates a diff file (if both current and snapshot files exist),
+        takes a snapshot of user-modified telemetry.rs if snapshots are enabled,
+        generates the new telemetry.rs from the template, takes a snapshot of the newly 
+        generated file, and applies user changes from the diff if rebase_changes is enabled.
+        """
         # Create telemetry.diff file
         if os.path.exists(self.file_paths()['telemetry']) and os.path.exists(self.file_paths()['telemetry_generated_snapshot']):
             os.makedirs(os.path.dirname(self.file_paths()['telemetry_diff']), exist_ok=True)
@@ -411,6 +770,14 @@ class Service(Subsystem):
             os.system('patch '+self.file_paths()['telemetry']+' <  '+self.file_paths()['telemetry_diff'])
     
     def generate_rust_telemetry_definition(self):
+        """
+        Generate Rust code definitions for all telemetry containers in this service.
+        
+        Returns:
+        --------
+        str
+            A string containing Rust struct definitions for all telemetry containers.
+        """
         telemetry_definition_text = ''
         for container in self.containers:
             if not isinstance(container, RCCNContainer):
@@ -437,6 +804,38 @@ class Service(Subsystem):
                 Union[TransmissionConstraint, Sequence[TransmissionConstraint]] | None
             ) = None,
     ):
+        """
+        Create a new command and add it to this service.
+        
+        Parameters:
+        -----------
+        name : str
+            The name of the command.
+        aliases : Mapping[str, str], optional
+            Alternative names for the command, keyed by namespace.
+        short_description : str, optional
+            A short description of the command.
+        long_description : str, optional
+            A longer description of the command.
+        extra : Mapping[str, str], optional
+            Arbitrary information about the command, keyed by name.
+        abstract : bool, optional
+            Whether this command is abstract. Default is False.
+        base : Command | str, optional
+            The base command or reference to a base command.
+        assignments : Mapping[str, Any], optional
+            Command assignments.
+        arguments : Sequence[Argument], optional
+            The arguments for this command.
+        entries : Sequence[CommandEntry], optional
+            Command entries.
+        level : CommandLevel, optional
+            The command level. Default is CommandLevel.NORMAL.
+        warning_message : str, optional
+            Warning message to display when executing this command.
+        constraint : Union[TransmissionConstraint, Sequence[TransmissionConstraint]], optional
+            Transmission constraints for this command.
+        """
         Command(
             name=name,
             system=self,
@@ -455,10 +854,29 @@ class Service(Subsystem):
         ) 
     
     def rccn_container(self):
+        """
+        Get all RCCNContainer objects belonging to this service.
+        
+        Returns:
+        --------
+        list
+            A list of RCCNContainer objects that belong to this service.
+        """
         return [container for container in self.containers if isinstance(container, RCCNContainer)]
 
 
 class RCCNCommand(Command):
+    """
+    A Protocol Utilization Standard (PUS) command that belongs to a Service.
+    
+    This class extends the Command class and provides specialized functionality for 
+    generating Rust code for commands within a PUS service. RCCNCommand manages command
+    subtype assignment, struct name generation for arguments, and handling of base commands.
+    
+    Each RCCNCommand automatically gets assigned to its parent Service's APID (Application 
+    Process ID) and a unique subtype within that service. It can generate Rust code for
+    command structs and implements keyword replacement for templates.
+    """
     def __init__(
         self,
         name: str,
@@ -479,6 +897,41 @@ class RCCNCommand(Command):
         ) = None,
         **kwargs
     ):
+        """
+        Initialize a new PUS command.
+        
+        Parameters:
+        -----------
+        name : str
+            The name of the command.
+        aliases : Mapping[str, str], optional
+            Alternative names for the command, keyed by namespace.
+        short_description : str, optional
+            A short description of the command.
+        long_description : str, optional
+            A longer description of the command.
+        extra : Mapping[str, str], optional
+            Arbitrary information about the command, keyed by name.
+        abstract : bool, optional
+            Whether this command is abstract. Default is False.
+        base : Command | str, optional
+            The base command or reference to a base command.
+        assignments : Mapping[str, Any], optional
+            Command assignments, including the subtype.
+        arguments : Sequence[Argument], optional
+            The arguments for this command.
+        entries : Sequence[CommandEntry], optional
+            Command entries.
+        level : CommandLevel, optional
+            The command level. Default is CommandLevel.NORMAL.
+        warning_message : str, optional
+            Warning message to display when executing this command.
+        constraint : Union[TransmissionConstraint, Sequence[TransmissionConstraint]], optional
+            Transmission constraints for this command.
+        **kwargs
+            Additional keyword arguments that may include 'system' to specify
+            which service this command belongs to.
+        """
         self.init_args = ()
         self.init_kwargs = {
             'name': name,
@@ -502,6 +955,25 @@ class RCCNCommand(Command):
             self.add_to_service(base.system)
 
     def add_to_service(self, service):
+        """
+        Add this command to a Service.
+        
+        This method handles the initialization of the command as part of a service,
+        setting up base commands if needed, and assigning a subtype if one isn't
+        explicitly provided.
+        
+        Parameters:
+        -----------
+        service : Service
+            The service this command will belong to.
+            
+        Notes:
+        ------
+        - If no base command is specified and the service has no base command,
+          a standard base command will be created automatically
+        - If no subtype is provided, a unique one will be assigned automatically
+        - The command's APID is automatically set to match the service's application APID
+        """
         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(
@@ -530,6 +1002,31 @@ class RCCNCommand(Command):
 
     
     def find_and_replace_keywords(self, text, text_modules_path):
+        """
+        Replace template keywords with actual command values.
+        
+        This method processes template text, replacing command-specific keywords with 
+        the actual values from this command. It handles:
+        1. Command module keywords - references to external template files
+        2. Command variable keywords - specific properties of this command
+        
+        Parameters:
+        -----------
+        text : str
+            Template text containing keywords to be replaced.
+        text_modules_path : str
+            Path to the directory containing text module templates.
+            
+        Returns:
+        --------
+        str
+            The processed text with all command keywords replaced with their actual values.
+            
+        Raises:
+        -------
+        FileExistsError
+            If a referenced command module file does not exist.
+        """
         # Find and replace command module keywords
         command_module_keywords = get_command_module_keywords(text)
         for command_module_keyword in command_module_keywords:
@@ -559,9 +1056,30 @@ class RCCNCommand(Command):
         return text
     
     def user_snapshot_path(self):
+        """
+        Get the path for user snapshots with current timestamp.
+        
+        Returns:
+        --------
+        str
+            The path where user snapshots are stored.
+        """
         return os.path.join(self.snapshot_directory, 'user', datetime.datetime.now().strftime("%Y-%m-%d_%H-%M-%S"))
 
     def struct_definition(self):
+        """
+        Generate a Rust struct definition for this command's arguments.
+        
+        This method creates a BitStruct definition in Rust for the command's arguments,
+        with appropriate documentation comments. If the command has no arguments,
+        an empty string is returned.
+        
+        Returns:
+        --------
+        str
+            A string containing the Rust code for the struct definition, or an empty
+            string if the command has no arguments.
+        """
         struct_definition_text = ""
         if len(self.arguments) == 0:
             return ''
@@ -582,6 +1100,18 @@ class RCCNCommand(Command):
 
 
 class RCCNContainer(Container):
+    """
+    A Protocol Utilization Standard (PUS) telemetry container that belongs to a Service.
+    
+    This class extends the Container class and provides specialized functionality for 
+    generating Rust code for telemetry containers within a PUS service. RCCNContainer
+    manages container type and subtype assignment, condition expressions, and handles
+    the generation of Rust struct definitions for telemetry data.
+    
+    Each RCCNContainer is automatically assigned to its parent Service's service ID (type)
+    and receives a unique subtype within that service. It supports various parameter types
+    for telemetry data collection and provides methods to add these parameters to the container.
+    """
     def __init__(
         self,
         base="/PUS/pus-tm", 
@@ -600,6 +1130,45 @@ class RCCNContainer(Container):
         rate: float | None = None,
         hint_partition: bool = False,
     ):
+        """
+        Initialize a new PUS telemetry container.
+        
+        Parameters:
+        -----------
+        base : str, optional
+            Base path for the telemetry packet. Default is "/PUS/pus-tm".
+        subtype : int, optional
+            Subtype for the container. If not provided, a unique value will be assigned.
+        system : System, optional
+            The system (usually a Service) this container belongs to.
+        name : str
+            The name of the container. Required.
+        entries : Sequence[ParameterEntry | ContainerEntry], optional
+            Parameter or container entries for this container.
+        abstract : bool, optional
+            Whether this container is abstract. Default is False.
+        condition : Expression, optional
+            Condition expression for when this container should be used.
+        aliases : Mapping[str, str], optional
+            Alternative names for the container, keyed by namespace.
+        short_description : str, optional
+            A short description of the container.
+        long_description : str, optional
+            A longer description of the container.
+        extra : Mapping[str, str], optional
+            Arbitrary information about the container, keyed by name.
+        bits : int, optional
+            Size in bits.
+        rate : float, optional
+            Expected rate of reception in Hz.
+        hint_partition : bool, optional
+            Hint to partition this container. Default is False.
+            
+        Raises:
+        -------
+        ValueError
+            If name is not provided.
+        """
         self.base = base
         self.subtype = subtype
         self.init_kwargs = {
@@ -626,6 +1195,24 @@ class RCCNContainer(Container):
             self.add_to_service(system)
 
     def add_to_service(self, service):
+        """
+        Add this container to a Service.
+        
+        This method handles the initialization of the container as part of a service,
+        setting up condition expressions for type and subtype, and managing the container's
+        integration with the service.
+        
+        The method performs several key operations:
+        1. Sets the container's type to match the service ID
+        2. Extracts type/subtype from existing condition expressions if present
+        3. Creates appropriate condition expressions for the container
+        4. Assigns a unique subtype if one isn't explicitly provided
+        
+        Parameters:
+        -----------
+        service : Service
+            The service this container will belong to.
+        """
         self.type = service.service_id
         condition_type = None
         condition_subtype = None
@@ -665,6 +1252,20 @@ class RCCNContainer(Container):
             super().__init__(system=service, **self.init_kwargs)
 
     def generate_rccn_telemetry(self):
+        """
+        Generate Rust code for this telemetry container.
+        
+        This method creates a Rust struct definition for the container, including:
+        1. Documentation comments from the container's short_description
+        2. ServiceTelemetry and BitStruct derive attributes
+        3. Subtype attribute if a subtype is defined
+        4. All parameter entries from the container
+        
+        Returns:
+        --------
+        str
+            A string containing the complete Rust struct definition for this container.
+        """
         rccn_telemetry_text = ""
         if hasattr(self, 'short_description') and self.short_description is not None:
             rccn_telemetry_text += "/// "+str(self.short_description)+"\n"
@@ -682,7 +1283,7 @@ class RCCNContainer(Container):
         rccn_telemetry_text += append        
         return rccn_telemetry_text
     
-    def add_integer_parameter(
+    def add_integer_parameter_entry(
             self,
             name: str,
             signed: bool = True,
@@ -702,8 +1303,50 @@ class RCCNContainer(Container):
             alarm: ThresholdAlarm | None = None,
             context_alarms: Sequence[ThresholdContextAlarm] | None = None,
      ):
-        int_parameter = IntegerParameter(
-            system=self,
+        """
+        Add an integer parameter to this container.
+        
+        This method creates an integer parameter and adds it as an entry to this container.
+        
+        Parameters:
+        -----------
+        name : str
+            The name of the parameter.
+        signed : bool, optional
+            Whether the integer is signed. Default is True.
+        bits : int, optional
+            Number of bits. Default is 32.
+        minimum : int, optional
+            Minimum valid value.
+        maximum : int, optional
+            Maximum valid value.
+        aliases : Mapping[str, str], optional
+            Alternative names for the parameter, keyed by namespace.
+        data_source : DataSource, optional
+            Source of the parameter value. Default is DataSource.TELEMETERED.
+        initial_value : Any, optional
+            Initial value for this parameter.
+        persistent : bool, optional
+            Whether this parameter's value should be persisted. Default is True.
+        short_description : str, optional
+            A short description of the parameter.
+        long_description : str, optional
+            A longer description of the parameter.
+        extra : Mapping[str, str], optional
+            Arbitrary information about the parameter, keyed by name.
+        units : str, optional
+            Units of this parameter.
+        encoding : Encoding, optional
+            Encoding information for this parameter.
+        calibrator : Calibrator, optional
+            Calibration information for this parameter.
+        alarm : ThresholdAlarm, optional
+            Alarm conditions for this parameter.
+        context_alarms : Sequence[ThresholdContextAlarm], optional
+            Context-dependent alarm conditions for this parameter.
+        """
+        parameter = IntegerParameter(
+            system=self.system,
             name=name,
             signed=signed,
             bits=bits,
@@ -722,4 +1365,531 @@ class RCCNContainer(Container):
             alarm=alarm,
             context_alarms=context_alarms
         )
-        self.entries.append(int_parameter)
+        self.entries.append(ParameterEntry(parameter=parameter))
+
+    def add_enumerated_parameter_entry( 
+        self,
+        name: str,
+        choices: Choices,
+        alarm: EnumerationAlarm | None = None,
+        context_alarms: Sequence[EnumerationContextAlarm] | 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,
+    ):
+        """
+        Add an enumerated parameter to this container.
+        
+        This method creates an enumerated parameter with predefined choices and adds it
+        as an entry to this container.
+        
+        Parameters:
+        -----------
+        name : str
+            The name of the parameter.
+        choices : Choices
+            The enumeration choices for this parameter.
+        alarm : EnumerationAlarm, optional
+            Alarm conditions for this parameter.
+        context_alarms : Sequence[EnumerationContextAlarm], optional
+            Context-dependent alarm conditions for this parameter.
+        aliases : Mapping[str, str], optional
+            Alternative names for the parameter, keyed by namespace.
+        data_source : DataSource, optional
+            Source of the parameter value. Default is DataSource.TELEMETERED.
+        initial_value : Any, optional
+            Initial value for this parameter.
+        persistent : bool, optional
+            Whether this parameter's value should be persisted. Default is True.
+        short_description : str, optional
+            A short description of the parameter.
+        long_description : str, optional
+            A longer description of the parameter.
+        extra : Mapping[str, str], optional
+            Arbitrary information about the parameter, keyed by name.
+        units : str, optional
+            Units of this parameter.
+        encoding : Encoding, optional
+            Encoding information for this parameter.
+        """
+        parameter = EnumeratedParameter(
+            system = self.system,
+            name=name,
+            choices=choices,
+            alarm=alarm,
+            context_alarms=context_alarms,
+            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
+        )
+        self.entries.append(ParameterEntry(parameter=parameter))
+        
+    def add_boolean_parameter_entry(
+        self,
+        name: str,
+        zero_string_value: str = "False",
+        one_string_value: str = "True",
+        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,
+    ):
+        """
+        Add a boolean parameter to this container.
+        
+        This method creates a boolean parameter and adds it as an entry to this container.
+        
+        Parameters:
+        -----------
+        name : str
+            The name of the parameter.
+        zero_string_value : str, optional
+            String representation of the boolean value 'false'. Default is "False".
+        one_string_value : str, optional
+            String representation of the boolean value 'true'. Default is "True".
+        aliases : Mapping[str, str], optional
+            Alternative names for the parameter, keyed by namespace.
+        data_source : DataSource, optional
+            Source of the parameter value. Default is DataSource.TELEMETERED.
+        initial_value : Any, optional
+            Initial value for this parameter.
+        persistent : bool, optional
+            Whether this parameter's value should be persisted. Default is True.
+        short_description : str, optional
+            A short description of the parameter.
+        long_description : str, optional
+            A longer description of the parameter.
+        extra : Mapping[str, str], optional
+            Arbitrary information about the parameter, keyed by name.
+        units : str, optional
+            Units of this parameter.
+        encoding : Encoding, optional
+            Encoding information for this parameter.
+        """
+        parameter = BooleanParameter(
+            system=self.system,
+            name=name,
+            zero_string_value=zero_string_value,
+            one_string_value=one_string_value,
+            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
+        )
+        self.entries.append(ParameterEntry(parameter=parameter))
+
+    def add_float_parameter_entry(
+        self,
+        name: str,
+        bits: Literal[32, 64] = 32,
+        minimum: float | None = None,
+        minimum_inclusive: bool = True,
+        maximum: float | None = None,
+        maximum_inclusive: bool = True,
+        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,
+    ):
+        """
+        Add a floating-point parameter to this container.
+        
+        This method creates a float parameter and adds it as an entry to this container.
+        
+        Parameters:
+        -----------
+        name : str
+            The name of the parameter.
+        bits : Literal[32, 64], optional
+            Number of bits, either 32 (float) or 64 (double). Default is 32.
+        minimum : float, optional
+            Minimum valid value.
+        minimum_inclusive : bool, optional
+            Whether the minimum value is inclusive. Default is True.
+        maximum : float, optional
+            Maximum valid value.
+        maximum_inclusive : bool, optional
+            Whether the maximum value is inclusive. Default is True.
+        aliases : Mapping[str, str], optional
+            Alternative names for the parameter, keyed by namespace.
+        data_source : DataSource, optional
+            Source of the parameter value. Default is DataSource.TELEMETERED.
+        initial_value : Any, optional
+            Initial value for this parameter.
+        persistent : bool, optional
+            Whether this parameter's value should be persisted. Default is True.
+        short_description : str, optional
+            A short description of the parameter.
+        long_description : str, optional
+            A longer description of the parameter.
+        extra : Mapping[str, str], optional
+            Arbitrary information about the parameter, keyed by name.
+        units : str, optional
+            Units of this parameter.
+        encoding : Encoding, optional
+            Encoding information for this parameter.
+        calibrator : Calibrator, optional
+            Calibration information for this parameter.
+        alarm : ThresholdAlarm, optional
+            Alarm conditions for this parameter.
+        context_alarms : Sequence[ThresholdContextAlarm], optional
+            Context-dependent alarm conditions for this parameter.
+        """
+        parameter = FloatParameter(
+            system=self.system,
+            name=name,
+            bits=bits,
+            minimum=minimum,
+            minimum_inclusive=minimum_inclusive,
+            maximum=maximum,
+            maximum_inclusive=maximum_inclusive,
+            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(ParameterEntry(parameter=parameter))
+    
+    def add_string_parameter_entry(
+        self,
+        name: str,
+        min_length: int | None = None,
+        max_length: 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,
+    ):
+        """
+        Add a string parameter to this container.
+        
+        This method creates a string parameter and adds it as an entry to this container.
+        
+        Parameters:
+        -----------
+        name : str
+            The name of the parameter.
+        min_length : int, optional
+            Minimum valid length of the string.
+        max_length : int, optional
+            Maximum valid length of the string.
+        aliases : Mapping[str, str], optional
+            Alternative names for the parameter, keyed by namespace.
+        data_source : DataSource, optional
+            Source of the parameter value. Default is DataSource.TELEMETERED.
+        initial_value : Any, optional
+            Initial value for this parameter.
+        persistent : bool, optional
+            Whether this parameter's value should be persisted. Default is True.
+        short_description : str, optional
+            A short description of the parameter.
+        long_description : str, optional
+            A longer description of the parameter.
+        extra : Mapping[str, str], optional
+            Arbitrary information about the parameter, keyed by name.
+        units : str, optional
+            Units of this parameter.
+        encoding : Encoding, optional
+            Encoding information for this parameter.
+        """
+        parameter = StringParameter(
+            system=self.system,
+            name=name,
+            min_length=min_length,
+            max_length=max_length,
+            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
+        )
+        self.entries.append(ParameterEntry(parameter=parameter))
+
+    def add_binary_parameter_entry(
+        self,
+        name: str,
+        min_length: int | None = None,
+        max_length: 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,
+    ):
+        """
+        Add a binary parameter to this container.
+        
+        This method creates a binary parameter and adds it as an entry to this container.
+        
+        Parameters:
+        -----------
+        name : str
+            The name of the parameter.
+        min_length : int, optional
+            Minimum valid length of the binary data in bytes.
+        max_length : int, optional
+            Maximum valid length of the binary data in bytes.
+        aliases : Mapping[str, str], optional
+            Alternative names for the parameter, keyed by namespace.
+        data_source : DataSource, optional
+            Source of the parameter value. Default is DataSource.TELEMETERED.
+        initial_value : Any, optional
+            Initial value for this parameter.
+        persistent : bool, optional
+            Whether this parameter's value should be persisted. Default is True.
+        short_description : str, optional
+            A short description of the parameter.
+        long_description : str, optional
+            A longer description of the parameter.
+        extra : Mapping[str, str], optional
+            Arbitrary information about the parameter, keyed by name.
+        units : str, optional
+            Units of this parameter.
+        encoding : Encoding, optional
+            Encoding information for this parameter.
+        """
+        parameter = BinaryParameter(
+            system=self.system,
+            name=name,
+            min_length=min_length,
+            max_length=max_length,
+            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
+        )
+        self.entries.append(ParameterEntry(parameter=parameter))
+
+    def add_absolute_time_parameter_entry(
+        self,
+        name: str,
+        reference: Union[Epoch, datetime.datetime, AbsoluteTimeParameter],
+        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: TimeEncoding | None = None,
+    ):
+        """
+        Add an absolute time parameter to this container.
+        
+        This method creates an absolute time parameter and adds it as an entry to this container.
+        
+        Parameters:
+        -----------
+        name : str
+            The name of the parameter.
+        reference : Union[Epoch, datetime.datetime, AbsoluteTimeParameter]
+            Reference time (epoch) for this parameter.
+        aliases : Mapping[str, str], optional
+            Alternative names for the parameter, keyed by namespace.
+        data_source : DataSource, optional
+            Source of the parameter value. Default is DataSource.TELEMETERED.
+        initial_value : Any, optional
+            Initial value for this parameter.
+        persistent : bool, optional
+            Whether this parameter's value should be persisted. Default is True.
+        short_description : str, optional
+            A short description of the parameter.
+        long_description : str, optional
+            A longer description of the parameter.
+        extra : Mapping[str, str], optional
+            Arbitrary information about the parameter, keyed by name.
+        units : str, optional
+            Units of this parameter.
+        encoding : TimeEncoding, optional
+            Encoding information for this time parameter.
+        """
+        parameter = AbsoluteTimeParameter(
+            system=self,
+            name=name,
+            reference=reference,
+            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
+        )
+        self.entries.append(ParameterEntry(parameter=parameter))
+
+    def add_aggregate_parameter_entry(
+        self,
+        name: str,
+        members: Sequence[Member],
+        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,
+        encoding: Encoding | None = None,
+    ):
+        """
+        Add an aggregate parameter to this container.
+        
+        This method creates an aggregate parameter (a parameter composed of multiple members)
+        and adds it as an entry to this container.
+        
+        Parameters:
+        -----------
+        name : str
+            The name of the parameter.
+        members : Sequence[Member]
+            The members that make up this aggregate parameter.
+        aliases : Mapping[str, str], optional
+            Alternative names for the parameter, keyed by namespace.
+        data_source : DataSource, optional
+            Source of the parameter value. Default is DataSource.TELEMETERED.
+        initial_value : Any, optional
+            Initial value for this parameter.
+        persistent : bool, optional
+            Whether this parameter's value should be persisted. Default is True.
+        short_description : str, optional
+            A short description of the parameter.
+        long_description : str, optional
+            A longer description of the parameter.
+        extra : Mapping[str, str], optional
+            Arbitrary information about the parameter, keyed by name.
+        encoding : Encoding, optional
+            Encoding information for this parameter.
+        """
+        parameter = AggregateParameter(
+            system=self.system,
+            name=name,
+            members=members,
+            aliases=aliases,
+            data_source=data_source,
+            initial_value=initial_value,
+            persistent=persistent,
+            short_description=short_description,
+            long_description=long_description,
+            extra=extra,
+            encoding=encoding
+        )
+        self.entries.append(ParameterEntry(parameter=parameter))
+
+    def add_array_parameter_entry(
+        self,
+        name: str,
+        data_type: DataType,
+        length: int | DynamicInteger,
+        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,
+        encoding: Encoding | None = None,
+    ):
+        """
+        Add an array parameter to this container.
+        
+        This method creates an array parameter (a parameter containing multiple elements
+        of the same type) and adds it as an entry to this container.
+        
+        Parameters:
+        -----------
+        name : str
+            The name of the parameter.
+        data_type : DataType
+            The data type of the array elements.
+        length : int | DynamicInteger
+            The length of the array, either as a fixed integer or a dynamic reference.
+        aliases : Mapping[str, str], optional
+            Alternative names for the parameter, keyed by namespace.
+        data_source : DataSource, optional
+            Source of the parameter value. Default is DataSource.TELEMETERED.
+        initial_value : Any, optional
+            Initial value for this parameter.
+        persistent : bool, optional
+            Whether this parameter's value should be persisted. Default is True.
+        short_description : str, optional
+            A short description of the parameter.
+        long_description : str, optional
+            A longer description of the parameter.
+        extra : Mapping[str, str], optional
+            Arbitrary information about the parameter, keyed by name.
+        encoding : Encoding, optional
+            Encoding information for this parameter.
+        """
+        parameter = ArrayParameter(
+            system=self.system,
+            name=name,
+            data_type=data_type,
+            length=length,
+            aliases=aliases,
+            data_source=data_source,
+            initial_value=initial_value,
+            persistent=persistent,
+            short_description=short_description,
+            long_description=long_description,
+            extra=extra,
+            encoding=encoding
+        )
+        self.entries.append(ParameterEntry(parameter=parameter))