feat: Add atomic model generation using JSON and iterative code generation

Author: liviagr

devsimpy/AI/functions_prompt/ext_transition.txt

@@ -0,0 +1,61 @@
+**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.
+   - Use `self.peek(self.IPorts[0], *args) to retrieve a message from a port. Change the index to peek at a specific port.
+    *Example : retrieve a message for every ports :*
+    for port in self.IPorts:
+        msg = self.peek(port, *args)
+
+   - `Message` is a class with the following variables : `value` which is the content of the message, and `time` representing the simulation time it was sent.
+   - 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
+   - the line **`return self.getState()`** is required
+
+
+**Handle and change state: **
+    - 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.
+   - Use `self.phaseIs()` to test if the model's current state name is equal to the provided string. Example : `if self.phaseIs("State_Name"):`.
+   - Use `self.getStatus()` to get the model's current state name. Use this if only the current state name is needed.
+
+**Example: the model has at least one input port**
+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()
+            # Customize based on intended behavior
+        
+        return self.getState()
+
+
+**Example: The model doesn't have any input ports**
+def extTransition(self, *args):
+	''' DEVS external transition function (only for models that receive data) '''
+	pass
+
+
+## Steps
+1. Use the number of input ports to identify if the function is necessary
+2. Use the 'parameters' field to add the eventually needed parameters.
+3. Use the 'description' and 'input_ports' fields to infer if you need to peek at every ports or only a specific one.
+4. Use the information in the 'states' array when using `self.holdIn()`. If the 'time' field is a string, assume that a class variable has been created. For example : `self.holdIn("state",self.variable_name)`.
+*Exception:* if the time is marked as 'infinity', use it directly, as a constant, without the quotes.
+Example : 
+"states": [
+      { "name": "IDLE", "time": "INFINITY"},
+      { "name": "SEND", "time": "duration"},
+      { "name": "GENERATE", "time": 0}
+    ],
+Where :
+- INFINITY represents the DEVSimPy constant
+- period, or any other string, represents a class variable
+- 0, or any other number, directly represent the state duration
+is used :
+- `self.holdIn("IDLE",INFINITY)`
+- `self.holdIn("SEND",self.duration)`
+- `self.holdIn("GENERATE",0)`
+5. Except told otherwise, there is no need to check the state before changing it.
+6. Only use the json's data value, the keys and structure must not appear in the code.
+7. Assume that every variable in 'model_properties' has been initialized and can be used directly, with the provided type and value.
+8. the function self.peek() should always be present if the function is needed.

devsimpy/AI/functions_prompt/init_function.txt

@@ -0,0 +1,39 @@
+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()` to define the initial state and corresponding duration.
+   - The ports aren't initialized here.
+
+
+**Example:**
+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
+
+
+## Steps
+1. Include the required imports
+2. Use the 'model_name' field to complete de class name.
+3. Initialize the needed variables (informations in the 'model_properties' array : a dictionary represents all the needed information for one variable). Only put the variables in the constructor parameters if they are in the 'parameters' field of the function, or if stated directly, else, only initialize them in the function's body. Some may be present in the 'model_description', you can add them too.
+4. Add additional imports if they seem relevant or necessary.
+5. Use the 'initial_state' field to get the name and time for the self.initPhase() function.
+6. You can write additional code to answer the 'description' request.
+7. Only output the imports, class declaration and __init__().

devsimpy/AI/functions_prompt/int_transition.txt

