EBC-Measurements 0.1__tar.gz

ebc_measurements-0.1/EBC_Measurements.egg-info/PKG-INFO

@@ -0,0 +1,9 @@
+Metadata-Version: 2.1
+Name: EBC_Measurements
+Version: 0.1
+Summary: A tool for different measurement devices
+Home-page: https://github.com/RWTH-EBC/EBC_Measurements
+Author: RWTH Aachen University, E.ON Energy Research Center, Institute for Energy Efficient Buildings and Indoor Climate
+Author-email: ebc-abos@eonerc.rwth-aachen.de
+License: MIT
+License-File: LICENSE

ebc_measurements-0.1/EBC_Measurements.egg-info/SOURCES.txt

@@ -0,0 +1,19 @@
+LICENSE
+README.md
+setup.py
+EBC_Measurements.egg-info/PKG-INFO
+EBC_Measurements.egg-info/SOURCES.txt
+EBC_Measurements.egg-info/dependency_links.txt
+EBC_Measurements.egg-info/top_level.txt
+ebcmeasurements/__init__.py
+ebcmeasurements/Base/Auxiliary.py
+ebcmeasurements/Base/DataLogger.py
+ebcmeasurements/Base/DataOutput.py
+ebcmeasurements/Base/DataSource.py
+ebcmeasurements/Base/DataSourceOutput.py
+ebcmeasurements/Base/__init__.py
+ebcmeasurements/Beckhoff/AdsDataSourceOutput.py
+ebcmeasurements/Beckhoff/__init__.py
+ebcmeasurements/Sensor_Electronic/SensoSysDataSource.py
+ebcmeasurements/Sensor_Electronic/SensoSysDevices.py
+ebcmeasurements/Sensor_Electronic/__init__.py

ebc_measurements-0.1/EBC_Measurements.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

ebc_measurements-0.1/EBC_Measurements.egg-info/top_level.txt

@@ -0,0 +1 @@
+ebcmeasurements

ebc_measurements-0.1/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 RWTH Aachen University - E.ON Energy Research Center - Institute for Energy Efficient Buildings and Indoor Climate
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

ebc_measurements-0.1/PKG-INFO

@@ -0,0 +1,9 @@
+Metadata-Version: 2.1
+Name: EBC_Measurements
+Version: 0.1
+Summary: A tool for different measurement devices
+Home-page: https://github.com/RWTH-EBC/EBC_Measurements
+Author: RWTH Aachen University, E.ON Energy Research Center, Institute for Energy Efficient Buildings and Indoor Climate
+Author-email: ebc-abos@eonerc.rwth-aachen.de
+License: MIT
+License-File: LICENSE

ebc_measurements-0.1/README.md

@@ -0,0 +1,2 @@
+# EBC-Measurements
+Measurement programms for different devices

ebc_measurements-0.1/ebcmeasurements/Base/Auxiliary.py

@@ -0,0 +1,14 @@
+import json
+
+
+def load_json(file_name: str) -> list | dict:
+    """Read a json file"""
+    with open(file_name, 'r') as f:
+        content = json.load(f)
+    return content
+
+
+def dump_json(content: list | dict, file_name: str):
+    """Dump a json file"""
+    with open(file_name, 'w') as f:
+        json.dump(content, f, indent=4)

ebc_measurements-0.1/ebcmeasurements/Base/DataLogger.py

