fameio 3.2.0__py3-none-any.whl → 3.4.0__py3-none-any.whl

fameio/input/schema/attribute.py

@@ -16,7 +16,7 @@ from fameio.tools import keys_to_lower
 
 
 class AttributeType(Enum):
-    """Data types that Attributes can take"""
+    """Data types that Attributes can take."""
 
     INTEGER = auto()
     DOUBLE = auto()
@@ -57,7 +57,7 @@ class AttributeType(Enum):
 
 
 class AttributeSpecs(Metadata):
-    """Schema Definition of a single Attribute (with possible inner Attributes) of an agent"""
+    """Schema Definition of a single Attribute (with possible inner Attributes) of an agent."""
 
     _DISALLOWED_NAMES = ["value", "values", "metadata"]
     _SEPARATOR = "."
@@ -83,8 +83,7 @@ class AttributeSpecs(Metadata):
     _NAME_DISALLOWED = f"Attribute name must not be empty and none of: {_DISALLOWED_NAMES}"
 
     def __init__(self, name: str, definition: dict):
-        """
-        Loads Attribute from given `definition`
+        """Loads Attribute from given `definition`.
 
         Args:
             name: of attribute type
@@ -115,8 +114,7 @@ class AttributeSpecs(Metadata):
 
     @staticmethod
     def _assert_is_allowed_name(full_name: str) -> None:
-        """
-        Raises SchemaError if provided name is not allowed for Attributes
+        """Raises SchemaError if provided name is not allowed for Attributes.
 
         Args:
             full_name: to be checked if it can serve as name for an attribute
@@ -134,7 +132,7 @@ class AttributeSpecs(Metadata):
 
     @staticmethod
     def _get_is_mandatory(definition: dict, name: str) -> bool:
-        """Returns True if `Mandatory` is set to True or if specification is missing; False otherwise"""
+        """Returns True if `Mandatory` is set to True or if specification is missing; False otherwise."""
         if AttributeSpecs.KEY_MANDATORY in definition:
             return definition[AttributeSpecs.KEY_MANDATORY]
         log().warning(AttributeSpecs._MISSING_SPEC_DEFAULT.format(AttributeSpecs.KEY_MANDATORY, name, True))
@@ -142,7 +140,7 @@ class AttributeSpecs(Metadata):
 
     @staticmethod
     def _get_is_list(definition: dict, name: str) -> bool:
-        """Returns True if `List` is set to True; Returns False otherwise or if specification is missing"""
+        """Returns True if `List` is set to True; Returns False otherwise or if specification is missing."""
         if AttributeSpecs.KEY_LIST in definition:
             return definition[AttributeSpecs.KEY_LIST]
         log().warning(AttributeSpecs._MISSING_SPEC_DEFAULT.format(AttributeSpecs.KEY_LIST, name, False))
@@ -150,8 +148,7 @@ class AttributeSpecs(Metadata):
 
     @staticmethod
     def _get_type(definition: dict, name: str) -> AttributeType:
-        """
-        Returns `AttributeType` from given definition
+        """Returns `AttributeType` from given definition.
 
         Args:
             definition: of the attribute
@@ -172,7 +169,7 @@ class AttributeSpecs(Metadata):
         raise log_error(SchemaError(AttributeSpecs._MISSING_TYPE.format(name)))
 
     def _get_allowed_values(self, definition: dict) -> ValueContainer:
-        """Returns ValueContainer with allowed values if defined; otherwise an empty ValueContainer"""
+        """Returns ValueContainer with allowed values if defined; otherwise an empty ValueContainer."""
         allowed_values: ValueContainer = ValueContainer()
         if AttributeSpecs.KEY_VALUES in definition:
             value_definition = definition[AttributeSpecs.KEY_VALUES]
@@ -181,9 +178,9 @@ class AttributeSpecs(Metadata):
         return allowed_values
 
     def _read_values(self, definition: dict | list) -> ValueContainer:
-        """
-        Returns accepted values mapped to their additional metadata specifications extracted from given `definition`
-        Accepts lists of accepted values or dictionaries with (optional) metadata assigned to each value
+        """Returns acceptable values mapped to their optional metadata specifications extracted from given `definition`.
+
+        Accepts lists of values or dictionaries with (optional) metadata assigned to each value
 
         Args:
             definition: list of acceptable values or dict with acceptable values as keys and (optional) metadata content
@@ -192,7 +189,7 @@ class AttributeSpecs(Metadata):
             Mapping of acceptable values to their associated Metadata
 
         Raises:
