fameio 2.3.1__py3-none-any.whl → 3.0.0__py3-none-any.whl

fameio/scripts/__init__.py

@@ -4,8 +4,8 @@ import sys
 from fameio.scripts.convert_results import DEFAULT_CONFIG as DEFAULT_CONVERT_CONFIG
 from fameio.scripts.convert_results import run as convert_results
 from fameio.scripts.make_config import run as make_config
-from fameio.source.cli.convert_results import handle_args as handle_convert_results_args
-from fameio.source.cli.make_config import handle_args as handle_make_config_args
+from fameio.cli.convert_results import handle_args as handle_convert_results_args
+from fameio.cli.make_config import handle_args as handle_make_config_args
 
 
 # noinspection PyPep8Naming

fameio/scripts/convert_results.py

@@ -4,18 +4,18 @@ from pathlib import Path
 
 import pandas as pd
 
-from fameio.source.cli.convert_results import handle_args, CLI_DEFAULTS as DEFAULT_CONFIG
-from fameio.source.cli.options import Options
-from fameio.source.cli.parser import update_default_config
-from fameio.source.logs import log_and_raise_critical, fameio_logger, log
-from fameio.source.results.agent_type import AgentTypeLog
-from fameio.source.results.conversion import apply_time_option, apply_time_merging
-from fameio.source.results.csv_writer import CsvWriter
-from fameio.source.results.data_transformer import DataTransformer, INDEX
-from fameio.source.results.input_dao import InputDao
-from fameio.source.results.output_dao import OutputDAO
-from fameio.source.results.reader import Reader
-from fameio.source.results.yaml_writer import data_to_yaml_file
+from fameio.cli.convert_results import handle_args, CLI_DEFAULTS as DEFAULT_CONFIG
+from fameio.cli.options import Options
+from fameio.cli import update_default_config
+from fameio.logs import log_critical_and_raise, fameio_logger, log
+from fameio.output.agent_type import AgentTypeLog
+from fameio.output.conversion import apply_time_option, apply_time_merging
+from fameio.output.csv_writer import CsvWriter
+from fameio.output.data_transformer import DataTransformer, INDEX
+from fameio.output.input_dao import InputDao
+from fameio.output.output_dao import OutputDAO
+from fameio.output.reader import Reader
+from fameio.output.yaml_writer import data_to_yaml_file
 
 ERR_MEMORY_ERROR = "Out of memory. Try using `-m` or `--memory-saving` option."
 ERR_MEMORY_SEVERE = "Out of memory despite memory-saving mode. Reduce output interval in `FAME-Core` and rerun model."
@@ -55,9 +55,10 @@ def run(config: dict = None) -> None:
         if config[Options.INPUT_RECOVERY]:
             log().info("Recovering inputs...")
             timeseries, scenario = input_dao.recover_inputs()
-            series_writer = CsvWriter(Path(config[Options.OUTPUT], "./recovered"), Path("./"), False)
+            base_path = config[Options.OUTPUT] if config[Options.OUTPUT] is not None else "./"
+            series_writer = CsvWriter(Path(base_path, "./recovered"), Path("./"), False)
             series_writer.write_time_series_to_disk(timeseries)
-            data_to_yaml_file(scenario.to_dict(), Path(config[Options.OUTPUT], "./recovered/scenario.yaml"))
+            data_to_yaml_file(scenario.to_dict(), Path(base_path, "./recovered/scenario.yaml"))
 
         if config[Options.MEMORY_SAVING]:
             written_files = output_writer.pop_all_file_paths()
@@ -69,7 +70,7 @@ def run(config: dict = None) -> None:
 
         log().info("Data conversion completed.")
     except MemoryError:
-        log_and_raise_critical(ERR_MEMORY_SEVERE if Options.MEMORY_SAVING else ERR_MEMORY_ERROR)
+        log_critical_and_raise(MemoryError(ERR_MEMORY_SEVERE if Options.MEMORY_SAVING else ERR_MEMORY_ERROR))
 
     file_stream.close()
     if not agent_type_log.has_any_agent_type():

fameio/scripts/make_config.py

@@ -2,14 +2,14 @@
 import sys
 from pathlib import Path
 
