Class EnvironmentConfig

src/environment/types.py:231–325

Environment configuration

        )

class EnvironmentConfig(BaseModel):
    """Environment configuration"""
    model_config = ConfigDict(arbitrary_types_allowed=True, extra="allow")
    
    name: str = Field(description="The name of the environment")
    description: str = Field(description="The description of the environment")
    metadata: Optional[Dict[str, Any]] = Field(default_factory=dict, description="The metadata of the environment")
    rules: str = Field(description="The rules of the environment")
    version: str = Field(default="1.0.0", description="Version of the environment")
    require_grad: bool = Field(default=False, description="Whether the environment requires gradients")
    
    cls: Optional[Type[Environment]] = Field(default=None, description="The class of the environment")
    config: Optional[Dict[str, Any]] = Field(default={}, description="The initialization configuration of the environment")
    instance: Optional[Any] = Field(default=None, description="The instance of the environment")
    code: Optional[str] = Field(default=None, description="Source code for dynamically generated environment classes (used when cls cannot be imported from a module)")
    
    actions: Dict[str, ActionConfig] = Field(default_factory=dict, description="Dictionary of actions available in this environment")
    
    def model_dump(self, **kwargs) -> Dict[str, Any]:
        """Dump the model to a dictionary, recursively serializing nested Pydantic models."""
        result = {
            "name": self.name,
            "description": self.description,
            "metadata": self.metadata,
            "rules": self.rules,
            "version": self.version,
            "require_grad": self.require_grad,
            
            "cls": dynamic_manager.get_class_string(self.cls) if self.cls else None,
            "config": self.config,
            "instance": None,
            "code": self.code,
            
            "actions": {name: action_config.model_dump() for name, action_config in self.actions.items()},
        }
        
        return result
    
    @classmethod
    def model_validate(cls, data: Dict[str, Any]) -> 'EnvironmentConfig':
        """Validate the model from a dictionary."""
        
        name = data.get("name")
        description = data.get("description")
        metadata = data.get("metadata")
        rules = data.get("rules")
        version = data.get("version")
        require_grad = data.get("require_grad", False)
        
        cls_ = None
        code = data.get("code")
        if code:
            class_name = dynamic_manager.extract_class_name_from_code(code)
            if class_name:
                try:
                    cls_ = dynamic_manager.load_class(
                        code, 
                        class_name=class_name,