@@ -0,0 +1,312 @@
+"""
+Base module: DataLogger, incl. ABC of DataSource and DataOutput
+"""
+
+from ebcmeasurements.Base import DataSource, DataOutput, DataSourceOutput
+from abc import ABC, abstractmethod
+import time
+import logging
+# Load logging configuration from file
+logger = logging.getLogger(__name__)
+
+
+class DataLoggerBase(ABC):
+    def __init__(
+            self,
+            data_sources_mapping: dict[str: DataSource.DataSourceBase],
+            data_outputs_mapping: dict[str: DataOutput.DataOutputBase],
+            data_rename_mapping: dict[str: dict[str: dict[str: str]]] | None = None,
+            **kwargs
+    ):
+        """
+        Initialize data logger instance
+
+        The format of data_sources_mapping is as follows:
+        {
+            '<source1_name>': instance1 of DataSource,
+            '<source2_name>': instance2 of DataSource,
+            ...
+        }
+
+        The format of data_outputs_mapping is as follows:
+        {
+            '<output1_name>': instance1 of class DataOutput,
+            '<output2_name>': instance2 of class DataOutput,
+            ...
+        }
+
+        The format of data_rename_mapping is as follows:
+        {
+            '<source1_name>': {
+                <'output1_name'>: {
+                    <variable_name_in_source1>: <new_variable_name_in_output1>,
+                    ...
+                },
+                <'output2_name'>: {
+                    <variable_name_in_source1>: <new_variable_name_in_output2>,
+                    ...
+                },
+            },
+            '<source2_name>': {
+                <'output1_name'>: {
+                    <variable_name_in_source2>: <new_variable_name_in_output1>,
+                    ...
+                },
+                <'output2_name'>: {
+                    <variable_name_in_source2>: <new_variable_name_in_output2>,
+                    ...
+                },
+            },
+            ...
+        }
+
+        :param data_sources_mapping: Mapping of multiple data sources
+        :param data_outputs_mapping: Mapping of multiple data outputs
+        :param data_rename_mapping: Mapping of rename for data sources and data outputs, None to use default names
+            provided by data sources
+        :param **kwargs:
+            'data_rename_mapping_explicit': bool: If set True, all variable keys in rename mapping will be checked, if
+            they are available in data source
+        """
+        # Extract all data sources and outputs to dict (values as instance(s)), also for nested class, e.g. Beckhoff
+        self._data_sources_mapping = {
+            k: ds.data_source if isinstance(ds, DataSourceOutput.DataSourceOutputBase) else ds
+            for k, ds in data_sources_mapping.items()
+        }
+        self._data_outputs_mapping = {
+            k: do.data_output if isinstance(do, DataSourceOutput.DataSourceOutputBase) else do
+            for k, do in data_outputs_mapping.items()
+        }
+
+        # Check rename mapping of data sources and outputs
+        if data_rename_mapping is None:
+            self._data_rename_mapping = None
+        else:
+            # Check data source name
+            for ds_name, output_dict in data_rename_mapping.items():
+                if ds_name in self._data_sources_mapping.keys():
+                    # Check data output name
+                    for do_name, mapping in output_dict.items():
+                        if do_name in self._data_outputs_mapping.keys():
+                            # Check mapping keys
+                            if kwargs.get('data_rename_mapping_explicit', False):
+                                for key in mapping.keys():
+                                    if key not in self._data_sources_mapping[ds_name].all_variable_names:
+                                        raise ValueError(
+                                            f"Explicit checking activated: Invalid variable name '{key}' for data "
+                                            f"source '{ds_name}' data output '{do_name}' for rename mapping"
+                                        )
+                        else:
+                            raise ValueError(f"Invalid data output name '{do_name}' for rename mapping")
+                else:
+                    raise ValueError(f"Invalid data source name '{ds_name}' for rename mapping")
+            # Checking complete
+            self._data_rename_mapping = data_rename_mapping
+            logger.info(f"Data rename activated, using mapping: \n{self._data_rename_mapping}")
+
+        # All variable names from all data sources, this will be set to DataOutput
+        if self._data_rename_mapping is None:
+            # Without rename
+            self._all_variable_names_dict = {
+                ds_name: {
+                    do_name: tuple(ds.all_variable_names)  # Origin names without rename
+                    for do_name in self._data_outputs_mapping.keys()
+                }
+                for ds_name, ds in self._data_sources_mapping.items()
+            }
+        else:
+            # With rename
+            self._all_variable_names_dict = {
+                ds_name: {
+                    do_name: tuple(
+                        self._data_rename_mapping.get(ds_name, {}).get(do_name, {}).get(var, var)  # Rename
+                        for var in ds.all_variable_names
+                    )
+                    for do_name in self._data_outputs_mapping.keys()
+                }
+                for ds_name, ds in self._data_sources_mapping.items()
+            }
+
+        # Set all_variable_names for each DataOutput
+        for do_name, do in self._data_outputs_mapping.items():
+            # Collect variable names from all data sources for the current output
+            all_data_sources_all_variable_names = tuple(
+                var_name
+                for ds_name in self._data_sources_mapping.keys()
+                for var_name in self._all_variable_names_dict[ds_name][do_name]
+            )
+
+            if do.log_time_required:
+                # With key of log time
+                do.all_variable_names = (do.key_of_log_time,) + all_data_sources_all_variable_names
+            else:
+                # Without key of log time, only all variable names
+                do.all_variable_names = all_data_sources_all_variable_names
+
+        # Additional methods for DataOutput that must be initialed
+        for do in self._data_outputs_mapping.values():
+            # Csv output
+            if isinstance(do, DataOutput.DataOutputCsv):
+                # Write csv header line
+                do.write_header_line()
+            else:
+                pass
+
+    def read_data_all_sources(self) -> dict[str: dict]:
+        """Read data from all data sources"""
+        return {
+            ds_name: ds.read_data()
+            for ds_name, ds in self._data_sources_mapping.items()
+        }
+
+    def log_data_all_outputs(self, data: dict[str: dict], timestamp: str = None):
+        """Log data to all data outputs"""
+        for do_name, do in self._data_outputs_mapping.items():
+            # Unzip and rename key for the current output
+            if self._data_rename_mapping is None:
+                unzipped_data = {
+                    var: value
+                    for ds_name, ds_data in data.items()
+                    for var, value in ds_data.items()
+                }
+            else:
+                unzipped_data = {
+                    self._data_rename_mapping.get(ds_name, {}).get(do_name, {}).get(var, var): value
+                    for ds_name, ds_data in data.items()
+                    for var, value in ds_data.items()
+                }
+            # Add log time as settings
+            if do.log_time_required:
+                # This data output requires log time
+                if timestamp is None:
+                    raise ValueError(f"The data output '{do}' requires timestamp but got None")
+                else:
+                    # Add timestamp to data
+                    unzipped_data[do.key_of_log_time] = timestamp
+            # Log data to this output
+            logger.debug(f"Logging data: {unzipped_data} to {do}")
+            do.log_data(unzipped_data)  # Log to output
+
+    @abstractmethod
+    def run_data_logging(self, **kwargs):
+        """Run data logging"""
+        pass
+
+    @property
+    def data_sources_mapping(self) -> dict:
+        return self._data_sources_mapping
+
+    @property
+    def data_outputs_mapping(self) -> dict:
+        return self._data_outputs_mapping
+
+
+class DataLoggerTimeTrigger(DataLoggerBase):
+    def __init__(
+            self,
+            data_sources_mapping: dict[str: DataSource.DataSourceBase],
+            data_outputs_mapping: dict[str: DataOutput.DataOutputBase],
+            data_rename_mapping: dict[str: dict[str: dict[str: str]]] | None = None,
+            **kwargs
+    ):
+        """Time triggerd data logger"""
+        logger.info("Initializing DataLoggerTimeTrigger ...")
+        super().__init__(data_sources_mapping, data_outputs_mapping, data_rename_mapping, **kwargs)
+
+    def run_data_logging(self, interval: int | float, duration: int | float | None):
+        """
+        Run data logging
+        :param interval: Log interval in second
+        :param duration: Log duration in second, if None, the duration is infinite
+        """
+        # Check the input
+        if interval <= 0:
+            raise ValueError(f"Logging interval '{interval}' should be greater than 0")
+        if duration is not None:
+            if duration <= 0:
+                raise ValueError(f"Logging duration '{duration}' should be 'None' or a value greater than 0")
+
+        # Init time values
+        start_time = time.time()
+        end_time = None if duration is None else start_time + duration
+        next_log_time = start_time  # Init next logging time
+        log_count = 0  # Init count of logging
+
+        logger.info(f"Starting data logging at time {time.strftime('%Y-%m-%d %H:%M:%S', time.localtime(start_time))}")
+        if end_time is None:
+            logger.info("Estimated end time: infinite")
+        else:
+            logger.info(f"Estimated end time {time.strftime('%Y-%m-%d %H:%M:%S', time.localtime(end_time))}")
+
+        # Logging data
+        try:
+            while end_time is None or time.time() < end_time:
+                # Update next logging time
+                next_log_time += interval
+
+                # Get timestamp
+                timestamp = self.get_timestamp_now()
+
+                # Get data from all sources
+                data = self.read_data_all_sources()
+
+                # Log count
+                log_count += 1  # Update log counter
+                print(f"Logging count(s): {log_count}")  # Print log counter to console
+
+                # Log data to each output
+                self.log_data_all_outputs(data, timestamp)
+
+                # Calculate the time to sleep to maintain the interval
+                sleep_time = next_log_time - time.time()
+                if sleep_time > 0:
+                    logger.debug(f"sleep_time = {sleep_time}")
+                    time.sleep(sleep_time)
+                else:
+                    logger.warning(f"sleep_time = {sleep_time} is negative")
+
+            # Finish data logging
+            logger.info("Data logging completed")
+        except KeyboardInterrupt:
+            logger.warning("Data logging stopped manually")
+
+    @staticmethod
+    def get_timestamp_now() -> str:
+        """Get the timestamp by now"""
+        return time.strftime('%Y-%m-%d %H:%M:%S', time.localtime())
+
+
+if __name__ == "__main__":
+    # Init data sources
+    data_source_1 = DataSource.RandomDataSource(size=5, key_missing_rate=0, value_missing_rate=0.5)
+    data_source_2 = DataSource.RandomStringSource(size=5, str_length=5, key_missing_rate=0.5, value_missing_rate=0.5)
+
+    # Init outputs
+    data_output_1 = DataOutput.DataOutputCsv(file_name='Test/csv_logger_1.csv')
+    data_output_2 = DataOutput.DataOutputCsv(file_name='Test/csv_logger_2.csv', csv_writer_settings={'delimiter': '\t'})
+
+    data_logger = DataLoggerTimeTrigger(
+        data_sources_mapping={
+            'Sou1': data_source_1,
+            'Sou2': data_source_2,
+        },
+        data_outputs_mapping={
+            'Log1': data_output_1,
+            'Log2': data_output_2,
+        },
+        data_rename_mapping={
+            'Sou1': {
+                'Log1': {'RandData0': 'RandData0InLog1'},
+                'Log2': {'RandData1': 'RandData1InLog2', 'RandData2': 'RandData2InLog2'},
+            },
+            'Sou2': {
+                'Log2': {'RandStr0': 'RandStr000'},
+            }
+        }
+    )
+    print(f"Data sources mapping: {data_logger.data_sources_mapping}")
+    print(f"Data outputs mapping: {data_logger.data_outputs_mapping}")
+    data_logger.run_data_logging(
+        interval=2,
+        duration=10
+    )