-            SchemaError: if values could not be parsed, logged with level "ERROR"
+            SchemaError: if values could not be parsed or do not match the attribute type, logged with level "ERROR"
         """
         try:
             value_container = ValueContainer(definition)
@@ -203,8 +200,7 @@ class AttributeSpecs(Metadata):
             raise log_error(SchemaError(AttributeSpecs._VALUES_ILL_FORMAT.format(definition))) from e
 
     def _convert_to_data_type(self, value: str, section: str) -> int | float | str:
-        """
-        Returns a given single `value` in `section` converted to this Attribute's data type
+        """Returns a given single `value` in `section` converted to this Attribute's data type.
 
         Args:
             value: to be converted
@@ -222,7 +218,7 @@ class AttributeSpecs(Metadata):
             raise log_error(SchemaError(AttributeSpecs._INCOMPATIBLE.format(value, section, self._attr_type))) from e
 
     def _get_default_value(self, definition: dict) -> int | float | str | list | None:
-        """Returns default value(s) from given definitions, or None if no default is specified"""
+        """Returns default value(s) from given definitions, or None if no default is specified."""
         if AttributeSpecs.KEY_DEFAULT in definition:
             provided_value = definition[AttributeSpecs.KEY_DEFAULT]
             if self._is_list:
@@ -231,8 +227,7 @@ class AttributeSpecs(Metadata):
         return None
 
     def _convert_list(self, values) -> list:
-        """
-        Converts all entries in given `values` list to this attribute data type and returns this new list
+        """Converts all entries in given `values` list to this attribute data type and returns this new list.
 
         Args:
             values: to be converted to a list of default values
@@ -248,8 +243,7 @@ class AttributeSpecs(Metadata):
         raise log_error(SchemaError(AttributeSpecs._DEFAULT_NOT_LIST.format(values)))
 
     def _convert_and_test(self, value: str):
-        """
-        Converts a given single `value` to this Attribute's data type and tests if the value is allowed
+        """Converts a given single `value` to this Attribute's data type and tests if the value is allowed.
 
         Args:
             value: to be converted and tested
@@ -268,7 +262,7 @@ class AttributeSpecs(Metadata):
 
     @staticmethod
     def _get_nested_attributes(definition: dict, name: str) -> dict[str, AttributeSpecs]:
-        """Returns dict of nested attributes read from given definition; empty dict if no nested attributes exist"""
+        """Returns dict of nested attributes read from given definition; empty dict if no nested attributes exist."""
         nested_attributes = {}
         if AttributeSpecs.KEY_NESTED in definition:
             for nested_name, nested_details in definition[AttributeSpecs.KEY_NESTED].items():
@@ -278,67 +272,67 @@ class AttributeSpecs(Metadata):
 
     @staticmethod
     def _get_help(definition) -> str:
-        """Returns (possible empty) help text if provided in definition; None otherwise"""
+        """Returns (possible empty) help text if provided in definition; None otherwise."""
         return definition.get(AttributeSpecs.KEY_HELP, "").strip()
 
     @property
     def attr_type(self) -> AttributeType:
-        """Returns AttributeType of this attribute"""
+        """Returns AttributeType of this attribute."""
         return self._attr_type
 
     @property
     def values(self) -> list:
-        """Returns the list of allowed values for this attribute"""
+        """Returns the list of allowed values for this attribute."""
         return self._allowed_values.as_list()
 
     @property
     def has_value_restrictions(self) -> bool:
-        """Returns True if the attribute can only take a set of certain values"""
+        """Returns True if the attribute can only take a set of certain values."""
         return not self._allowed_values.is_empty()
 
     @property
     def is_list(self) -> bool:
-        """Return True if this attribute type is a list"""
+        """Return True if this attribute type is a list."""
         return self._is_list
 
     @property
     def has_nested_attributes(self) -> bool:
-        """Returns True if nested attributes are defined"""
+        """Returns True if nested attributes are defined."""
         return bool(self._nested_attributes)
 
     @property
     def nested_attributes(self) -> dict[str, AttributeSpecs]:
-        """Returns list of nested Attributes of this Attribute or an empty dict if no nested attributes are defined"""
+        """Returns list of nested Attributes of this Attribute or an empty dict if no nested attributes are defined."""
         return self._nested_attributes
 
     @property
     def has_default_value(self) -> bool:
-        """Return True if a default value is available"""
+        """Return True if a default value is available."""
         return self._default_value is not None
 
     @property
     def default_value(self) -> Any | None:
-        """Return the default value of this attribute, or None if no default is specified"""
+        """Return the default value of this attribute, or None if no default is specified."""
         return self._default_value
 
     @property
     def is_mandatory(self) -> bool:
-        """Return True if this attribute is mandatory"""
+        """Return True if this attribute is mandatory."""
         return self._is_mandatory
 
     @property
     def full_name(self) -> str:
-        """Returns name including name of enclosing parent attributes"""
+        """Returns name including name of enclosing parent attributes."""
         return self._full_name
 
     @property
     def has_help_text(self) -> bool:
-        """Return True if a help_text is available"""
+        """Return True if a help_text is available."""
         return bool(self._help)
 
     @property
     def help_text(self) -> str:
-        """Return the help_text of this attribute, if any"""
+        """Return the help_text of this attribute, if any."""
         return self._help
 
     def _to_dict(self) -> dict[str, Any]:

fameio/input/schema/java_packages.py

@@ -11,7 +11,7 @@ from fameio.tools import keys_to_lower
 
 
 class JavaPackages:
-    """Schema definitions for Java package names in which model classes reside"""
+    """Schema definitions for Java package names in which model classes reside."""
 
     KEY_AGENT: Final[str] = "Agents".lower()
     KEY_DATA_ITEM: Final[str] = "DataItems".lower()
@@ -28,8 +28,7 @@ class JavaPackages:
 
     @classmethod
     def from_dict(cls, definitions: dict[str, list[str]]) -> JavaPackages:
-        """
-        Creates JavaPackages from a dictionary representation
+        """Creates JavaPackages from a dictionary representation.
 
         Args:
             definitions: dictionary representation of JavaPackages
@@ -58,19 +57,19 @@ class JavaPackages:
 
     @property
     def agents(self) -> list[str]:
-        """Return list of java package names that contain the model's Agents"""
+        """Return list of java package names that contain the model's Agents."""
         return self._agents
 
     @property
     def data_items(self) -> list[str]:
