fameio 2.0.0__py3-none-any.whl → 2.1.1__py3-none-any.whl

fameio/source/results/data_transformer.py

@@ -22,7 +22,6 @@ class DataTransformer(ABC):
 
     MODES = {
         ResolveOptions.IGNORE: lambda: DataTransformerIgnore(),
-        ResolveOptions.MERGE: lambda: DataTransformerMerge(),
         ResolveOptions.SPLIT: lambda: DataTransformerSplit(),
     }
     SIMPLE_COLUMN_INDEX = -1
@@ -47,6 +46,7 @@ class DataTransformer(ABC):
             if column_id == DataTransformer.SIMPLE_COLUMN_INDEX:
                 data_frame.rename(columns=self._get_column_map(agent_type), inplace=True)
                 index = INDEX
+                data_frame = data_frame.loc[:, agent_type.get_simple_column_mask()]
             else:
                 data_frame.rename(columns={0: column_name}, inplace=True)
                 index = INDEX + agent_type.get_inner_columns(column_id)
@@ -54,7 +54,6 @@ class DataTransformer(ABC):
             if not data_frame.empty:
                 data_frame.index = pd.MultiIndex.from_tuples(data_frame.index)
                 data_frame.rename_axis(index, inplace=True)
-            data_frame.dropna(how="all", axis=1, inplace=True)
             data_frames[column_name] = data_frame
         return data_frames
 
@@ -82,10 +81,10 @@ class DataTransformer(ABC):
         container: Dict[int, Dict[Tuple, List[Union[float, None, str]]]],
     ) -> None:
         """Adds data from given `series` to specified `container` dict as list"""
-        dummy_list = [None] * len(mask_simple)
+        empty_list = [None] * len(mask_simple)
         for line in series.line:
             index = (series.agentId, line.timeStep)
-            simple_values = dummy_list.copy()
+            simple_values = empty_list.copy()
             for column in line.column:
                 if mask_simple[column.fieldId]:
                     simple_values[column.fieldId] = column.value
@@ -114,22 +113,6 @@ class DataTransformerIgnore(DataTransformer):
     """Ignores complex columns on output"""
 
 
-class DataTransformerMerge(DataTransformer):
-    """Merges complex columns on output into a single column entry"""
-
-    def _get_column_map(self, agent_type: AgentType) -> Dict[int, str]:
-        """Returns mapping of simple (and merged) column IDs to their name (or enhanced name) for given `agent_type`"""
-        return agent_type.get_merged_column_map()
-
-    @staticmethod
-    def _merge_complex_column(column: Output.Series.Line.Column, values: List) -> None:
-        """Merges given complex `column` content and saves it to given `values` list"""
-        result = []
-        for entry in column.entry:
-            result.append((tuple(entry.indexValue), entry.value))
-        values[column.fieldId] = result
-
-
 class DataTransformerSplit(DataTransformer):
     @staticmethod
     def _store_complex_values(column: Output.Series.Line.Column, container: Dict[int, Dict], base_index: Tuple) -> None:

fameio/source/results/input_dao.py

@@ -8,7 +8,7 @@ from fameprotobuf.DataStorage_pb2 import DataStorage
 from fameprotobuf.Field_pb2 import NestedField
 from fameprotobuf.InputFile_pb2 import InputData
 
-from fameio.source.logs import logger
+from fameio.source.logs import log
 from fameio.source.scenario import GeneralProperties, Agent, Contract, Scenario
 from fameio.source.schema import Schema, AttributeSpecs, AttributeType
 from fameio.source.series import TimeSeriesManager
@@ -80,10 +80,10 @@ class InputDao:
             InputConversionException: if no or more than one input is present
         """
         if not self._inputs:
-            logger().error(self._ERR_NO_INPUTS)
+            log().error(self._ERR_NO_INPUTS)
             raise InputConversionException(self._ERR_NO_INPUTS)
         if len(self._inputs) > 1:
-            logger().error(self._ERR_MULTIPLE_INPUTS)
+            log().error(self._ERR_MULTIPLE_INPUTS)
             raise InputConversionException(self._ERR_MULTIPLE_INPUTS)
         return self._inputs[0]
 

fameio/source/results/output_dao.py

@@ -68,4 +68,7 @@ class OutputDAO:
         """
         agent_series = self._all_series.pop(agent_name) if agent_name in self._all_series else []
         agent_type = self._agent_type_log.get_agent_type(agent_name)
