py_canoe 3.0.2__tar.gz → 3.0.3__tar.gz

{py_canoe-3.0.2 → py_canoe-3.0.3}/PKG-INFO

@@ -1,8 +1,7 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.3
 Name: py_canoe
-Version: 3.0.2
+Version: 3.0.3
 Summary: Python CANoe Package
-Home-page: https://github.com/chaitu-ycr/py_canoe
 License: LICENSE
 Keywords: Vector,CANoe,py_canoe
 Author: chaitu-ycr
@@ -20,6 +19,7 @@ Classifier: Programming Language :: Python :: 3.13
 Classifier: Topic :: Software Development :: Embedded Systems
 Requires-Dist: pywin32 (>=306,<=308)
 Project-URL: Documentation, https://chaitu-ycr.github.io/py_canoe/
+Project-URL: Homepage, https://github.com/chaitu-ycr/py_canoe
 Project-URL: Repository, https://github.com/chaitu-ycr/py_canoe
 Description-Content-Type: text/markdown
 
@@ -78,8 +78,7 @@ pip install py_canoe --upgrade
 ### import CANoe module and create CANoe object instance
 
 ```python
-from py_canoe import CANoe
-from time import sleep as wait
+from py_canoe import CANoe, wait
 
 canoe_inst = CANoe()
 ```
@@ -289,3 +288,49 @@ wait(1)
 canoe_inst.stop_measurement()
 ```
 
+### add/remove database
+
+```python
+self.canoe_inst.open(canoe_cfg=self.canoe_cfg_gen_db_setup, visible=True, auto_save=True, prompt_user=False, auto_stop=True)
+self.canoe_inst.start_measurement()
+wait(1)
+# add database
+self.canoe_inst.add_database(fr"{self.file_path}\demo_cfg\DBs\sample_databases\XCP.dbc", 'CAN1', 1)
+# remove database
+self.canoe_inst.remove_database(fr"{self.file_path}\demo_cfg\DBs\sample_databases\XCP.dbc", 1)
+```
+
+### start/stop online measurement setup logging block
+
+```python
+self.canoe_inst.open(canoe_cfg=self.canoe_cfg_online_setup)
+self.canoe_inst.start_measurement()
+wait(1)
+# stop logging block
+self.canoe_inst.start_stop_online_measurement_setup_logging_block(fr'{self.demo_cfg_dir}\Logs\demo_online_setup_log.blf', start=False)
+wait(2)
+# start logging block
+self.canoe_inst.start_stop_online_measurement_setup_logging_block(fr'{self.demo_cfg_dir}\Logs\demo_online_setup_log.blf', start=True)
+```
+
+### working with logging blocks
+
+```python
+# remove current logging blocks
+for i in range(canoe_inst.logging_collection.count):
+    canoe_inst.remove_logging_block(1)  # iteration start from 1 and shifts after each delete
+
+# add a new block
+# define dest path with file format as asc, blf or other
+# may include field functions like {IncMeasurement}
+full_path = "C:/sample_log_{IncMeasurement}.blf"
+canoe_inst.add_logging_block(full_path)
+canoe_inst.start_measurement()
+# ...
+canoe_inst.stop_measurement()
+# log should be fully generated at this point for you to analyze
+canoe_inst.set_configuration_modified(False)  # to avoid popup asking to save changes
+canoe_inst.quit()
+```
+
+

{py_canoe-3.0.2 → py_canoe-3.0.3}/README.md

@@ -53,8 +53,7 @@ pip install py_canoe --upgrade
 ### import CANoe module and create CANoe object instance
 
 ```python
-from py_canoe import CANoe
-from time import sleep as wait
+from py_canoe import CANoe, wait
 
 canoe_inst = CANoe()
 ```
@@ -263,3 +262,49 @@ var_value = canoe_inst.get_environment_variable_value('data_var')
 wait(1)
 canoe_inst.stop_measurement()
 ```
