proc code builder

[FAReTek1]

make a script in mutation.py to allow for building a proccode from a list of argtypes/argument & string objects

signature:

def construct_proccode(components: list[ArgumentType | Argument | str]) -> str:

[Cmullins0808]

Write a function in mutation.py called:

python
Copy
Edit
def construct_proccode(components: list[ArgumentType | Argument | str]) -> str:
This function should build a "proccode" string by intelligently combining items from the input list, which can be:

ArgumentType – likely a type descriptor (e.g., "number", "string").

Argument – an object that might represent a named parameter.

str – simple text fragments that might be part of the code pattern.

🧠 Assumptions (since we're outside the full codebase):
Let's define mock classes to simulate the behavior:

python
Copy
Edit
class ArgumentType:
def init(self, typename: str):
self.typename = typename

def __str__(self):
    return f"[{self.typename}]"

class Argument:
def init(self, name: str, type: str):
self.name = name
self.type = type

def __str__(self):
    return f"[{self.type} {self.name}]"

✅ Sample construct_proccode Implementation:
python
Copy
Edit
def construct_proccode(components: list) -> str:
"""
Construct a proccode string by joining elements in the list.
- ArgumentType becomes [typename]
- Argument becomes [type name]
- str is included as-is
"""
result = []

for item in components:
    if isinstance(item, str):
        result.append(item)
    elif hasattr(item, 'typename'):
        result.append(f"[{item.typename}]")
    elif hasattr(item, 'name') and hasattr(item, 'type'):
        result.append(f"[{item.type} {item.name}]")
    else:
        raise ValueError(f"Unsupported component: {item}")

return ' '.join(result)

🔄 Example Usage:
python
Copy
Edit
components = [
"move",
ArgumentType("number"),
"steps",
Argument("x", "number"),
"and wait"
]

print(construct_proccode(components))
Output:

scss
Copy
Edit
move [number] steps [number x] and wait