-        return data_transformer.extract_agent_data(agent_series, agent_type)
+        extracted_data = data_transformer.extract_agent_data(agent_series, agent_type)
+        if None in extracted_data and extracted_data[None].empty:
+            extracted_data.pop(None)
+        return extracted_data

fameio/source/results/reader.py

@@ -11,7 +11,7 @@ from typing import IO, List
 from fameprotobuf.DataStorage_pb2 import DataStorage
 from google.protobuf.message import DecodeError
 
-from fameio.source.logs import logger
+from fameio.source.logs import log
 
 
 class Reader(ABC):
@@ -51,15 +51,15 @@ class Reader(ABC):
         Returns:
             Reader that can read the specified file
         """
-        logger().debug("Reading file headers...")
+        log().debug("Reading file headers...")
         try:
             header = file.read(Reader._HEADER_LENGTH).decode(Reader.HEADER_ENCODING)
             return Reader._READER_HEADERS[header](file, read_single)
         except (KeyError, UnicodeDecodeError):
-            logger().warning(Reader._WARN_NO_HEADER)
+            log().warning(Reader._WARN_NO_HEADER)
             file.seek(0)
             if read_single:
-                logger().error(Reader._ERR_UNSUPPORTED_MODE)
+                log().error(Reader._ERR_UNSUPPORTED_MODE)
             return ReaderV0(file, False)
 
     @typing.final
@@ -67,7 +67,7 @@ class Reader(ABC):
         """Returns length of next DataStorage message in file"""
         message_length_byte = self._file.read(self.BYTES_DEFINING_MESSAGE_LENGTH)
         if not message_length_byte:
-            logger().debug(self._DEBUG_FILE_END_REACHED)
+            log().debug(self._DEBUG_FILE_END_REACHED)
             message_length_int = 0
         else:
             message_length_int = struct.unpack(">i", message_length_byte)[0]
@@ -86,7 +86,7 @@ class Reader(ABC):
         else:
             raise IOError(self._ERR_FILE_CORRUPT_NEGATIVE_LENGTH)
         if message_length and len(message) != message_length:
-            logger().error(self._ERR_FILE_CORRUPT_MISSING_DATA)
+            log().error(self._ERR_FILE_CORRUPT_MISSING_DATA)
         return self._parse_to_data_storage(message) if message else None
 
     @staticmethod
@@ -107,7 +107,7 @@ class ReaderV0(Reader):
 
     def __init__(self, file: IO, read_single):
         super().__init__(file, read_single)
-        logger().warning(self._WARN_DEPRECATED)
+        log().warning(self._WARN_DEPRECATED)
 
     def read(self) -> List[DataStorage]:
         result = self._read_data_storage_message()
@@ -126,5 +126,5 @@ class ReaderV1(Reader):
             messages.append(self._read_data_storage_message(message_length))
             if self._read_single:
                 break
-        logger().debug(f"Read {len(messages)} messages from file.")
+        log().debug(f"Read {len(messages)} messages from file.")
         return messages

fameio/source/results/yaml_writer.py

@@ -6,7 +6,7 @@ from typing import Dict
 
 import yaml
 
-from fameio.source.logs import logger
+from fameio.source.logs import log
 
 ERR_WRITE_EXCEPTION = "Failed to save dictionary to YAML file `{}`"
 INFO_DESTINATION = "Saving scenario to file at {}"
@@ -20,7 +20,7 @@ def data_to_yaml_file(data: Dict, file_path: Path) -> None:
         data: to be saved to yaml file
         file_path: at which the file will be created
     """
-    logger().info(INFO_DESTINATION.format(file_path))
+    log().info(INFO_DESTINATION.format(file_path))
     try:
         with open(file_path, "w") as f:
             yaml.dump(data, f, sort_keys=False)

fameio/source/scenario/contract.py

@@ -5,7 +5,7 @@ from __future__ import annotations
 
 from typing import Any, Dict, List, Optional
 
-from fameio.source.logs import logger
+from fameio.source.logs import log
 from fameio.source.scenario.attribute import Attribute
 from fameio.source.scenario.exception import get_or_default, get_or_raise, log_and_raise
 from fameio.source.time import FameTime