+
+### add/remove database
+
+```python
+self.canoe_inst.open(canoe_cfg=self.canoe_cfg_gen_db_setup, visible=True, auto_save=True, prompt_user=False, auto_stop=True)
+self.canoe_inst.start_measurement()
+wait(1)
+# add database
+self.canoe_inst.add_database(fr"{self.file_path}\demo_cfg\DBs\sample_databases\XCP.dbc", 'CAN1', 1)
+# remove database
+self.canoe_inst.remove_database(fr"{self.file_path}\demo_cfg\DBs\sample_databases\XCP.dbc", 1)
+```
+
+### start/stop online measurement setup logging block
+
+```python
+self.canoe_inst.open(canoe_cfg=self.canoe_cfg_online_setup)
+self.canoe_inst.start_measurement()
+wait(1)
+# stop logging block
+self.canoe_inst.start_stop_online_measurement_setup_logging_block(fr'{self.demo_cfg_dir}\Logs\demo_online_setup_log.blf', start=False)
+wait(2)
+# start logging block
+self.canoe_inst.start_stop_online_measurement_setup_logging_block(fr'{self.demo_cfg_dir}\Logs\demo_online_setup_log.blf', start=True)
+```
+
+### working with logging blocks
+
+```python
+# remove current logging blocks
+for i in range(canoe_inst.logging_collection.count):
+    canoe_inst.remove_logging_block(1)  # iteration start from 1 and shifts after each delete
+
+# add a new block
+# define dest path with file format as asc, blf or other
+# may include field functions like {IncMeasurement}
+full_path = "C:/sample_log_{IncMeasurement}.blf"
+canoe_inst.add_logging_block(full_path)
+canoe_inst.start_measurement()
+# ...
+canoe_inst.stop_measurement()
+# log should be fully generated at this point for you to analyze
+canoe_inst.set_configuration_modified(False)  # to avoid popup asking to save changes
+canoe_inst.quit()
+```
+

py_canoe-3.0.3/py_canoe/__init__.py

@@ -0,0 +1 @@
+from .py_canoe import CANoe, wait

py_canoe-3.0.3/py_canoe/logging_collection.py