ebc_measurements-0.1/ebcmeasurements/Base/DataOutput.py

@@ -0,0 +1,124 @@
+"""
+Module Data Output
+
+Data output module will always receive data in type 'dict' from data logger, with keys of variable names.
+"""
+
+from abc import ABC, abstractmethod
+from typing import TypedDict
+import csv
+import os
+import logging.config
+# Load logging configuration from file
+logger = logging.getLogger(__name__)
+
+
+class DataOutputBase(ABC):
+    # Class attribute: key's name for the logged time
+    key_of_log_time = 'LogTime'
+
+    def __init__(self, log_time_required: bool):
+        # Internal variable for property 'all_variable_names'
+        # It should be set by a DataLogger instance via property setter
+        self._all_variable_names: tuple[str, ...] = ()
+
+        # Internal variable for property 'log_time_required'
+        # It should be defined during the initialization
+        self._log_time_required = log_time_required
+
+    @abstractmethod
+    def log_data(self, data: dict):
+        """
+        Log data to output
+
+        This method must be implemented in child class and will be used by the DataLogger to log data to the output
+        """
+        pass
+
+    @staticmethod
+    def generate_dir_of_file(file_name: str):
+        """Generate a directory to save file if it does not exist"""
+        dir_path = os.path.dirname(file_name)
+        if not os.path.exists(dir_path):
+            os.makedirs(dir_path)
+
+    @property
+    def all_variable_names(self) -> tuple[str, ...]:
+        """
+        All possible variable names of this data output
+
+        This property returns a tuple containing the names of all variables that this data output can potentially
+        contain.
+        """
+        return self._all_variable_names
+
+    @all_variable_names.setter
+    def all_variable_names(self, names: tuple[str, ...]):
+        self._all_variable_names = names
+
+    @property
+    def log_time_required(self) -> bool:
+        """If this data output requires log time by data logging"""
+        return self._log_time_required
+
+
+class DataOutputCsv(DataOutputBase):
+    class CsvWriterSettings(TypedDict):
+        """Typed dict for csv writer settings"""
+        delimiter: str
+
+    def __init__(
+            self,
+            file_name: str,
+            csv_writer_settings: dict | None = None
+    ):
+        """
+        Initialize data output instance for csv data
+        :param file_name: File name to save csv data with full path
+        :param csv_writer_settings: Settings of csv writer, supported keys: 'delimiter', if None, use default settings
+        """
+        logger.info("Initializing DataOutputCsv ...")
+
+        super().__init__(log_time_required=True)  # csv file always requires log time
+        self.file_name = file_name
+        self.generate_dir_of_file(self.file_name)  # Generate file path if not exists
+
+        # Set default csv_writer_settings
+        self.csv_writer_settings: 'DataOutputCsv.CsvWriterSettings' = {
+            'delimiter': ';'  # Delimiter of csv-file
+        }
+
+        # Set csv_writer_settings
+        if csv_writer_settings is None:
+            # Use default csv_writer_settings
+            logger.info(f"Using default csv writer settings: {self.csv_writer_settings}")
+        else:
+            # Check all keys in csv_writer_settings
+            for key in csv_writer_settings.keys():
+                if key not in self.csv_writer_settings.keys():
+                    raise ValueError(f"Invalid key in csv_writer_settings: '{key}'")
+            # Update csv_writer_settings
+            self.csv_writer_settings.update(csv_writer_settings)
+            logger.info(f"Using csv writer settings: {self.csv_writer_settings}")
+
+    def log_data(self, data: dict):
+        """Log data to csv"""
+        # Create a data dictionary based on the order of all variable names
+        reordered_data = {k: data.get(k, None) for k in self._all_variable_names}
+        self._append_to_csv(list(reordered_data.values()))  # Append data to csv
+
+    def write_header_line(self):
+        """Write header line as the first row of csv, this method must be called by initializing DataLogger"""
+        self._write_to_csv(list(self._all_variable_names))
+
+    def _write_to_csv(self, row: list):
+        """Write a csv, the existing content in the file is erased as soon as the file is opened"""
+        with open(self.file_name, 'w', newline='') as f:
+            csv_writer = csv.writer(f, **self.csv_writer_settings)
+            csv_writer.writerow(row)
+
+    def _append_to_csv(self, row: list):
+        """Append a new line to csv, the existing content in the file is preserved"""
+        with open(self.file_name, 'a', newline='') as f:
+            csv_writer = csv.writer(f, **self.csv_writer_settings)
+            csv_writer.writerow(row)