-from fameio.source.cli.make_config import handle_args, CLI_DEFAULTS as DEFAULT_CONFIG
-from fameio.source.cli.options import Options
-from fameio.source.cli.parser import update_default_config
-from fameio.source.loader import load_yaml, check_for_yaml_file_type
-from fameio.source.logs import fameio_logger, log
-from fameio.source.scenario import Scenario
-from fameio.source.validator import SchemaValidator
-from fameio.source.writer import ProtoWriter
+from fameio.cli.make_config import handle_args, CLI_DEFAULTS as DEFAULT_CONFIG
+from fameio.cli.options import Options
+from fameio.cli import update_default_config
+from fameio.input.loader import load_yaml, validate_yaml_file_suffix
+from fameio.logs import fameio_logger, log
+from fameio.input.scenario import Scenario
+from fameio.input.validator import SchemaValidator
+from fameio.input.writer import ProtoWriter
 
 
 def run(config: dict = None) -> None:
@@ -18,7 +18,7 @@ def run(config: dict = None) -> None:
     fameio_logger(log_level_name=config[Options.LOG_LEVEL], file_name=config[Options.LOG_FILE])
 
     file = config[Options.FILE]
-    check_for_yaml_file_type(Path(file))
+    validate_yaml_file_suffix(Path(file))
     scenario = Scenario.from_dict(load_yaml(Path(file), encoding=config[Options.INPUT_ENCODING]))
     SchemaValidator.check_agents_have_contracts(scenario)
 

fameio/{source/series.py → series.py}

@@ -5,19 +5,19 @@ import math
 import os
 from enum import Enum, auto
 from pathlib import Path
-from typing import Dict, Union, Tuple, Any, List
+from typing import Union, Any
 
 import pandas as pd
-from fameprotobuf.InputFile_pb2 import InputData
+from fameprotobuf.input_file_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, log
-from fameio.source.time import ConversionException, FameTime
-from fameio.source.tools import clean_up_file_name
+from fameio.input.resolver import PathResolver
+from fameio.logs import log_error_and_raise, log
+from fameio.time import ConversionError, FameTime
+from fameio.tools import clean_up_file_name
 
 
-class TimeSeriesException(Exception):
+class TimeSeriesError(Exception):
     """Indicates that an error occurred during management of time series"""
 
     pass
@@ -50,7 +50,7 @@ class TimeSeriesManager:
     def __init__(self, path_resolver: PathResolver = PathResolver()) -> None:
         self._path_resolver = path_resolver
         self._id_count = -1
-        self._series_by_id: Dict[Union[str, int, float], Dict[Entry, Any]] = {}
+        self._series_by_id: dict[Union[str, int, float], dict[Entry, Any]] = {}
 
     def register_and_validate(self, identifier: Union[str, int, float]) -> None:
         """
@@ -75,7 +75,7 @@ class TimeSeriesManager:
         name, series = self._get_name_and_dataframe(identifier)
         self._series_by_id[identifier] = {Entry.ID: self._id_count, Entry.NAME: name, Entry.DATA: series}
 
-    def _get_name_and_dataframe(self, identifier: Union[str, int, float]) -> Tuple[str, pd.DataFrame]:
+    def _get_name_and_dataframe(self, identifier: Union[str, int, float]) -> tuple[str, pd.DataFrame]:
         """Returns name and DataFrame containing the series obtained from the given `identifier`"""
         if isinstance(identifier, str):
             series_path = self._path_resolver.resolve_series_file_path(Path(identifier).as_posix())
@@ -84,14 +84,14 @@ class TimeSeriesManager:
                 try:
                     return identifier, self._check_and_convert_series(data)
                 except TypeError as e:
-                    log_error_and_raise(TimeSeriesException(self._ERR_CORRUPT_TIME_SERIES_VALUE.format(identifier), e))
-                except ConversionException:
-                    log_error_and_raise(TimeSeriesException(self._ERR_CORRUPT_TIME_SERIES_KEY.format(identifier)))
+                    log_error_and_raise(TimeSeriesError(self._ERR_CORRUPT_TIME_SERIES_VALUE.format(identifier), e))
+                except ConversionError:
+                    log_error_and_raise(TimeSeriesError(self._ERR_CORRUPT_TIME_SERIES_KEY.format(identifier)))
             else:
                 message = self._ERR_FILE_NOT_FOUND.format(identifier)
                 if self._is_number_string(identifier):
                     message += self._ERR_NUMERIC_STRING
-                log_error_and_raise(TimeSeriesException(message))
+                log_error_and_raise(TimeSeriesError(message))
         else:
             return self._create_timeseries_from_value(identifier)
 
@@ -106,7 +106,7 @@ class TimeSeriesManager:
             axis=1,
             result_type="expand",
         )
-        return data
+        return data.astype({0: "int64"})
 
     @staticmethod
     def _assert_valid(value: Any) -> float:
@@ -129,10 +129,10 @@ class TimeSeriesManager:
             return False
 
     @staticmethod
-    def _create_timeseries_from_value(value: Union[int, float]) -> Tuple[str, pd.DataFrame]:
+    def _create_timeseries_from_value(value: Union[int, float]) -> tuple[str, pd.DataFrame]:
         """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))