@@ -0,0 +1,345 @@
+"""CANoe COM objects related to logging setup"""
+
+import logging
+
+import win32com
+
+logger = logging.getLogger('CANOE_LOG')
+
+
+class LoggingCollection:
+    """Collection of all Logging Blocks of the current configuration."""
+
+    def __init__(self, logging_collection_com):
+        self._com = win32com.client.Dispatch(logging_collection_com)
+
+    @property
+    def count(self) -> int:
+        """This property returns the number of objects inside the collection."""
+        return int(self._com.Count)
+
+    def item(self, index: int) -> "Logging":
+        """This property returns an object from the collection."""
+        return Logging(self._com.Item(index))
+
+    def add(self, full_name: str) -> "Logging":
+        """This method adds a logging block to the Measurement Setup.
+
+        :param full_name: full path to log file as "C:/file.(asc|blf|mf4)", may have
+                          field functions like {IncMeasurement} in the file name
+        """
+        return Logging(self._com.Add(full_name))
+
+    def remove(self, index: int):
+        """This method removes a logging block (Logging) from a logging collection."""
+        self._com.Remove(index)
+
+
+class Logging:
+
+    """The Logging object represents a Logging Block in the current configuration.
+
+    The filename extension of the logging file which is specified with this property
+    determines the logging format. The full name can now also contain field functions;
+    e.g. Logging.FullName = "LOGFILE_M{IncMeasurement}.ASC
+
+    """
+
+    def __init__(self, logging_com):
+        self._com = win32com.client.Dispatch(logging_com)
+
+    @property
+    def exporter(self) -> "Exporter":
+        """This property returns an Exporter object."""
+        return Exporter(self._com.Exporter)
+
+    def file_name_options(self):
+        """This property returns a LoggingFileNameOptions object."""
+        raise NotImplementedError("FileNameOptions access is not implemented yet.")
+
+    def filter(self):
+        """This property returns a LoggingFilter object."""
+        raise NotImplementedError("FileNameOptions access is not implemented yet.")
+
+    @property
+    def full_name(self) -> str:
+        """This property sets or determines the complete path to the logging file."""
+        return self._com.FullName
+
+    @full_name.setter
+    def full_name(self, fullname: str):
+        self._com.FullName = fullname
+
+    @property
+    def trigger(self) -> "Trigger":
+        """This property returns a Trigger object."""
+        return Trigger(self._com.Trigger)
+
+
+class Trigger:
+
+    """Trigger block located before the Logging Block in the Measurement Setup."""
+
+    def __init__(self, trigger_com):
+        self._com = win32com.client.Dispatch(trigger_com)
+
+    @property
+    def active(self) -> bool:
+        """This property sets or returns the status of the trigger."""
+        return self._com.Active
+
+    @active.setter
+    def active(self, _active: bool):
+        self._com.Active = _active
+
+    def start(self):
+        """This method starts the trigger."""
+        self._com.Start()
+
+    def stop(self):
+        """This method stops the trigger."""
+        self._com.Stop()
+
+
+class Exporter:
+
+    """Export dialog.
+
+    The Exporter object represents an export dialog, as it can
+    be used e.g. in a Logging Block in the Measurement Setup.
+
+    """
+
+    def __init__(self, exporter_com):
+        self._com = win32com.client.Dispatch(exporter_com)
+
+    def destinations(self):
+        """Returns a Files object for the destination files of an exporter.
+
+        On the first access to the destination files of an exporter the Files object
+        contains the destination file as it is defined in the according Export dialog.
+
+        If no destination file is set a destination file is derived from the source
+        file. Name and path of this destination file correspond to the name and path
+        of the source file. The format is CSV. If as many destination files as source
+        files are given, an according destination file will be generated for each
+        source file (n to n).
+
+        If the numbers of destination files and source files don't match, the number of
+        destination files must be 1. All source files will be merged into the
+        destination file (n to 1).
+        """
+        raise NotImplementedError("Destinations access is not implemented yet.")
+
+    @property
+    def filter(self) -> "Filter":
+        """Returns a Filter object"""
+        return Filter(self._com.Filter)
+
+    @property
+    def messages(self) -> list["Message"]:
+        """Returns all messages that have been detected during loading.
+
+        Consist of messages that come from the source files of an exporter
+        and can be exported/converted.
+
+        """
+        messages_collection = Messages(self._com.Symbols)
+        messages = []
+        for i in range(1, messages_collection.count + 1):
+            messages.append(messages_collection.item(i))
+        return messages
+
+    def settings(self):
+        """Returns an ExporterSettings object."""
+        raise NotImplementedError("FileNameOptions access is not implemented yet.")
+
+    def sources(self):
+        """Returns Files object for each source file of the exporter or offline source.
+
+        On the first access to the source files of the exporter the Files object
+        contains the source file as defined in the Export dialog.
+
+        Typically this is the logging file as set in the Logging Block, as long as no
+        other source file has been defined manually.
+
+        """
+        raise NotImplementedError("FileNameOptions access is not implemented yet.")
+
+    @property
+    def symbols(self) -> list["ExporterSymbol"]:
+        """Returns all symbols that have been detected during loading the source files.
+
+        This includes signals, system variables and bus statistics information
+        that can be exported/converted.
+
+        """
+        symbols_collection = ExporterSymbols(self._com.Symbols)
+        symbols = []
+        for i in range(1, symbols_collection.count + 1):
+            symbols.append(symbols_collection.item(i))
+        return symbols
+
+    def time_section(self):
+        """Returns the TimeSection object."""
+        raise NotImplementedError("TimeSection access is not implemented yet.")
+
+    def load(self):
+        """Loads source files of an exporter and determines the signals and messages.
+
+        If several source files are set, all signals and messages of all
+        source files are determined.
+
+        """
+        self._com.Load()
+
+    def save(self, no_prompt_user: bool = True):
+        """Starts the export/conversion.
+
+        Although the parameter noPromptUser is set to True, the function will fail
+        if a failure situation occurs and the storage cannot be performed. Possible
+        failure situations are e.g. write-protection or disk full.
+
+        """
+        self._com.Save(noPromptUser=no_prompt_user)
+
+
+class Filter:
+    """Represents a Pass Filter for messages and signals in usage with an exporter."""
+
+    def __init__(self, filter_com):
+        self._com = win32com.client.Dispatch(filter_com)
+
+    @property
+    def count(self) -> int:
+        """This property returns the number of objects inside the collection."""
+        return int(self._com.Count)
+
+    @property
+    def enabled(self) -> bool:
+        """This property activates/deactivates a Filter object or returns its state.
+
+        The initial value of this property is False.
+
+        """
+        return self._com.Enabled
+
+    @enabled.setter
+    def enabled(self, enabled: bool):
+        self._com.Enabled = enabled
+
+    def item(self, index):
+        """This property returns an object from the collection."""
+        raise NotImplementedError("Item access is not implemented yet.")
+
+    def add(self, fullname: str):
+        """This method adds a message or a signal to the explorer's filter.
+
+        The Exporter object needs fully qualified names of all messages and signals
+        that have to be taken into consideration during export or conversion:
+
+            Messages:
+            <DatabaseName>::<MessageName>
+            Signals:
+            <DatabaseName>::<MessageName>::<SignalName>
+            System variables:
+            <Namespace>::<SystemVariable>
+            Environment variables:
+            <DatabaseName>::<EnvironmentVariable>
+
+        When performing a message-oriented conversion only messages, system variables
+        and environment variables are taken into consideration. Any (even specified)
+        signals will be ignored.
+
+        When performing a signal-orientierted export messages, signals, system variables
+        and environment variables are taken into consideration. All signals included in
+        specified messages, system variables and environment variables will be
+        exported as well.
+
+        Besides using their symbolic name messages can be declared by using their
+        numeric ID, which either can be decimal or hexadecimal.
+
+        :param fullname: of the signal or message
+
+        """
+        self._com.Add(fullname)
+
+    def clear(self):
+        """This method clears all messages and signals of the filter."""
+        self._com.Clear()
+
+    def remove(self, index: int):
+        """This method removes a message or a signal from the filter.
+
+        :param index: number
+
+        """
+        self._com.Remove(index)
+
+
+class Messages:
+
+    """Collection of messages."""
+
+    def __init__(self, messages_com):
+        self._com = win32com.client.Dispatch(messages_com)
+
+    @property
+    def count(self) -> int:
+        """This property returns the number of objects inside the collection."""
+        return int(self._com.Count)
+
+    def item(self, index: int) -> "Message":
+        """This property returns an object from the collection."""
+        return Message(self._com.Item(index))
+
+
+class ExporterSymbols:
+
+    """Collection of signals."""
+
+    def __init__(self, symbols_com):
+        self._com = win32com.client.Dispatch(symbols_com)
+
+    @property
+    def count(self) -> int:
+        """This property returns the number of objects inside the collection."""
+        return int(self._com.Count)
+
+    def item(self, index: int) -> "ExporterSymbol":
+        """This property returns an object from the collection."""
+        return ExporterSymbol(self._com.Item(index))
+
+
+class Message:
+
+    """The Message object represents a single message."""
+
+    def __init__(self, message_com):
+        self._com = win32com.client.Dispatch(message_com)
+
+    @property
+    def full_name(self) -> str:
+        """This property determines the fully qualified name of a message.
+
+        The following format is used: <DatabaseName>::<MessageName>
+
+        """
+        return self._com.FullName
+
+
+class ExporterSymbol:
+
+    """Symbol (signal, system variable or bus statistics information).
+
+     Found in a source file, loaded by the Exporter.
+
+     """
+
+    def __init__(self, message_com):
+        self._com = win32com.client.Dispatch(message_com)
+
+    @property
+    def full_name(self) -> str:
+        """This property returns the fully qualified symbol name."""
+        return self._com.FullName