ebc_measurements-0.1/ebcmeasurements/Base/DataSource.py

@@ -0,0 +1,103 @@
+"""
+Module Data source
+
+Data source module must always provide data in type 'dict', with keys of variable names.
+"""
+
+from abc import ABC, abstractmethod
+import random
+
+
+class DataSourceBase(ABC):
+    """Base class of data source"""
+    def __init__(self):
+        # Internal variable for property 'all_variable_names'
+        # It should be defined during the initialization, e.g. from a configuration file, from inside the class, or
+        # from reading parameters of all devices. Using tuple to ensure the elements are immutable.
+        self._all_variable_names: tuple[str, ...] = ()
+
+    @abstractmethod
+    def read_data(self) -> dict:
+        """
+        Read data from source
+
+        This method must be implemented in child classes and will be used by the DataLogger to retrieve data.
+        """
+        pass
+
+    @property
+    def all_variable_names(self) -> tuple[str, ...]:
+        """
+        All possible variable names provided by this data source
+
+        This property returns a tuple containing the names of all variables that this data source can potentially
+        provide.
+        """
+        return self._all_variable_names
+
+
+class RandomDataSource(DataSourceBase):
+    def __init__(self, size: int = 10, key_missing_rate: float = 0.5, value_missing_rate: float = 0.5):
+        """
+        Random data source to simulate data generation
+        :param size: Number of variables to generate
+        :param key_missing_rate: Probability of a key being excluded from the final dictionary
+        :param value_missing_rate: Probability of assigning None to a value instead of a random float
+        """
+        super().__init__()
+        if not (0.0 <= key_missing_rate <= 1.0):
+            raise ValueError(f"key_missing_rate '{key_missing_rate}' must be between 0.0 and 1.0")
+        if not (0.0 <= value_missing_rate <= 1.0):
+            raise ValueError(f"value_missing_rate '{value_missing_rate}' must be between 0.0 and 1.0")
+
+        self.size = size
+        self.key_missing_rate = key_missing_rate
+        self.value_missing_rate = value_missing_rate
+        self._all_variable_names = tuple(f'RandData{n}' for n in range(self.size))  # Define all data names
+
+    def read_data(self) -> dict:
+        """Generate random data for each variable name, randomly drop some keys, and randomly insert None values"""
+        return {
+            name: (None if random.random() < self.value_missing_rate else random.uniform(0.0, 100.0))
+            for name in self._all_variable_names
+            if random.random() >= self.key_missing_rate
+        }
+
+
+class RandomStringSource(RandomDataSource):
+    def __init__(
+            self, size: int = 10, str_length: int = 5, key_missing_rate: float = 0.5, value_missing_rate: float = 0.5):
+        """
+        Random string source to simulate data generation
+        :param size: Number of variables to generate
+        :param str_length: Length of each random string
+        :param key_missing_rate: Probability of a key being excluded from the final dictionary
+        :param value_missing_rate: Probability of assigning None to a value instead of a random float
+        """
+        super().__init__(size, key_missing_rate, value_missing_rate)
+        self.str_length = str_length
+        self._all_variable_names = tuple(f'RandStr{n}' for n in range(self.size))  # Re-define all data names
+
+    def read_data(self) -> dict:
+        def generate_random_string(length: int) -> str:
+            """Generate random string with defined length"""
+            chars = '1234567890AaBbCcDdEeFf'
+            return ''.join(random.choice(chars) for _ in range(length))
+
+        return {
+            name: (None if random.random() < self.value_missing_rate else generate_random_string(self.str_length))
+            for name in self._all_variable_names
+            if random.random() >= self.key_missing_rate
+        }
+
+
+if __name__ == "__main__":
+    random_data_source = RandomDataSource(size=10, key_missing_rate=0.5, value_missing_rate=0.5)
+    print(f"All variable names of random data source: {random_data_source.all_variable_names}")
+    for _ in range(10):
+        print(random_data_source.read_data())
+
+    random_str_source = RandomStringSource(size=10, str_length=8, key_missing_rate=0.5, value_missing_rate=0.5)
+    print(f"All variable names of random string source: {random_str_source.all_variable_names}")
+    for _ in range(10):
+        print(random_str_source.read_data())