@@ -47,7 +47,7 @@ class Contract:
         """Constructs a new Contract"""
         assert product_name != ""
         if sender_id == receiver_id:
-            logger().warning(self._ERR_SENDER_IS_RECEIVER.format(sender_id))
+            log().warning(self._ERR_SENDER_IS_RECEIVER.format(sender_id))
         if delivery_interval <= 0:
             raise ValueError(self._ERR_INTERVAL_NOT_POSITIVE.format(delivery_interval))
         self._sender_id = sender_id

fameio/source/scenario/exception.py

@@ -4,7 +4,7 @@
 
 from typing import NoReturn, Any, Union
 
-from fameio.source.logs import log_error_and_raise, logger
+from fameio.source.logs import log_error_and_raise, log
 
 _DEFAULT_USED = "Using default value '{}' for missing key '{}'"
 
@@ -33,7 +33,7 @@ def get_or_default(dictionary: dict, key: str, default_value) -> Any:
     if key in dictionary and dictionary[key] is not None:
         return dictionary[key]
     else:
-        logger().debug(_DEFAULT_USED.format(default_value, key))
+        log().debug(_DEFAULT_USED.format(default_value, key))
         return default_value
 
 

fameio/source/scenario/generalproperties.py

@@ -3,7 +3,7 @@
 # SPDX-License-Identifier: Apache-2.0
 from __future__ import annotations
 
-from fameio.source.logs import logger
+from fameio.source.logs import log
 from fameio.source.scenario.exception import get_or_default, get_or_raise
 from fameio.source.time import FameTime
 from fameio.source.tools import keys_to_lower
@@ -34,7 +34,7 @@ class GeneralProperties:
         output_process: int,
     ) -> None:
         if simulation_stop_time < simulation_start_time:
-            logger().warning(GeneralProperties._SIMULATION_DURATION)
+            log().warning(GeneralProperties._SIMULATION_DURATION)
         self._run_id = run_id
         self._simulation_start_time = simulation_start_time
         self._simulation_stop_time = simulation_stop_time

fameio/source/schema/agenttype.py

@@ -5,7 +5,7 @@ from __future__ import annotations
 
 from typing import Dict, List, Any
 
-from fameio.source.logs import log_error_and_raise, logger
+from fameio.source.logs import log_error_and_raise, log
 from fameio.source.schema.exception import SchemaException
 from fameio.source.schema.attribute import AttributeSpecs
 from fameio.source.tools import keys_to_lower
@@ -63,26 +63,26 @@ class AgentType:
                 full_name = name + "." + attribute_name
                 agent_type._attributes[attribute_name] = AttributeSpecs(full_name, attribute_details)
         else:
-            logger().info(AgentType._NO_ATTRIBUTES.format(name))
+            log().info(AgentType._NO_ATTRIBUTES.format(name))
 
         if AgentType._KEY_PRODUCTS in definition and definition[AgentType._KEY_PRODUCTS]:
             agent_type._products.update(AgentType._read_products(definition[AgentType._KEY_PRODUCTS], name))
         else:
-            logger().info(AgentType._NO_PRODUCTS.format(name))
+            log().info(AgentType._NO_PRODUCTS.format(name))
 
         if AgentType._KEY_OUTPUTS in definition:
             outputs_to_add = definition[AgentType._KEY_OUTPUTS]
             if outputs_to_add:
                 agent_type._outputs.update(outputs_to_add)
         else:
-            logger().debug(AgentType._NO_OUTPUTS.format(name))
+            log().debug(AgentType._NO_OUTPUTS.format(name))
 
         if AgentType._KEY_METADATA in definition:
             metadata_to_add = definition[AgentType._KEY_METADATA]
             if metadata_to_add:
                 agent_type._metadata.update(metadata_to_add)
         else:
-            logger().debug(AgentType._NO_METADATA.format(name))
+            log().debug(AgentType._NO_METADATA.format(name))
 
         return agent_type
 

fameio/source/schema/attribute.py

@@ -7,7 +7,7 @@ import typing
 from enum import Enum, auto
 from typing import Any, Dict
 
-from fameio.source.logs import logger
+from fameio.source.logs import log
 from fameio.source.schema.exception import SchemaException
 from fameio.source.time import FameTime
 from fameio.source.tools import keys_to_lower
@@ -70,18 +70,18 @@ class AttributeSpecs:
             self._is_mandatory = definition[AttributeSpecs._KEY_MANDATORY]
         else:
             self._is_mandatory = True