py_canoe-3.0.2/py_canoe/__init__.py → py_canoe-3.0.3/py_canoe/py_canoe.py

@@ -2,12 +2,14 @@
 import os
 import time
 import logging
+
 import pythoncom
 import win32com.client
-from typing import Union
+from typing import Union, Iterable
 from datetime import datetime
 
 # import internal modules here
+from .logging_collection import LoggingCollection, Logging, ExporterSymbol, Message
 from .py_canoe_logger import PyCanoeLogger
 
 
@@ -53,8 +55,8 @@ class CANoe:
 
     def __init_canoe_application_bus(self):
         self.bus_com_obj = win32com.client.Dispatch(self.application_com_obj.Bus)
-        self.bus_databases = win32com.client.Dispatch(self.bus_com_obj.Databases)
-        self.bus_nodes = win32com.client.Dispatch(self.bus_com_obj.Nodes)
+        self.bus_databases_com_obj = win32com.client.Dispatch(self.bus_com_obj.Databases)
+        self.bus_nodes_com_obj = win32com.client.Dispatch(self.bus_com_obj.Nodes)
 
     def __init_canoe_application_capl(self):
         self.capl_obj = lambda: CanoeCapl(self.application_com_obj)
@@ -63,16 +65,18 @@ class CANoe:
         self.configuration_com_obj = win32com.client.Dispatch(self.application_com_obj.Configuration)
         if self.configuration_events_enabled:
             win32com.client.WithEvents(self.configuration_com_obj, CanoeConfigurationEvents)
