atomicshop 2.16.10__py3-none-any.whl → 2.16.12__py3-none-any.whl

atomicshop/ssh_remote.py

@@ -126,24 +126,24 @@ class SSHRemote:
         except paramiko.ssh_exception.NoValidConnectionsError as e:
             error = str(e)
             # Logging the error also. Since the process name isn't critical, we'll continue script execution.
-            print_api(error, logger=self.logger, logger_method='error', traceback_string=True, oneline=True)
+            print_api(error, logger=self.logger, logger_method='error', traceback_string=True)
             pass
         except paramiko.ssh_exception.SSHException as e:
             error = str(e)
             # Logging the error also. Since the process name isn't critical, we'll continue script execution.
-            print_api(error, logger=self.logger, logger_method='error', traceback_string=True, oneline=True)
+            print_api(error, logger=self.logger, logger_method='error', traceback_string=True)
             pass
         except ConnectionResetError:
             # Returning the error.
             error = "An existing connection was forcibly closed by the remote host."
             # Logging the error also. Since the process name isn't critical, we'll continue script execution.
-            print_api(error, logger=self.logger, logger_method='error', traceback_string=True, oneline=True)
+            print_api(error, logger=self.logger, logger_method='error', traceback_string=True)
             pass
         except TimeoutError:
             # Returning the error.
             error = "Connection timed out."
             # Logging the error also. Since the process name isn't critical, we'll continue script execution.
-            print_api(error, logger=self.logger, logger_method='error', traceback_string=True, oneline=True)
+            print_api(error, logger=self.logger, logger_method='error', traceback_string=True)
             pass
 
         return error
@@ -165,24 +165,24 @@ class SSHRemote:
         except AttributeError as function_exception_object:
             if function_exception_object.name == "open_session":
                 result_exception = "'SSHRemote().connect' wasn't executed."
-                print_api(result_exception, logger=self.logger, logger_method='error', traceback_string=True, oneline=True)
+                print_api(result_exception, logger=self.logger, logger_method='error', traceback_string=True)
 
                 # Since getting Process name is not the main feature of the server, we can pass the exception
                 pass
             else:
                 result_exception = f"Couldn't execute script over SSH. Unknown yet exception with 'AttributeError' " \
                                    f"and name: {function_exception_object.name}"
-                print_api(result_exception, logger=self.logger, logger_method='error', traceback_string=True, oneline=True)
+                print_api(result_exception, logger=self.logger, logger_method='error', traceback_string=True)
                 # Since getting Process name is not the main feature of the server, we can pass the exception
                 pass
         except socket.error:
             result_exception = "Couldn't execute script over SSH. SSH socket closed."
-            print_api(result_exception, logger=self.logger, logger_method='error', traceback_string=True, oneline=True)
+            print_api(result_exception, logger=self.logger, logger_method='error', traceback_string=True)
             # Since getting Process name is not the main feature of the server, we can pass the exception
             pass
         except Exception:
             result_exception = "Couldn't execute script over SSH. Unknown yet exception."
-            print_api(result_exception, logger=self.logger, logger_method='error', traceback_string=True, oneline=True)
+            print_api(result_exception, logger=self.logger, logger_method='error', traceback_string=True)
             # Since getting Process name is not the main feature of the server, we can pass the exception
             pass
 
@@ -334,7 +334,7 @@ class SSHRemote:
             # Basically we don't care much about SSH exceptions. Just log them and pass to record.
             except Exception as function_exception_object:
                 execution_error = function_exception_object
-                print_api(execution_error, logger=self.logger, logger_method='error', traceback_string=True, oneline=True)
+                print_api(execution_error, logger=self.logger, logger_method='error', traceback_string=True)
                 pass
 
             # Closing SSH connection at this stage.

atomicshop/wrappers/factw/install/pre_install_and_install_before_restart.py