-        """Return list of java package names that contain the model's DataItems"""
+        """Return list of java package names that contain the model's DataItems."""
         return self._data_items
 
     @property
     def portables(self) -> list[str]:
-        """Return list of java package names that contain the model's Portables"""
+        """Return list of java package names that contain the model's Portables."""
         return self._portables
 
     def to_dict(self) -> dict[str, list[str]]:
-        """Return dictionary representation of this JavaPackages object"""
+        """Return dictionary representation of this JavaPackages object."""
         return {self.KEY_AGENT: self.agents, self.KEY_DATA_ITEM: self.data_items, self.KEY_PORTABLE: self.portables}

fameio/input/schema/schema.py

@@ -14,7 +14,7 @@ from .java_packages import JavaPackages
 
 
 class Schema:
-    """Definition of a schema"""
+    """Definition of a schema."""
 
     KEY_AGENT_TYPE: Final[str] = "AgentTypes".lower()
     KEY_PACKAGES: Final[str] = "JavaPackages".lower()
@@ -30,14 +30,13 @@ class Schema:
 
     @classmethod
     def from_dict(cls, definitions: dict) -> Schema:
-        """
-        Load given dictionary `definitions` into a new schema
+        """Convert given `definitions` into a new schema.
 
         Args:
             definitions: dictionary representation of schema
 
         Returns:
-            new Schema
+            schema created from given definitions
 
         Raises:
             SchemaError: if definitions are incomplete or erroneous, logged on level "ERROR"
@@ -59,8 +58,7 @@ class Schema:
 
     @staticmethod
     def _get_or_raise(definitions: dict[str, Any], key: str, error_message: str) -> Any:
-        """
-        Get given `key` from given `definitions` - raise error with given `error_message` if not present
+        """Get given `key` from given `definitions` - raise error with given `error_message` if not present.
 
         Args:
             definitions: to search the key in
@@ -79,25 +77,25 @@ class Schema:
 
     @classmethod
     def from_string(cls, definitions: str) -> Schema:
-        """Load given string `definitions` into a new Schema"""
+        """Load given string `definitions` into a new Schema."""
         return cls.from_dict(ast.literal_eval(definitions))
 
     def to_dict(self) -> dict:
-        """Serializes the schema content to a dict"""
+        """Serializes the schema content to a dict."""
         return self._original_input_dict
 
     def to_string(self) -> str:
-        """Returns a string representation of the Schema of which the class can be rebuilt"""
+        """Returns a string representation of the Schema of which the class can be rebuilt."""
         return repr(self.to_dict())
 
     @property
     def agent_types(self) -> dict[str, AgentType]:
-        """Returns all the agent types by their name"""
+        """Returns all the agent types by their name."""
         return self._agent_types
 
     @property
     def packages(self) -> JavaPackages:
-        """Returns JavaPackages, i.e. names where model classes are defined in"""
+        """Returns JavaPackages, i.e. names where model classes are defined in."""
         if self._packages is None:
             raise log_error(SchemaError(self._ERR_MISSING_PACKAGES))
         return self._packages