Create a generic Python class to be used as an atomic model within a DEVS environment using the DEVSimpy tool. The class should follow these characteristics and structure, based on the model type. The tabulation wil be made with a \t. I don't want you to write anything else than the actual class and the import.

### Types of Atomic Models

1. **Generator Model:**
   - The generator model only sends data while alternating states; it does not have an external transition (`extTransition`) since it does not receive data.

2. **Default Model:**
   - This model receives data via external transitions (`extTransition`) and sends data via `outputFnc`. It will use both `extTransition` and `outputFnc` methods.

3. **Viewer or Collector Models:**
   - Viewer and collector models only gather data without sending it. Viewers display data visually (e.g., using Turtle or other tools), while collectors log data to a file.
   - These models do not need an `outputFnc` since they only retrieve data.

### General Class Structure and Functions

1. **Required Imports:**
   
   from DomainInterface.DomainBehavior import DomainBehavior
   from DomainInterface.Object import Message
   

2. **Inheritance:** The class should inherit from `DomainBehavior`.

3. **Constructor (`__init__`):**
   - Accept customizable external parameters with default values to configure the model’s behavior.
   - Initialize any necessary attributes within the class, just like a standard Python constructor.
   - Important: Use `self.initPhase()` **only in the constructor** to define the initial state and corresponding duration. Do not use `initPhase` in transition functions.

4. **External Transition (`extTransition`):**
   - Executed when the model receives a message via its input ports. Only applicable to models that handle incoming data, such as the default model.
   - For each port in `self.IPorts`, use `self.peek(port, *args)` to retrieve the message.
   - Based on the message content, the model can take actions such as changing state, executing specific logic, or remaining in the current state.
   - Use `self.holdIn()` to set the new state and delay until the next transition as needed. **Do not use `initPhase` here.**

5. **Output Function (`outputFnc`):**
   - Sends messages via output ports, only required for models that transmit data, like the default model.
   - Structure the message using the `Message` class to transmit necessary information according to the model’s logic.

6. **Internal Transition (`intTransition`):**
   - Executed when the internal transition time expires, based on the model’s current state.
   - This transition may include changing the state, performing actions, or maintaining the current state.
   - To modify the model’s state during an internal transition, **use `self.holdIn("State_Name", timeUntilNextTransition)`**.

7. **Retrieve Current State (`getState`):**
   - Use `self.getState()` to retrieve the model’s current state at any point in the code. This can help conditionally control actions based on the model’s state.

8. **Time Advance (`timeAdvance`):**
   - Controls time advancement in the simulation by returning `self.getSigma()` for the time until the next transition.

Sample Class Structure:

from DomainInterface.DomainBehavior import DomainBehavior
from DomainInterface.Object import Message

class ModelName(DomainBehavior):
    ''' DEVS Class for a generic model '''

    def __init__(self, param1=10, param2="default"):
        ''' Constructor '''
        DomainBehavior.__init__(self)
        self.param1 = param1
        self.param2 = param2
        # Initialize any other required attributes
        self.initPhase('INITIAL_STATE', INFINITY)  # Customizable initial state and duration

    def extTransition(self, *args):
        ''' DEVS external transition function (only for models that receive data) '''
        for port in self.IPorts:
            msg = self.peek(port, *args)
            if msg:
                # State change or action logic based on the message
                current_state = self.getState()  # Example usage of getState()
                pass  # Customize based on intended behavior
         
         return self.getState()

    def outputFnc(self):
        ''' DEVS output function (only for models that send data) '''
        # Create and return a structured message for output ports
        return self.poke(self.OPorts[0], Message("Message content", self.timeNext))

    def intTransition(self):
        ''' DEVS internal transition function '''
        current_state = self.getState()  # Example usage of getState()
        # Use self.holdIn() to change state or set an internal delay
        pass  # Customize as needed
        
        return self.getState()

    def timeAdvance(self):
        ''' DEVS Time Advance function '''
        return self.getSigma()