@@ -66,7 +66,7 @@ def install_before_restart(
 
     if not fact_source_archive_path:
         # Download the FACT_core repo.
-        if not filesystem.get_file_paths_from_directory(installation_directory):
+        if not filesystem.get_paths_from_directory(installation_directory, get_file=True):
             git_wrapper = githubw.GitHubWrapper(repo_url=config_install.FACT_CORE_GITHUB_URL)
             git_wrapper.build_links_from_repo_url()
             git_wrapper.download_and_extract_branch(

atomicshop/wrappers/loggingw/reading.py

@@ -4,18 +4,12 @@ from pathlib import Path
 import datetime
 
 from ... import filesystem, datetimes
-from ...basics import booleans
+from ...basics import booleans, list_of_classes
 from ...file_io import csvs
 
 
-class LogReaderTimeCouldntBeFoundInFileNameError(Exception):
-    pass
-
-
 def get_logs_paths(
-        log_files_directory_path: str = None,
-        log_file_path: str = None,
-        file_name_pattern: str = '*.*',
+        log_file_path: str,
         date_format: str = None,
         latest_only: bool = False,
         previous_day_only: bool = False,
@@ -24,8 +18,6 @@ def get_logs_paths(
     """
     This function gets the logs file paths from the directory. Supports rotating files to get the logs by time.
 
-    :param log_files_directory_path: Path to the log files. If specified, the function will get all the files from the
-        directory by the 'file_name_pattern'.
     :param log_file_path: Path to the log file. If specified, the function will get the file and all the rotated logs
         associated with this file. The 'file_name_pattern' will become the file name using the file name and extension.
 
@@ -37,8 +29,6 @@ def get_logs_paths(
 
         # The 'log_files_directory_path' will also be taken from the 'log_file_path':
         log_files_directory_path = 'C:/logs'
-    :param file_name_pattern: Pattern to match the log files names.
-        Default file_name_pattern will match all the files.
     :param date_format: date format string pattern to match the date in the log file name.
         If specified, the function will get the log file by the date pattern.
         If not specified, the function will get the file date by file last modified time.
@@ -53,11 +43,6 @@ def get_logs_paths(
 
     """
 
-    if not log_files_directory_path and not log_file_path:
-        raise ValueError('Either "log_files_directory_path" or "log_file_path" must be specified.')
-    elif log_files_directory_path and log_file_path:
-        raise ValueError('Both "log_files_directory_path" and "log_file_path" cannot be specified at the same time.')
-
     if latest_only or previous_day_only or specific_date:
         booleans.check_3_booleans_when_only_1_can_be_true(
                 (latest_only, 'latest_only'),
@@ -67,73 +52,63 @@ def get_logs_paths(
     if not date_format and specific_date:
         raise ValueError('If "specific_date" is specified, "date_format" must be specified.')
 
-    # If log file path is specified, get the file_name_pattern from the file name.
-    if log_file_path:
-        # Build the file_name_pattern.
-        log_file_name: str = Path(log_file_path).stem
-        log_file_extension: str = Path(log_file_path).suffix
-        file_name_pattern = f'{log_file_name}*{log_file_extension}'
+    # Get the file_name_pattern from the file name. Build the file_name_pattern.
+    log_file_name: str = Path(log_file_path).stem
+    log_file_extension: str = Path(log_file_path).suffix
+    file_name_pattern: str = f'{log_file_name}*{log_file_extension}'
 
-        # Get the directory path from the file path.
-        log_files_directory_path = Path(log_file_path).parent
+    # Get the directory path from the file path.
+    log_files_directory_path: str = str(Path(log_file_path).parent)
 
-    # Get all the log file paths by the file_name_pattern.
-    logs_files: list = filesystem.get_file_paths_from_directory(
+    # Get all the log file paths by the file_name_pattern and the date_format string.
+    logs_files: list = filesystem.get_paths_from_directory(
         log_files_directory_path,
+        get_file=True,
         file_name_check_pattern=file_name_pattern,
         add_last_modified_time=True,
-        sort_by_last_modified_time=True)
+        sort_by_last_modified_time=True,
+        datetime_format=date_format
+    )
+
+    # The above will not include the latest log file if it is not rotated yet.
+    # noinspection PyTypeChecker
+    last_log_file_atomic_path: filesystem.AtomicPath = None
+    if os.path.isfile(log_file_path):
+        last_log_file_atomic_path = filesystem.AtomicPath(log_file_path)
+        last_log_file_atomic_path.update(update_last_modified=True)
+
+    if logs_files and last_log_file_atomic_path and date_format:
+        # The problem here is the file name that doesn't contain the date string in the name.
+        # If it is regular log rotation, then there will be one file that doesn't have the date string in the name.
+        # If the function used to get the previous day log, then there will be no file that doesn't have the date
+        # string.
+
+        # Get the latest timestamp from the files with dates.
+        latest_datetime_float: float = 0
+        for file_index, single_file in enumerate(logs_files):
+            if single_file.datetime_float > latest_datetime_float:
+                latest_datetime_float = single_file.datetime_float
+
+        # We will add one day to the latest date that we found and assign to the latest file in rotation
+        # which is without the datetime string.
+        latest_datetime_float += 86400
+        last_log_file_atomic_path.datetime_float = latest_datetime_float
+        last_log_file_atomic_path.datetime_datetime = datetime.datetime.fromtimestamp(latest_datetime_float)
+        last_log_file_atomic_path.datetime_string = (
+            last_log_file_atomic_path.datetime_datetime.strftime(date_format))
+        last_log_file_atomic_path.datetime_format = date_format
+
+        # Add the last log file to the list.
+        logs_files.append(last_log_file_atomic_path)
+
+        # Sort the files by the last modified time.
+        logs_files = list_of_classes.sort_by_attributes(logs_files, ['datetime_float'])
+    elif last_log_file_atomic_path and logs_files and not date_format:
+        logs_files.append(last_log_file_atomic_path)
+    elif last_log_file_atomic_path and not logs_files:
+        logs_files = [last_log_file_atomic_path]
 
-    # Get the datetime object from the first file name by the date pattern.
-    first_date_string = None
     if logs_files:
-        first_file_name: str = Path(logs_files[0]['file_path']).name
-        first_datetime_object, first_date_string, first_timestamp_float = (
-            datetimes.get_datetime_from_complex_string_by_pattern(first_file_name, date_format))
-
-    # The problem here is the file name that doesn't contain the date string in the name.
-    # If it is regular log rotation, then there will be one file that doesn't have the date string in the name.
-    # If the function used to get the previous day log, then there will be no file that doesn't have the date string.
-    if len(logs_files) > 1 or (len(logs_files) == 1 and first_date_string):
-        if date_format:
-            latest_timestamp: float = 0
-            for file_index, single_file in enumerate(logs_files):
-                # Get file name from current loop file path.
-                current_file_name: str = Path(single_file['file_path']).name
-                logs_files[file_index]['file_name'] = current_file_name
-
-                # Get the datetime object from the file name by the date format pattern.
-                datetime_object, date_string, timestamp_float = (
-                    datetimes.get_datetime_from_complex_string_by_pattern(current_file_name, date_format))
-
-                # Update the last modified time to the dictionary.
-                logs_files[file_index]['last_modified'] = timestamp_float
-                logs_files[file_index]['datetime'] = datetime_object
-                logs_files[file_index]['date_string'] = date_string
-
-                if timestamp_float and timestamp_float > latest_timestamp:
-                    latest_timestamp = timestamp_float
-
-            # Check timestamps, if more than 1 file is None, then the function that gets the date from the file name
-            # didn't work properly, probably because of the string datetime format or the filenames.
-            none_timestamps = [single_file['last_modified'] for single_file in logs_files].count(None)
-            if none_timestamps > 1:
-                raise LogReaderTimeCouldntBeFoundInFileNameError(
-                    'The date pattern could not be found in the file name. Check the date pattern and the file names.')
-
-            # Now, there should be a file that doesn't have the string date pattern in the file name.
-            # We will add one day to the latest date that we found and assign to that file path.
-            for file_index, single_file in enumerate(logs_files):
-                if single_file['last_modified'] is None:
-                    latest_timestamp += 86400
-                    logs_files[file_index]['last_modified'] = latest_timestamp
-                    logs_files[file_index]['datetime'] = datetime.datetime.fromtimestamp(latest_timestamp)
-                    logs_files[file_index]['date_string'] = logs_files[file_index]['datetime'].strftime(date_format)
-                    break
-
-            # Sort the files by the last modified time.
-            logs_files = sorted(logs_files, key=lambda x: x['last_modified'], reverse=False)
-
         if latest_only:
             logs_files = [logs_files[-1]]
 
@@ -146,19 +121,13 @@ def get_logs_paths(
 
         if specific_date:
             # Check if there is a specific date log file.
-            logs_files = [single_file for single_file in logs_files if single_file['date_string'] == specific_date]
-    # If there is only one file, meaning it is the current day log.
-    # If the 'previous_day_only' is True, then there are no previous day logs to output.
-    elif len(logs_files) == 1 and previous_day_only:
-        logs_files = []
+            logs_files = [single_file for single_file in logs_files if single_file.datetime_string == specific_date]
 
     return logs_files
 
 
 def get_all_log_files_into_list(
-        log_files_directory_path: str = None,
         log_file_path: str = None,
-        file_name_pattern: str = '*.*',
         date_format: str = None,
         log_type: Literal['csv'] = 'csv',
         header_type_of_files: Literal['first', 'all'] = 'first',
@@ -170,10 +139,7 @@ def get_all_log_files_into_list(
     This function gets the logs contents from the log files. Supports rotating files to get the logs by time.
     All the contents will be merged into one list.
 
-    :param log_files_directory_path: Path to the log files. Check the 'get_logs_paths' function for more details.
     :param log_file_path: Path to the log file. Check the 'get_logs_paths' function for more details.
-    :param file_name_pattern: Pattern to match the log files names.
-        Default file_name_pattern will match all the files.
     :param date_format: date format string pattern to match the date in the log file name.
         If specified, the function will get the log file by the date pattern.
         If not specified, the function will get the file date by file last modified time.
@@ -202,9 +168,7 @@ def get_all_log_files_into_list(
 
     # Get all the log file paths by the file_name_pattern.
     logs_files: list = get_logs_paths(
-        log_files_directory_path=log_files_directory_path,
         log_file_path=log_file_path,
-        file_name_pattern=file_name_pattern,
         date_format=date_format)
 
     # Read all the logs.
@@ -213,13 +177,13 @@ def get_all_log_files_into_list(
     for single_file in logs_files:
         if log_type == 'csv':
             if header_type_of_files == 'all':
-                csv_content, _ = csvs.read_csv_to_list_of_dicts_by_header(single_file['file_path'], **print_kwargs)
+                csv_content, _ = csvs.read_csv_to_list_of_dicts_by_header(single_file.path, **print_kwargs)
                 logs_content.extend(csv_content)
             elif header_type_of_files == 'first':
                 # The function gets empty header to read it from the CSV file, the returns the header that it read.
                 # Then each time the header is fed once again to the function.
                 csv_content, header = csvs.read_csv_to_list_of_dicts_by_header(
-                    single_file['file_path'], header=header, **print_kwargs)
+                    single_file.path, header=header, **print_kwargs)
                 # Any way the first file will be read with header.
                 logs_content.extend(csv_content)
 
@@ -230,7 +194,7 @@ def get_all_log_files_into_list(
     if remove_logs:
         # Remove the statistics files.
         for single_file in logs_files:
-            filesystem.remove_file(single_file['file_path'])
+            filesystem.remove_file(single_file.path)
 
     if move_to_path:
         # Get formatted time stamp for file name.
@@ -243,9 +207,8 @@ def get_all_log_files_into_list(
         filesystem.create_directory(move_to_path_with_timestamp)
         # Move the statistics files.
         for single_file in logs_files:
-            single_file_name = filesystem.get_file_name(single_file['file_path'])
-            move_to_path_with_file = f'{move_to_path_with_timestamp}{os.sep}{single_file_name}'
-            filesystem.move_file(single_file['file_path'], move_to_path_with_file)
+            move_to_path_with_file = f'{move_to_path_with_timestamp}{os.sep}{single_file.name}'
+            filesystem.move_file(single_file.path, move_to_path_with_file)
 
     return logs_content
 
@@ -301,9 +264,9 @@ class LogReader:
         :param log_type: Type of log to get.
         :param get_previous_file: Boolean, if True, the function will get the previous log file.
             For example, your log is set to rotate every Midnight.
-            Meaning, once the day will change, the function will get the log file from the previous day in the third entry
-            of the return tuple. This happens only once each 24 hours. Not from the time the function was called, but from
-            the time the day changed.
+            Meaning, once the day will change, the function will get the log file from the previous day in the
+            third entry of the return tuple. This happens only once each 24 hours. Not from the time
+            the function was called, but from the time the day changed.
         :param header: List of strings that will be the header of the CSV file. Default is 'None'.
             None: the header from the CSV file will be used. The first row of the CSV file will be the header.
                 Meaning, that the first line will be skipped and the second line will be the first row of the content.
@@ -362,7 +325,7 @@ class LogReader:
         # if not latest_statistics_file_path_object:
         #     return [], [], self.header
 
-        latest_statistics_file_path: str = latest_statistics_file_path_object[0]['file_path']
+        latest_statistics_file_path: str = latest_statistics_file_path_object[0].path
 
         # Get the previous day statistics file path.
         previous_day_statistics_file_path: Union[str, None] = None
@@ -371,7 +334,7 @@ class LogReader:
                 log_file_path=self.log_file_path,
                 date_format=self.date_format,
                 previous_day_only=True
-            )[0]['file_path']
+            )[0].path
         # If you get IndexError, it means that there are no previous day logs to read.
         except IndexError:
             pass

atomicshop/wrappers/pywin32w/wmis/helpers.py

@@ -114,7 +114,11 @@ def call_method(
     # Check if the method executed successfully.
     for result in results:
         if result != 0:
-            raise WmiMethodExecutionError(f"Failed to execute method '{method_name}' with error code: {result}")
+            if result == 91:
+                raise PermissionError(f"Failed to execute method '{method_name}' with error code: {result}, "
+                                      f"Try with Admin rights.")
+            else:
+                raise WmiMethodExecutionError(f"Failed to execute method '{method_name}' with error code: {result}")
 
 
 """

atomicshop/wrappers/pywin32w/wmis/win32networkadapter.py

@@ -133,35 +133,3 @@ def set_dns_server(
 
     # Set DNS servers
     helpers.call_method(adapter_config, 'SetDNSServerSearchOrder', dns_servers)
-
-
-def is_adapter_dns_gateway_from_dhcp(
-        use_default_interface: bool = False,
-        connection_name: str = None,
-        mac_address: str = None
-) -> bool:
-    """
-    Check if the adapter is set to obtain the DNS servers automatically from DHCP.
-    :param use_default_interface: bool, if True, the default network interface will be used.
-        This is the adapter that your internet is being used from.
-    :param connection_name: string, adapter name as shown in the network settings.
-    :param mac_address: string, MAC address of the adapter. Format: '00:00:00:00:00:00'.
-    :return: bool, True if DHCP is enabled, False otherwise.
-    """
-
-    adapter_config, current_adapter = get_wmi_network_configuration(
-        use_default_interface=use_default_interface, connection_name=connection_name, mac_address=mac_address)
-
-    # If DHCP is not enabled.
-    if not adapter_config.DHCPEnabled:
-        # Then it is obvious that DNS Gateway is also Statis.
-        return False
-    # If DHCP is enabled.
-    else:
-        # Then we need to check if Default IP gateway is the same as DNS Gateway, if so.
-        if adapter_config.DefaultIPGateway == adapter_config.DNSServerSearchOrder:
-            # Then it is set dynamically from DHCP.
-            return True
-        else:
-            # If not, so it is static.
-            return False

atomicshop/wrappers/socketw/dns_server.py

@@ -230,17 +230,16 @@ class DnsServer:
                     # This error happens when the client closes the connection before the server.
                     # This is not an error for a DNS Server, but we'll log it anyway only with the full DNS logger.
                     message = "Error: to receive DNS request, An existing connection was forcibly closed"
-                    # print_api(message, logger=self.logger, logger_method='error', traceback_string=True, oneline=True)
+                    # print_api(message, logger=self.logger, logger_method='error', traceback_string=True)
                     print_api(
-                        message, logger=self.dns_full_logger, logger_method='error', traceback_string=True,
-                        oneline=True)
+                        message, logger=self.dns_full_logger, logger_method='error', traceback_string=True)
                     self.dns_full_logger.info("==========")
                     pass
                     continue
                 except Exception:
                     message = "Unknown Exception: to receive DNS request"
                     print_api(
-                        message, logger=self.logger, logger_method='critical', traceback_string=True, oneline=True)
+                        message, logger=self.logger, logger_method='critical', traceback_string=True)
                     self.logger.info("==========")
                     pass
                     continue
@@ -417,9 +416,9 @@ class DnsServer:
                                 except ValueError:
                                     message = f"Looks like wrong type of response for QTYPE: {qtype_string}. Response: "
                                     print_api(message, logger=self.logger, logger_method='critical',
-                                              traceback_string=True, oneline=True)
+                                              traceback_string=True)
                                     print_api(f"{dns_built_response}", logger=self.logger, logger_method='critical',
-                                              traceback_string=True, oneline=True)
+                                              traceback_string=True)
                                     # Pass the exception.
                                     pass
                                     # Continue to the next DNS request, since there's nothing to do here right now.
@@ -430,9 +429,9 @@ class DnsServer:
                                         (f"Unknown exception while creating response for QTYPE: {qtype_string}. "
                                          f"Response: ")
                                     print_api(message, logger=self.logger, logger_method='critical',
-                                              traceback_string=True, oneline=True)
+                                              traceback_string=True)
                                     print_api(f"{dns_built_response}", logger=self.logger, logger_method='critical',
-                                              traceback_string=True, oneline=True)
+                                              traceback_string=True)
                                     # Pass the exception.
                                     pass
                                     # Continue to the next DNS request, since there's nothing to do here right now.
@@ -479,7 +478,7 @@ class DnsServer:
                                             google_dns_ipv4_socket.recvfrom(self.buffer_size_receive)
                                     except TimeoutError as function_exception_object:
                                         print_api(function_exception_object, logger=self.logger, logger_method='error',
-                                                  traceback_string=True, oneline=True)
+                                                  traceback_string=True)
                                         google_dns_ipv4_socket.close()
                                         counter += 1
                                         # Pass the exception.
@@ -725,7 +724,7 @@ class DnsServer:
                 except Exception:
                     message = "Unknown Exception: to parse DNS request"
                     print_api(
-                        message, logger=self.logger, logger_method='critical', traceback_string=True, oneline=True)
+                        message, logger=self.logger, logger_method='critical', traceback_string=True)
                     self.logger.info("==========")
                     pass
                     continue

atomicshop/wrappers/socketw/exception_wrapper.py

@@ -27,14 +27,12 @@ def connection_exception_decorator(function_name):
             message = f"Socket Accept: {kwargs['domain_from_dns_server']}:{port}: " \
                       f"* Established connection was aborted by software on the host..."
             wrapper_handle_connection_exceptions.message = message
-            print_api(message, logger_method='error', traceback_string=True, **kwargs['print_kwargs'])
-            pass
+            print_api(message, logger_method='error', traceback_string=True, oneline=True, **kwargs['print_kwargs'])
         except ConnectionResetError:
             message = f"Socket Accept: {kwargs['domain_from_dns_server']}:{port}: " \
                       f"* An existing connection was forcibly closed by the remote host..."
             wrapper_handle_connection_exceptions.message = message
             print_api(message, logger_method='error', traceback_string=True, oneline=True, **kwargs['print_kwargs'])
-            pass
         except ssl.SSLEOFError as e:
             # A subclass of SSLError raised when the SSL connection has been terminated abruptly. Generally, you
             # shouldn't try to reuse the underlying transport when this error is encountered.
@@ -47,7 +45,7 @@ def connection_exception_decorator(function_name):
                 message = \
                     f"Socket Accept: {kwargs['domain_from_dns_server']}:{port}: {message}"
                 wrapper_handle_connection_exceptions.message = message
-                print_api(message, error_type=True, logger_method='error', **kwargs['print_kwargs'])
+                print_api(message, error_type=True, logger_method='error', oneline=True, **kwargs['print_kwargs'])
             except Exception:
                 message = f"Socket Accept: port {port}: {message}"
                 wrapper_handle_connection_exceptions.message = message
@@ -61,7 +59,7 @@ def connection_exception_decorator(function_name):
                 message = \
                     f"Socket Accept: {kwargs['domain_from_dns_server']}:{port}: {message}"
                 wrapper_handle_connection_exceptions.message = message
-                print_api(message, logger_method='error', **kwargs['print_kwargs'])
+                print_api(message, logger_method='error', oneline=True, **kwargs['print_kwargs'])
             except Exception:
                 message = f"Socket Accept: port {port}: {message}"
                 wrapper_handle_connection_exceptions.message = message
@@ -88,14 +86,14 @@ def connection_exception_decorator(function_name):
 
                 message = "SSLError on accept. Not documented..."
                 wrapper_handle_connection_exceptions.message = message
-                print_api(message, logger_method='error', **kwargs['print_kwargs'])
+                print_api(message, logger_method='error', oneline=True, **kwargs['print_kwargs'])
 
                 message = f'ssl.SSLError:{exception_object}'
                 wrapper_handle_connection_exceptions.message = message
                 message = \
                     f"Socket Accept: {kwargs['domain_from_dns_server']}:{port}: {message}"
                 wrapper_handle_connection_exceptions.message = message
-                print_api(message, logger_method='error', **kwargs['print_kwargs'])
+                print_api(message, logger_method='error', oneline=True, **kwargs['print_kwargs'])
             pass
         except FileNotFoundError:
             message = "'SSLSocket.accept()' crashed: 'FileNotFoundError'. Some problem with SSL during Handshake - " \

atomicshop/wrappers/socketw/get_process.py

@@ -67,20 +67,20 @@ class GetCommandLine:
                 except ModuleNotFoundError as function_exception_object:
                     execution_error = f"Module not installed: {function_exception_object}"
                     print_api(
-                        execution_error, error_type=True, logger_method="error", traceback_string=True, oneline=True,
+                        execution_error, error_type=True, logger_method="error", traceback_string=True,
                         **print_kwargs)
                     pass
                 except psutil.AccessDenied:
                     execution_error = f"Access Denied for 'psutil' to read system process command line. " \
                                       f"Run script with Admin Rights."
                     print_api(
-                        execution_error, error_type=True, logger_method="error", traceback_string=True, oneline=True,
+                        execution_error, error_type=True, logger_method="error", traceback_string=True,
                         **print_kwargs)
                     pass
                 except Exception:
                     execution_error = "There was undocumented exception in localhost script execution."
                     print_api(
-                        execution_error, error_type=True, logger_method="error", traceback_string=True, oneline=True,
+                        execution_error, error_type=True, logger_method="error", traceback_string=True,
                         **print_kwargs)
                     pass
 

atomicshop/wrappers/socketw/receiver.py

@@ -49,17 +49,17 @@ class Receiver:
             class_data = self.ssl_socket.recv(self.buffer_size_receive)
         except ConnectionAbortedError:
             message = "* Connection was aborted by the client. Exiting..."
-            print_api(message, logger=self.logger, logger_method='critical', traceback_string=True, oneline=True)
+            print_api(message, logger=self.logger, logger_method='critical', traceback_string=True)
             # This will be treated as empty message - indicate that socket was closed and will be handled properly.
             pass
         except ConnectionResetError:
             message = "* Connection was forcibly closed by the client. Exiting..."
-            print_api(message, logger=self.logger, logger_method='critical', traceback_string=True, oneline=True)
+            print_api(message, logger=self.logger, logger_method='critical', traceback_string=True)
             # This will be treated as empty message - indicate that socket was closed and will be handled properly.
             pass
         except ssl.SSLError:
             message = "* Encountered SSL error on packet receive. Exiting..."
-            print_api(message, logger=self.logger, logger_method='critical', traceback_string=True, oneline=True)
+            print_api(message, logger=self.logger, logger_method='critical', traceback_string=True)
             # This will be treated as empty message - indicate that socket was closed and will be handled properly.
             pass
 

atomicshop/wrappers/socketw/sender.py

@@ -50,7 +50,7 @@ class Sender:
             self.logger.info(f"Sent the message to destination.")
         except ConnectionResetError:
             message = "* Couldn't reach the server - Connection was reset. Exiting..."
-            print_api(message, logger=self.logger, logger_method='critical', traceback_string=True, oneline=True)
+            print_api(message, logger=self.logger, logger_method='critical', traceback_string=True)
             # Since the connection is down, it will be handled in thread_worker_main
             function_result = False
             pass

atomicshop/wrappers/socketw/sni.py

@@ -267,7 +267,7 @@ class SNIHandler:
             print_api(message, **(print_kwargs or {}))
         except Exception as exception_object:
             message = f"SNI Handler: Undocumented exception general settings section: {exception_object}"
-            print_api(message, error_type=True, logger_method="error", traceback_string=True, oneline=True,
+            print_api(message, error_type=True, logger_method="error", traceback_string=True,
                       **(print_kwargs or {}))
             pass
 

atomicshop/wrappers/socketw/socket_server_tester.py

@@ -3,7 +3,7 @@ import threading
 from .socket_client import SocketClient
 from ..configparserw import ConfigParserWrapper
 from ..loggingw import loggingw
-from ...filesystem import get_file_paths_from_directory
+from ... import filesystem
 from ...file_io import jsons, file_io
 
 
@@ -57,14 +57,14 @@ def execute_test(config_static):
     loggingw.get_logger_with_stream_handler("network")
 
     # Get all the files in requests folder recursively.
-    request_file_list = get_file_paths_from_directory(config['requests_directory'])
+    request_file_list = filesystem.get_paths_from_directory(config['requests_directory'], get_file=True)
     print(f"Found request files: {len(request_file_list)}")
 
     # Get contents of all request files to list of contents.
     requests_bytes_list: list = list()
     for request_file_path in request_file_list:
         if config['request_type'] == 'json':
-            request_file_content = jsons.read_json_file(request_file_path)
+            request_file_content = jsons.read_json_file(request_file_path.path)
 
             # If imported json is regular and not combined json.
             if isinstance(request_file_content, dict):
@@ -79,13 +79,13 @@ def execute_test(config_static):
                     requests_bytes_list.extend(
                         get_key_values_from_json(json_dict, config['request_json_hex_key_list']))
         elif config['request_type'] == 'string':
-            request_file_content = file_io.read_file(request_file_path)
+            request_file_content = file_io.read_file(request_file_path.path)
             # Convert string content to bytes and append to list.
             requests_bytes_list.append(request_file_content.encode())
             print(f"Extracted 1 request.")
         elif config['request_type'] == 'binary':
             # The content is already in bytes, so just appending.
-            requests_bytes_list.append(file_io.read_file(request_file_path, 'rb'))
+            requests_bytes_list.append(file_io.read_file(request_file_path.path, 'rb'))
             print(f"Extracted 1 request.")
 
     print(f"Finished parsing. Parsed requests: {len(requests_bytes_list)}")