-        self.configuration_offline_setup = win32com.client.Dispatch(self.configuration_com_obj.OfflineSetup)
-        self.configuration_offline_setup_source = win32com.client.Dispatch(self.configuration_offline_setup.Source)
-        self.configuration_offline_setup_source_sources = win32com.client.Dispatch(self.configuration_offline_setup_source.Sources)
-        sources = self.configuration_offline_setup_source_sources
+        self.configuration_offline_setup_com_obj = win32com.client.Dispatch(self.configuration_com_obj.OfflineSetup)
+        self.configuration_offline_setup_source_com_obj = win32com.client.Dispatch(self.configuration_offline_setup_com_obj.Source)
+        self.configuration_offline_setup_logging_collection = lambda: win32com.client.Dispatch(self.configuration_offline_setup_com_obj.LoggingCollection)
+        self.configuration_offline_setup_source_sources_com_obj = win32com.client.Dispatch(self.configuration_offline_setup_source_com_obj.Sources)
+        sources = self.configuration_offline_setup_source_sources_com_obj
         sources_count = sources.Count + 1
         self.configuration_offline_setup_source_sources_paths = lambda: [sources.Item(index) for index in range(1, sources_count)]
-        self.configuration_online_setup = win32com.client.Dispatch(self.configuration_com_obj.OnlineSetup)
-        self.configuration_online_setup_bus_statistics = win32com.client.Dispatch(self.configuration_online_setup.BusStatistics)
-        self.configuration_online_setup_bus_statistics_bus_statistic = lambda bus_type, channel: win32com.client.Dispatch(self.configuration_online_setup_bus_statistics.BusStatistic(bus_type, channel))
-        self.configuration_general_setup = CanoeConfigurationGeneralSetup(self.configuration_com_obj)
+        self.configuration_online_setup_com_obj = win32com.client.Dispatch(self.configuration_com_obj.OnlineSetup)
+        self.configuration_online_setup_bus_statistics_com_obj = win32com.client.Dispatch(self.configuration_online_setup_com_obj.BusStatistics)
+        self.configuration_online_setup_bus_statistics_bus_statistic = lambda bus_type, channel: win32com.client.Dispatch(self.configuration_online_setup_bus_statistics_com_obj.BusStatistic(bus_type, channel))
+        self.configuration_online_setup_logging_collection = lambda: win32com.client.Dispatch(self.configuration_online_setup_com_obj.LoggingCollection)
+        self.configuration_general_setup_obj = CanoeConfigurationGeneralSetup(self.configuration_com_obj)
         self.configuration_simulation_setup = lambda: CanoeConfigurationSimulationSetup(self.configuration_com_obj)
         self.__replay_blocks = self.configuration_simulation_setup().replay_collection.fetch_replay_blocks()
         self.configuration_test_setup = lambda: CanoeConfigurationTestSetup(self.configuration_com_obj)