-            logger().warning(AttributeSpecs._MISSING_SPEC_DEFAULT.format(AttributeSpecs._KEY_MANDATORY, name, True))
+            log().warning(AttributeSpecs._MISSING_SPEC_DEFAULT.format(AttributeSpecs._KEY_MANDATORY, name, True))
 
         if AttributeSpecs._KEY_LIST in definition:
             self._is_list = definition[AttributeSpecs._KEY_LIST]
         else:
             self._is_list = False
-            logger().warning(AttributeSpecs._MISSING_SPEC_DEFAULT.format(AttributeSpecs._KEY_LIST, name, False))
+            log().warning(AttributeSpecs._MISSING_SPEC_DEFAULT.format(AttributeSpecs._KEY_LIST, name, False))
 
         if AttributeSpecs._KEY_TYPE in definition:
             self._attr_type = AttributeSpecs._get_type_for_name(definition[AttributeSpecs._KEY_TYPE])
         else:
-            logger().error(AttributeSpecs._MISSING_TYPE.format(name))
+            log().error(AttributeSpecs._MISSING_TYPE.format(name))
             raise SchemaException(AttributeSpecs._MISSING_TYPE.format(name))
 
         if self._attr_type == AttributeType.TIME_SERIES and self._is_list:

fameio/source/schema/java_packages.py

@@ -0,0 +1,69 @@
+# SPDX-FileCopyrightText: 2024 German Aerospace Center <fame@dlr.de>
+#
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+from typing import List, Dict
+
+from fameio.source.logs import log_error_and_raise
+from fameio.source.schema import SchemaException
+from fameio.source.tools import keys_to_lower
+
+
+class JavaPackages:
+    """Schema definitions for Java package names in which model classes reside"""
+
+    _ERR_MISSING_AGENTS = "JavaPackages requires non-empty list for `Agents`. Key was missing or list was empty."
+    _ERR_MISSING_DATA_ITEMS = "JavaPackages requires non-empty list for `DataItems`. Key was missing or list was empty."
+    _ERR_MISSING_PORTABLES = "JavaPackages require non-empty list for `Portables`. Key was missing or list was empty."
+
+    _KEY_AGENT = "Agents".lower()
+    _KEY_DATA_ITEM = "DataItems".lower()
+    _KEY_PORTABLE = "Portables".lower()
+
+    def __init__(self):
+        self._agents: List[str] = []
+        self._data_items: List[str] = []
+        self._portables: List[str] = []
+
+    @classmethod
+    def from_dict(cls, definitions: Dict[str, List[str]]) -> JavaPackages:
+        """
+        Creates JavaPackages from a dictionary representation
+
+        Args:
+            definitions: dictionary representation of JavaPackages
+
+        Returns:
+            new instance of JavaPackages
+        """
+        java_packages = cls()
+        definitions = keys_to_lower(definitions)
+
+        java_packages._agents = definitions.get(JavaPackages._KEY_AGENT, [])
+        java_packages._data_items = definitions.get(JavaPackages._KEY_DATA_ITEM, [])
+        java_packages._portables = definitions.get(JavaPackages._KEY_PORTABLE, [])
+
+        if not java_packages._agents:
+            log_error_and_raise(SchemaException(JavaPackages._ERR_MISSING_AGENTS))
+        if not java_packages._data_items:
+            log_error_and_raise(SchemaException(JavaPackages._ERR_MISSING_DATA_ITEMS))
+        if not java_packages._portables:
+            log_error_and_raise(SchemaException(JavaPackages._ERR_MISSING_PORTABLES))
+
+        return java_packages
+
+    @property
+    def agents(self) -> List[str]:
+        """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 self._data_items
+
+    @property
+    def portables(self) -> List[str]:
+        """Return list of java package names that contain the model's Portables"""
+        return self._portables

fameio/source/schema/schema.py

@@ -1,42 +1,53 @@
-# SPDX-FileCopyrightText: 2023 German Aerospace Center <fame@dlr.de>
+# SPDX-FileCopyrightText: 2024 German Aerospace Center <fame@dlr.de>
 #
 # SPDX-License-Identifier: Apache-2.0
 from __future__ import annotations
 
 import ast
-from typing import Dict
+from typing import Dict, Optional
 