+            log_error_and_raise(TimeSeriesError(TimeSeriesManager._ERR_NAN_VALUE))
         data = pd.DataFrame({0: [INT64_MIN, INT64_MAX], 1: [value, value]})
         return TimeSeriesManager._CONSTANT_IDENTIFIER.format(value), data
 
@@ -150,29 +150,31 @@ class TimeSeriesManager:
             TimeSeriesException: if identifier was not yet registered
         """
         if not self._time_series_is_registered(identifier):
-            log_error_and_raise(TimeSeriesException(self._ERR_UNREGISTERED_SERIES.format(identifier)))
+            log_error_and_raise(TimeSeriesError(self._ERR_UNREGISTERED_SERIES.format(identifier)))
         return self._series_by_id.get(identifier)[Entry.ID]
 
-    def get_all_series(self) -> List[Tuple[int, str, pd.DataFrame]]:
+    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:
             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:
+    def reconstruct_time_series(self, timeseries: list[InputData.TimeSeriesDao]) -> None:
         """Reconstructs and stores time series from given list of `timeseries_dao`"""
         for one_series in timeseries:
             self._id_count += 1
-            reconstructed = {Entry.ID: one_series.seriesId}
-            if len(one_series.row) == 1:
-                reconstructed[Entry.NAME] = one_series.row[0].value
+            reconstructed = {Entry.ID: one_series.series_id}
+            if len(one_series.values) == 1 or (
+                len(one_series.values) == 2 and one_series.values[0] == one_series.values[1]
+            ):
+                reconstructed[Entry.NAME] = one_series.values[0]
                 reconstructed[Entry.DATA] = None
             else:
-                reconstructed[Entry.NAME] = self._get_cleaned_file_name(one_series.seriesName)
+                reconstructed[Entry.NAME] = self._get_cleaned_file_name(one_series.series_name)
                 reconstructed[Entry.DATA] = pd.DataFrame(
-                    [{self._KEY_ROW_TIME: item.timeStep, self._KEY_ROW_VALUE: item.value} for item in one_series.row]
+                    {self._KEY_ROW_TIME: list(one_series.time_steps), self._KEY_ROW_VALUE: list(one_series.values)}
                 )
-            self._series_by_id[one_series.seriesId] = reconstructed
+            self._series_by_id[one_series.series_id] = reconstructed
 
     def _get_cleaned_file_name(self, timeseries_name: str):
         if timeseries_name.lower().endswith(".csv"):
@@ -185,5 +187,5 @@ class TimeSeriesManager:
         """Return name or path for given `series_id` if series these are identified by their number.
         Use this only if series were added via `reconstruct_time_series`"""
         if series_id < 0 or series_id > self._id_count:
-            log_error_and_raise(TimeSeriesException(self._ERR_UNREGISTERED_SERIES.format(series_id)))
+            log_error_and_raise(TimeSeriesError(self._ERR_UNREGISTERED_SERIES.format(series_id)))
         return self._series_by_id[series_id][Entry.NAME]

fameio/{source/time.py → time.py}

@@ -8,7 +8,7 @@ import re
 from enum import Enum, auto
 from typing import Union
 
-from fameio.source.logs import log_error_and_raise
+from fameio.logs import log_error_and_raise
 
 START_IN_REAL_TIME = "2000-01-01_00:00:00"
 DATE_FORMAT = "%Y-%m-%d_%H:%M:%S"
@@ -16,7 +16,7 @@ DATE_REGEX = re.compile("[0-9]{4}-[0-9]{2}-[0-9]{2}_[0-9]{2}:[0-9]{2}:[0-9]{2}")
 FAME_FIRST_DATETIME = dt.datetime.strptime(START_IN_REAL_TIME, DATE_FORMAT)
 
 
-class ConversionException(Exception):
+class ConversionError(Exception):
     """Indicates that something went wrong during time stamp conversion"""
 
     pass
@@ -75,14 +75,14 @@ class FameTime:
     def convert_datetime_to_fame_time_step(datetime_string: str) -> int:
         """Converts real Datetime string to FAME time step"""
         if not FameTime.is_datetime(datetime_string):
-            log_error_and_raise(ConversionException(FameTime._FORMAT_INVALID.format(datetime_string)))
+            log_error_and_raise(ConversionError(FameTime._FORMAT_INVALID.format(datetime_string)))
         datetime = FameTime._convert_to_datetime(datetime_string)
         years_since_start_time = datetime.year - FAME_FIRST_DATETIME.year
         beginning_of_year = dt.datetime(year=datetime.year, month=1, day=1, hour=0, minute=0, second=0)
         seconds_since_beginning_of_year = int((datetime - beginning_of_year).total_seconds())
         steps_since_beginning_of_year = seconds_since_beginning_of_year * Constants.STEPS_PER_SECOND
         if steps_since_beginning_of_year > Constants.STEPS_PER_YEAR:
-            log_error_and_raise(ConversionException(FameTime._INVALID_TOO_LARGE.format(datetime_string)))
+            log_error_and_raise(ConversionError(FameTime._INVALID_TOO_LARGE.format(datetime_string)))
         year_offset = years_since_start_time * Constants.STEPS_PER_YEAR
         return year_offset + steps_since_beginning_of_year
 
@@ -92,7 +92,7 @@ class FameTime:
         try:
             return dt.datetime.strptime(datetime_string, DATE_FORMAT)
         except ValueError:
-            log_error_and_raise(ConversionException(FameTime._INVALID_TIMESTAMP.format(datetime_string)))
+            log_error_and_raise(ConversionError(FameTime._INVALID_TIMESTAMP.format(datetime_string)))
 
     @staticmethod
     def convert_fame_time_step_to_datetime(fame_time_steps: int, date_format: str = DATE_FORMAT) -> str:
@@ -109,7 +109,7 @@ class FameTime:
         try:
             return datetime.strftime(date_format)
         except ValueError:
-            log_error_and_raise(ConversionException(FameTime._INVALID_DATE_FORMAT.format(date_format)))
+            log_error_and_raise(ConversionError(FameTime._INVALID_DATE_FORMAT.format(date_format)))
 
     @staticmethod
     def convert_time_span_to_fame_time_steps(value: int, unit: TimeUnit) -> int:
@@ -118,7 +118,7 @@ class FameTime:
         if steps:
             return steps * value
         else:
-            log_error_and_raise(ConversionException(FameTime._TIME_UNIT_UNKNOWN.format(unit)))
+            log_error_and_raise(ConversionError(FameTime._TIME_UNIT_UNKNOWN.format(unit)))
 
     @staticmethod
     def is_datetime(string: str) -> bool:
@@ -159,4 +159,4 @@ class FameTime:
             try:
                 return int(value)
             except ValueError:
-                log_error_and_raise(ConversionException(FameTime._NO_TIMESTAMP.format(value)))
+                log_error_and_raise(ConversionError(FameTime._NO_TIMESTAMP.format(value)))

fameio/{source/tools.py → tools.py}

@@ -2,10 +2,10 @@
 #
 # SPDX-License-Identifier: Apache-2.0
 from pathlib import Path
-from typing import Any, Dict, Union
+from typing import Any, Union
 
 
-def keys_to_lower(dictionary: Dict[str, Any]) -> Dict[str, Any]:
+def keys_to_lower(dictionary: dict[str, Any]) -> dict[str, Any]:
     """Returns new dictionary content of given `dictionary` but its top-level `keys` in lower case"""
     return {keys.lower(): value for keys, value in dictionary.items()}