ebc_measurements-0.1/ebcmeasurements/Base/DataSourceOutput.py

@@ -0,0 +1,50 @@
+"""
+Module Data source output
+
+Data source output is for system that contains source (for read data) and output (for log data) via one system
+interface, e.g. Beckhoff PLC (ADS interface), MQTT (client interface)
+"""
+
+from abc import ABC
+from ebcmeasurements.Base import DataSource, DataOutput
+from typing import Optional
+import os
+import logging.config
+# Load logging configuration from file
+logger = logging.getLogger(__name__)
+
+
+class DataSourceOutputBase(ABC):
+    """Base class of data source output"""
+    class SystemDataSource(DataSource.DataSourceBase, ABC):
+        """Nested class for data source operation"""
+        def __init__(self, system: Optional[object]):
+            super().__init__()
+            self.system = system
+
+    class SystemDataOutput(DataOutput.DataOutputBase, ABC):
+        """Nested class for data output operation"""
+        def __init__(self, system: Optional[object], log_time_required: Optional[bool]):
+            super().__init__(log_time_required)
+            self.system = system
+
+    def __init__(self):
+        self.system: object = None  # System of data source and data output
+        self._data_source: Optional[DataSourceOutputBase.SystemDataSource] = None
+        self._data_output: Optional[DataSourceOutputBase.SystemDataOutput] = None
+
+    @property
+    def data_source(self) -> 'DataSourceOutputBase.SystemDataSource':
+        """Instance of SystemDataSource, initialized on first access"""
+        if self._data_source is None:
+            # Lazy initialization with properties
+            self._data_source = self.SystemDataSource(system=self.system)
+        return self._data_source
+
+    @property
+    def data_output(self) -> 'DataSourceOutputBase.SystemDataOutput':
+        """Instance of SystemDataOutput, initialized on first access"""
+        if self._data_output is None:
+            # Lazy initialization with properties
+            self._data_output = self.SystemDataOutput(system=self.system, log_time_required=None)
+        return self._data_output