-from fameio.source.logs import log_error_and_raise
+from fameio.source.logs import log_error_and_raise, log
 from fameio.source.schema.agenttype import AgentType
 from fameio.source.schema.exception import SchemaException
+from fameio.source.schema.java_packages import JavaPackages
 from fameio.source.tools import keys_to_lower
 
 
 class Schema:
     """Definition of a schema"""
 
-    _AGENT_TYPES_MISSING = "Required keyword `AgentTypes` missing in Schema."
-    _AGENT_TYPES_EMPTY = "`AgentTypes` must not be empty - at least one type of agent is required."
+    _ERR_AGENT_TYPES_MISSING = "Required keyword `AgentTypes` missing in Schema."
+    _ERR_AGENT_TYPES_EMPTY = "`AgentTypes` must not be empty - at least one type of agent is required."
+    _WARN_MISSING_PACKAGES = "No `JavaPackages` defined Schema. Future versions of fameio will require it."
+
     _KEY_AGENT_TYPE = "AgentTypes".lower()
+    _KEY_PACKAGES = "JavaPackages".lower()
 
     def __init__(self, definitions: dict):
         self._original_input_dict = definitions
         self._agent_types = {}
+        self._packages: Optional[JavaPackages] = None
 
     @classmethod
     def from_dict(cls, definitions: dict) -> Schema:
         """Load given dictionary `definitions` into a new Schema"""
         definitions = keys_to_lower(definitions)
         if Schema._KEY_AGENT_TYPE not in definitions:
-            log_error_and_raise(SchemaException(Schema._AGENT_TYPES_MISSING))
+            log_error_and_raise(SchemaException(Schema._ERR_AGENT_TYPES_MISSING))
         schema = cls(definitions)
         agent_types = definitions[Schema._KEY_AGENT_TYPE]
         if len(agent_types) == 0:
-            log_error_and_raise(SchemaException(Schema._AGENT_TYPES_EMPTY))
+            log_error_and_raise(SchemaException(Schema._ERR_AGENT_TYPES_EMPTY))
 
         for agent_type_name, agent_definition in agent_types.items():
             agent_type = AgentType.from_dict(agent_type_name, agent_definition)
             schema._agent_types[agent_type_name] = agent_type
+
+        if Schema._KEY_PACKAGES in definitions:
+            schema._packages = JavaPackages.from_dict(definitions[Schema._KEY_PACKAGES])
+        else:
+            log().warning(Schema._WARN_MISSING_PACKAGES)
+            schema._packages = JavaPackages()
         return schema
 
     @classmethod
@@ -56,3 +67,8 @@ class Schema:
     def agent_types(self) -> Dict[str, AgentType]:
         """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"""
+        return self._packages

fameio/source/series.py

@@ -9,9 +9,10 @@ from typing import Dict, Union, Tuple, Any, List
 
 import pandas as pd
 from fameprotobuf.InputFile_pb2 import InputData
+from google.protobuf.internal.wire_format import INT64_MIN, INT64_MAX
 
 from fameio.source import PathResolver
-from fameio.source.logs import log_error_and_raise, logger
+from fameio.source.logs import log_error_and_raise, log
 from fameio.source.time import ConversionException, FameTime
 from fameio.source.tools import clean_up_file_name
 
@@ -114,7 +115,8 @@ class TimeSeriesManager:
         """Returns name and dataframe for a new static timeseries created from the given `value`"""
         if math.isnan(value):
             log_error_and_raise(TimeSeriesException(TimeSeriesManager._ERR_NAN_VALUE))