@@ -113,6 +117,9 @@ class CANoe:
     def __init_canoe_application_version(self):
         self.version_com_obj = win32com.client.Dispatch(self.application_com_obj.Version)
 
+    def __init_logging_collection(self):
+        self.logging_collection = LoggingCollection(self.configuration_com_obj.OnlineSetup.LoggingCollection)
+
     def new(self, auto_save=False, prompt_user=False) -> None:
         try:
             self.__init_canoe_application()
@@ -155,6 +162,7 @@ class CANoe:
                 self.__init_canoe_application_networks()
                 self.__init_canoe_application_system()
                 self.__init_canoe_application_ui()
+                self.__init_logging_collection()
                 self.__log.debug(f'📢 CANoe configuration successfully opened 🎉')
             else:
                 raise PyCanoeException(f'CANoe configuration "{canoe_cfg}" not found')
@@ -283,7 +291,7 @@ class CANoe:
                 if file_already_added:
                     self.__log.warning(f'⚠️ File "{absolute_log_file_path}" already added as offline source')
                 else:
-                    self.configuration_offline_setup_source_sources.Add(absolute_log_file_path)
+                    self.configuration_offline_setup_source_sources_com_obj.Add(absolute_log_file_path)
                     self.__log.debug(f'📢 File "{absolute_log_file_path}" added as offline source')
                 return True
             else:
@@ -1281,14 +1289,14 @@ class CANoe:
                 self.__log.warning('⚠️ measurement is running. not possible to add database')
                 return False
             else:
-                databases = self.configuration_general_setup.database_setup.databases.fetch_databases()
+                databases = self.configuration_general_setup_obj.database_setup.databases.fetch_databases()
                 if database_file in [database.full_name for database in databases.values()]:
                     self.__log.warning(f'⚠️ database "{database_file}" already added')
                     return False
                 else:
-                    self.configuration_general_setup.database_setup.databases.add_network(database_file, database_network)
+                    self.configuration_general_setup_obj.database_setup.databases.add_network(database_file, database_network)
                     wait(1)
-                    databases = self.configuration_general_setup.database_setup.databases.fetch_databases()
+                    databases = self.configuration_general_setup_obj.database_setup.databases.fetch_databases()
                     for database in databases.values():
                         if database.full_name == database_file:
                             database.channel = database_channel
@@ -1311,7 +1319,7 @@ class CANoe:
                 self.__log.warning('⚠️ measurement is running. not possible to remove database')
                 return False
             else:
-                databases = self.configuration_general_setup.database_setup.databases
+                databases = self.configuration_general_setup_obj.database_setup.databases
                 if database_file not in [database.full_name for database in databases.fetch_databases().values()]:
                     self.__log.warning(f'⚠️ database "{database_file}" not available to remove')
                     return False
@@ -1319,7 +1327,7 @@ class CANoe:
                     for i in range(1, databases.count + 1):
                         database_com_obj = databases.com_obj.Item(i)
                         if database_com_obj.FullName == database_file and database_com_obj.Channel == database_channel:
-                            self.configuration_general_setup.database_setup.databases.remove(i)
+                            self.configuration_general_setup_obj.database_setup.databases.remove(i)
                             wait(1)
                             self.__log.debug(f'👉 database "{database_file}" removed from channel {database_channel}')
                             return True
@@ -1327,6 +1335,81 @@ class CANoe:
             self.__log.error(f'😡 failed to remove database "{database_file}". {e}')
             return False
 