@@ -0,0 +1,51 @@
+**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)`**.
+   - `timeUntilNextTransition` can directly be a number or a variable
+   - the line **`return self.getState()`** is required
+
+
+**Handle and change state: **
+    - 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.
+   - Use `self.phaseIs()` to test if the model's current state name is equal to the provided string. Example : `if self.phaseIs("State_Name"):`.
+   - Use `self.getStatus()` to get the model's current state name. Use this if only the current state name is needed.
+
+
+**Example: **
+
+ 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
+	# Customize as needed
+	
+	return self.getState()
+
+
+## Steps 
+1. Use the 'parameters' field to add the eventual needed parameters.
+2. Write code to follow the 'description' field.
+3. Check if you need to directly access the state or only change it. In the second case, directly use `holdIn()`
+4. Pay attention to how you need to access the state : 
+    - the full state object (getState())
+    - only the name
+5. Use the information in the 'states' array when using `self.holdIn()`. If the 'time' is a string, assume that a class variable has been created. For example : `self.holdIn("state",self.variable_name)`.
+Example : 
+JSON states array :
+"states": [
+      { "name": "IDLE", "time": "INFINITY"},
+      { "name": "SEND", "time": "duration"},
+      { "name": "GENERATE", "time": 0}
+    ],
+Where :
+- INFINITY represents the DEVSimPy constant
+- period, or any other string, represents a class variable
+- 0, or any other number, directly represent the state duration
+is used in code :
+- `self.holdIn("IDLE",INFINITY)`
+- `self.holdIn("SEND",self.duration)`
+- `self.holdIn("GENERATE",0)`
+*Exception:* if the time is marked as 'INFINITY', use it directly, as a constant (without the quotes).
+6. Only use the json's data value, the keys and structure must not appear in the code.
+7. Assume that every variable in 'model_properties' has been initialized and can be used directly, with the provided type and value.

devsimpy/AI/functions_prompt/output_function.txt

@@ -0,0 +1,32 @@
+**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. This class has two attributes : `value` which is the content of the message, and `time` representing the simulation time it was sent.
+   - Use the `self.poke(self.OPorts[0], Message("Message content", self.timeNext))` to send the message.
+   **self.poke needs to be a return**
+
+
+**Handle state: **
+    - 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.
+   - Use `self.phaseIs()` to test if the model's current state name is equal to the provided string. Example : `if self.phaseIs("State_Name"):`.
+   - Use `self.getStatus()` to get the model's current state name. Use this if only the current state name is needed.
+
+**Example: if the model has at least one output port**
+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))
+
+**Example: if the model doesn't have an output port**
+def outputFnc(self):
+	''' DEVS output function (only for models that send data) '''
+	pass
+
+
+## Steps
+1. Use the number of output ports to identify if the function is necessary
+2. Use the 'parameters' field to add the eventual needed parameters.
+3. Follow the 'description' field to write the needed code.
+4. Use the 'description' field to understand which message needs to be sent.
+5. Use the 'description' and 'output_ports' fields to infer if one or multiple ports need to send the message.
+6. Assume that every variable in 'class_variables' has been initialized.
+7. Always return the self.poke result if the function is needed.

devsimpy/AI/functions_prompt/time_advance.txt

@@ -0,0 +1,10 @@
+**Time Advance (`timeAdvance`):**
+   - Controls time advancement in the simulation by returning `self.getSigma()` for the time until the next transition.
+
+**Example:**
+def timeAdvance(self):
+	''' DEVS Time Advance function '''
+	return self.getSigma()
+
+## Steps
+1. Unless the 'description' and 'parameters' fields are specified, you can just return the provided example.

devsimpy/AI/json_gen_prompt.txt

@@ -0,0 +1,16 @@
+You are an expert in DEVS modeling. The user input describes different characteristics of a DEVS model, return them as a json.
+
+Here is an explanation about how some fields work :
+- "states" : each state has a "name" and is held for a certain "time". The time can correspond to a class_variable. In this case, use the name provided.
+- "model_description" should be a short paragraph explaining the actions the model needs to do. It can be directly paraphrased from the user's input.
+- "initial_state" should correspond to one of the entry in the "states" array.
+- "model_properties" represent all the properties either described by the user, or judged as necessary. If the property can have multiple value (like enum, array, list) then use an array to represent all the possibilities.
+- "parameters" are a function parameters in a coding sense. It represents the additional parameters (like a constructor variables). If a variable is in the model_properties, it doesn't need to be put in parameters.
+
+1. Identify the model's main goal.
+2. Identify the properties (a property can't be a possible function)
+3. Identify the state(s) : their name and time.
+4. Make sure the "initial_state" corresponds to a "states" entry
+5. Only put parameters in the function is they are not "model_properties"
+6. If a behavior isn't specified for a function, then use the default behavior.
+