-        return TimeSeriesManager._CONSTANT_IDENTIFIER.format(value), pd.DataFrame({0: [0], 1: [value]})
+        data = pd.DataFrame({0: [INT64_MIN, INT64_MAX], 1: [value, value]})
+        return TimeSeriesManager._CONSTANT_IDENTIFIER.format(value), data
 
     def get_series_id_by_identifier(self, identifier: Union[str, int, float]) -> int:
         """
@@ -136,7 +138,7 @@ class TimeSeriesManager:
     def get_all_series(self) -> List[Tuple[int, str, pd.DataFrame]]:
         """Returns iterator over id, name and dataframe of all stored series"""
         if len(self._series_by_id) == 0:
-            logger().warning(self._WARN_NO_DATA)
+            log().warning(self._WARN_NO_DATA)
         return [(v[Entry.ID], v[Entry.NAME], v[Entry.DATA]) for v in self._series_by_id.values()]
 
     def reconstruct_time_series(self, timeseries: List[InputData.TimeSeriesDao]) -> None:

fameio/source/validator.py

@@ -7,7 +7,7 @@ from collections import Counter
 from typing import Any, Dict, List
 
 from fameio.source import PathResolver
-from fameio.source.logs import log_error_and_raise, logger
+from fameio.source.logs import log_error_and_raise, log
 from fameio.source.scenario import Agent, Attribute, Contract, Scenario
 from fameio.source.schema.agenttype import AgentType
 from fameio.source.schema.attribute import AttributeSpecs, AttributeType
@@ -125,9 +125,9 @@ class SchemaValidator:
                         )
                 else:
                     if specification.has_default_value:
-                        logger().warning(SchemaValidator._DEFAULT_IGNORED.format(specification.full_name))
+                        log().warning(SchemaValidator._DEFAULT_IGNORED.format(specification.full_name))
                     else:
-                        logger().info(SchemaValidator._OPTIONAL_MISSING.format(specification.full_name))
+                        log().info(SchemaValidator._OPTIONAL_MISSING.format(specification.full_name))
             if name in attributes and specification.has_nested_attributes:
                 attribute = attributes[name]
                 if specification.is_list:
@@ -179,7 +179,7 @@ class SchemaValidator:
         attribute_type = specification.attr_type
         if specification.is_list:
             if not is_list:
-                logger().warning(SchemaValidator._IS_NO_LIST.format(specification.full_name, value_or_values))
+                log().warning(SchemaValidator._IS_NO_LIST.format(specification.full_name, value_or_values))
                 return SchemaValidator._is_compatible_value(attribute_type, value_or_values)
             for value in value_or_values:
                 if not SchemaValidator._is_compatible_value(attribute_type, value):
@@ -280,4 +280,4 @@ class SchemaValidator:
 
         if inactive_agents:
             for agent_id, agent_name in inactive_agents.items():
-                logger().warning(SchemaValidator._MISSING_CONTRACTS_FOR_AGENTS.format(agent_id, agent_name))
+                log().warning(SchemaValidator._MISSING_CONTRACTS_FOR_AGENTS.format(agent_id, agent_name))

fameio/source/writer.py

@@ -1,4 +1,4 @@
-# SPDX-FileCopyrightText: 2023 German Aerospace Center <fame@dlr.de>
+# SPDX-FileCopyrightText: 2024 German Aerospace Center <fame@dlr.de>
 #
 # SPDX-License-Identifier: Apache-2.0
 
@@ -9,8 +9,9 @@ from fameprotobuf.DataStorage_pb2 import DataStorage
 from fameprotobuf.InputFile_pb2 import InputData
 from fameprotobuf.Field_pb2 import NestedField
 from fameprotobuf.Contract_pb2 import ProtoContract
+from fameprotobuf.Model_pb2 import ModelData
 
-from fameio.source.logs import log_error_and_raise, logger
+from fameio.source.logs import log_error_and_raise, log
 from fameio.source.results.reader import Reader
 from fameio.source.scenario import (
     Agent,
@@ -21,6 +22,7 @@ from fameio.source.scenario import (
 )
 from fameio.source.schema import Schema
 from fameio.source.schema.attribute import AttributeSpecs, AttributeType
+from fameio.source.schema.java_packages import JavaPackages
 from fameio.source.series import TimeSeriesManager
 from fameio.source.time import FameTime
 from fameio.source.tools import ensure_is_list
@@ -59,7 +61,7 @@ class ProtoWriter:
 
     def _create_protobuf_from_scenario(self, scenario: Scenario) -> DataStorage:
         """Returns given `scenario` written to new DataStorage protobuf"""
-        logger().info("Converting scenario to protobuf.")
+        log().info("Converting scenario to protobuf.")
         pb_data_storage = DataStorage()
         pb_input = pb_data_storage.input
 
@@ -69,12 +71,13 @@ class ProtoWriter:
         self._set_time_series(pb_input)
         self._set_schema(pb_input, scenario.schema)
 
+        self._set_java_package_names(pb_data_storage.model, scenario.schema.packages)
         return pb_data_storage
 
     @staticmethod
     def _set_general_properties(pb_input: InputData, general_properties: GeneralProperties) -> None:
         """Saves a scenario's general properties to specified protobuf `pb_input` container"""