+    def get_logging_blocks(self) -> list[Logging]:
+        """Return all available logging blocks."""
+        blocks = []
+        for i in range(1, self.logging_collection.count + 1):
+            blocks.append(self.logging_collection.item(i))
+        return blocks
+
+    def add_logging_block(self, full_name: str) -> Logging:
+        """Adds new logging block.
+
+        :param full_name: full path to log file as "C:/file.(asc|blf|mf4|...)", may have
+                          field functions like {IncMeasurement} in the file name
+
+        """
+        return self.logging_collection.add(full_name)
+
+    def remove_logging_block(self, index: int) -> None:
+        """Remove logging block at given index.
+
+        Blocks` indexes starts from 1 instead of 0. After one block is removed
+        the rest shift up e.g. having 3 loggers [L1, L2, L3] if we remove index=2
+        the new order will be [L1, L3] with indexes 1 and 2.
+
+        """
+        if index==0:
+            raise ValueError("Logging blocks indexing starts from 1 and not 0.")
+
+        self.logging_collection.remove(index)
+
+    def load_logs_for_exporter(self, logger_index: int) -> None:
+        """Load all source files of exporter and determine symbols/messages.
+
+        :param logger_index: indicates logger and its log files
+        """
+        self.logging_collection.item(logger_index).exporter.load()
+
+    def get_symbols(self, logger_index: int) -> list[ExporterSymbol]:
+        """Return all exporter symbols from given logger."""
+        return self.logging_collection.item(logger_index).exporter.symbols
+
+    def get_messages(self, logger_index: int) -> list[Message]:
+        """Return all messages from given logger."""
+        return self.logging_collection.item(logger_index).exporter.messages
+
+    def add_filters_to_exporter(self, logger_index: int, full_names: Iterable):
+        """Add messages and symbols to exporter filter by their full names.
+
+        :param logger_index: indicates logger
+        :param full_names: of messages and symbols
+
+        """
+        expo_filter = self.logging_collection.item(logger_index).exporter.filter
+        for name in full_names:
+            expo_filter.add(name)
+
+    def start_export(self, logger_index: int):
+        """Starts the export/conversion of exporter.
+
+        :param logger_index: indicates logger
+
+        """
+        self.logging_collection.item(logger_index).exporter.save()
+
+    def set_configuration_modified(self, modified: bool) -> None:
+        """Change status of configuration.
+
+        Modified=False makes it possible to load other config or close
+        the application without the popup "Do you want to save changes?".
+        Without that the application will stop on that popup.
+
+        :param modified: change configuration flag
+
+        """
+        self.configuration_com_obj.Modified = modified
+
 
 def wait(timeout_seconds=0.1):
     """Waits for a specified timeout, pumping Windows messages.

{py_canoe-3.0.2 → py_canoe-3.0.3}/py_canoe/py_canoe_logger.py

@@ -16,17 +16,14 @@ class PyCanoeLogger:
         self.log = logging.getLogger('CANOE_LOG')
         self.log.handlers.clear()
         self.log.propagate = False
-        self.__py_canoe_log_initialization(py_canoe_log_dir)
-
-    def __py_canoe_log_initialization(self, py_canoe_log_dir):
         self.log.setLevel(logging.DEBUG)
-        log_format = logging.Formatter("%(asctime)s [CANOE_LOG] [%(levelname)-4.8s] %(message)s")
-        ch = logging.StreamHandler(sys.stdout)
-        ch.setFormatter(log_format)
-        self.log.addHandler(ch)
+        self.__log_format = logging.Formatter("%(asctime)s [CANOE_LOG] [%(levelname)-4.8s] %(message)s")
+        self.__handler = logging.StreamHandler(sys.stdout)
+        self.__handler.setFormatter(self.__log_format)
+        self.log.addHandler(self.__handler)
         if py_canoe_log_dir != '' and not os.path.exists(py_canoe_log_dir):
             os.makedirs(py_canoe_log_dir, exist_ok=True)
         if os.path.exists(py_canoe_log_dir):
-            fh = handlers.RotatingFileHandler(fr'{py_canoe_log_dir}\py_canoe.log', maxBytes=0, encoding='utf-8')
-            fh.setFormatter(log_format)
-            self.log.addHandler(fh)
+            file_handler = handlers.RotatingFileHandler(fr'{py_canoe_log_dir}\py_canoe.log', maxBytes=0, encoding='utf-8')
+            file_handler.setFormatter(self.__log_format)
+            self.log.addHandler(file_handler)

{py_canoe-3.0.2 → py_canoe-3.0.3}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "py_canoe"
-version = "3.0.2"
+version = "3.0.3"
 description = "Python CANoe Package"
 authors = ["chaitu-ycr <chaitu.ycr@gmail.com>"]
 license = "LICENSE"