-        logger().info("Adding General Properties")
+        log().info("Adding General Properties")
         pb_input.runId = general_properties.run_id
         pb_input.simulation.startTime = general_properties.simulation_start_time
         pb_input.simulation.stopTime = general_properties.simulation_stop_time
@@ -84,7 +87,7 @@ class ProtoWriter:
 
     def _add_agents(self, pb_input: InputData, agents: List[Agent], schema: Schema) -> None:
         """Triggers setting of `agents` to `pb_input`"""
-        logger().info("Adding Agents")
+        log().info("Adding Agents")
         for agent in agents:
             pb_agent = self._set_agent(pb_input.agent.add(), agent)
             attribute_specs = schema.agent_types[agent.type_name].attributes
@@ -125,7 +128,7 @@ class ProtoWriter:
             if attribute_specs.is_mandatory:
                 pb_field = self._add_field(pb_parent, name)
                 self._set_attribute(pb_field, attribute_specs.default_value, attribute_specs.attr_type)
-                logger().info(self._USING_DEFAULT.format(name))
+                log().info(self._USING_DEFAULT.format(name))
 
     @staticmethod
     def _add_field(pb_parent: Union[InputData.AgentDao, NestedField], name: str) -> NestedField:
@@ -154,7 +157,7 @@ class ProtoWriter:
     @staticmethod
     def _add_contracts(pb_input: InputData, contracts: List[Contract]) -> None:
         """Triggers setting of `contracts` to `pb_input`"""
-        logger().info("Adding Contracts")
+        log().info("Adding Contracts")
         for contract in contracts:
             pb_contract = ProtoWriter._set_contract(pb_input.contract.add(), contract)
             ProtoWriter._set_contract_attributes(pb_contract, contract.attributes)
@@ -178,7 +181,7 @@ class ProtoWriter:
     ) -> None:
         """Assign (nested) Attributes to given protobuf container `pb_parent`"""
         for name, attribute in attributes.items():
-            logger().debug("Assigning contract attribute `{}`.".format(name))
+            log().debug("Assigning contract attribute `{}`.".format(name))
             pb_field = ProtoWriter._add_field(pb_parent, name)
 
             if attribute.has_value:
@@ -196,7 +199,7 @@ class ProtoWriter:
 
     def _set_time_series(self, pb_input: InputData) -> None:
         """Adds all time series from TimeSeriesManager to given `pb_input`"""
-        logger().info("Adding TimeSeries")
+        log().info("Adding TimeSeries")
         for unique_id, identifier, data in self._time_series_manager.get_all_series():
             pb_series = pb_input.timeSeries.add()
             pb_series.seriesId = unique_id
@@ -213,12 +216,20 @@ class ProtoWriter:
     @staticmethod
     def _set_schema(pb_input: InputData, schema: Schema) -> None:
         """Sets the given `schema` `pb_input`"""
-        logger().info("Adding Schema")
+        log().info("Adding Schema")
         pb_input.schema = schema.to_string()
 
+    @staticmethod
+    def _set_java_package_names(pb_model: ModelData, java_packages: JavaPackages) -> None:
+        """Adds given JavaPackages names to given ModelData section"""
+        pb_packages = pb_model.packages
+        pb_packages.agent.extend(java_packages.agents)
+        pb_packages.dataItem.extend(java_packages.data_items)
+        pb_packages.portable.extend(java_packages.portables)
+
     def _write_protobuf_to_disk(self, pb_data_storage: DataStorage) -> None:
         """Writes given `protobuf_input_data` to disk"""
-        logger().info(self._INFO_WRITING.format(self.file_path))
+        log().info(self._INFO_WRITING.format(self.file_path))
         try:
             with open(self.file_path, "wb") as file:
                 serialised_data_storage = pb_data_storage.SerializeToString()
@@ -227,4 +238,4 @@ class ProtoWriter:
                 file.write(serialised_data_storage)
         except OSError as e:
             log_error_and_raise(ProtoWriterException(ProtoWriter._NO_FILE_SPECIFIED.format(self.file_path), e))
-        logger().info(self._INFO_WRITING_COMPLETED.format(self.file_path))
+        log().info(self._INFO_WRITING_COMPLETED.format(self.file_path))