atomicshop 2.15.11__py3-none-any.whl → 3.10.5__py3-none-any.whl

atomicshop/basics/bytes_arrays.py

@@ -1,3 +1,7 @@
+from typing import Union
+import string
+
+
 def get_single_byte_from_byte_string(byte_string, index: int):
     """
     Function extracts single byte as byte from byte string object.
@@ -53,6 +57,30 @@ def convert_sequence_of_bytes_to_sequence_of_strings(byte_sequence: bytes) -> li
     return result
 
 
+def convert_sequence_of_bytes_to_exact_string(
+        byte_sequence: bytes,
+        add_space_between_bytes: bool = False,
+) -> str:
+    """
+    Convert sequence of bytes to exact string.
+    Example: b'\xc0\x00' -> 'c000'
+
+    :param byte_sequence: bytes, sequence of bytes.
+    :param add_space_between_bytes: bool, add space between bytes.
+        Example: b'\xc0\x00' -> 'c0 00'
+    :return: string.
+    """
+
+    # Convert to hex string and format
+    byte_list: list = []
+    for byte in byte_sequence:
+        byte_list.append(f'{byte:02x}')
+
+    result = ''.join(byte_list)
+
+    return result
+
+
 def find_position(target: bytes, file_path: str = None, file_bytes: bytes = None, chunk_size: int = None, starting_position: int = 0) -> int:
     """
     Find position of the target bytes string in the file.
@@ -155,3 +183,18 @@ def read_bytes_from_position(
         # Read the specified number of bytes.
         data = file.read(num_bytes)
     return data
+
+
+def convert_bytes_to_printable_string_only(
+        byte_sequence: Union[bytes, bytearray],
+        non_printable_character: str = '.'
+) -> str:
+    """
+    Convert bytes to printable string. If byte is not printable, replace it with 'non_printable_character'.
+    :param byte_sequence: bytes or bytearray, sequence of bytes.
+    :param non_printable_character: string, character to replace non-printable characters.
+    :return:
+    """
+
+    printable = set(string.printable)
+    return ''.join(chr(byte) if chr(byte) in printable else non_printable_character for byte in byte_sequence)

atomicshop/basics/classes.py

@@ -1,12 +1,160 @@
 import os
 import sys
 import ast
-import importlib
 from pathlib import Path
+import pkgutil
+import importlib
+import inspect
 
 from ..file_io.file_io import read_file
 
 
+"""
+Using logger in the class only once during the import of the module.
+ 
+class ParserParent:
+    # Initializing the logger in the "class variable" section will leave the instance of the logger initiated
+    # and the rest of the instances of the class will use the same logger.
+    # It is not in the "__init__" section, so it's not going to be initiated again.
+    # The name of the logger using "__name__" variable, which is the full name of the module package.
+    # Example: classes.parsers.parser_1_reference_general
+
+    # The code outside the functions will be executed during import of the module. When initializing a class
+    # in the script these lines will not be called again, only the "init" function.
+    logger = create_custom_logger()
+
+    def __init__(self, class_client_message: ClientMessage):
+        self.class_client_message: ClientMessage = class_client_message
+
+    # Usage: self.logger.info("Message")
+"""
+
+
+"""
+Using Base class for easier interfacing on subclasses.
+
+recognition/recognition_base.py:
+    from abc import abstractmethod
+    
+    
+    class Recognizer:
+        @abstractmethod
+        def recognize_vendor(self, file_path: str) -> str:
+            pass
+    
+        @abstractmethod
+        def recognize_family(self, bytes_list: list[str]]) -> str:
+            pass
+
+
+recognition/super_vendor.py:
+    from .recognition_base import Recognizer
+    
+    class SupervendorRecognizer(Recognizer):
+        def recognize_vendor(self, file_path: str) -> str:
+            classification_string: str = <Some logic to classify the SuperVendor>
+            return classification_string
+    
+        def recognize_family(self, bytes_list: list[str]]) -> str:
+            family_classification_string: str = <Some logic to classify the family of the SuperVendor>
+            return family_classification_string
+            
+
+main_script.py:
+    from . import recognition
+    from .recognition.recognition_base import Recognizer
+    
+    # Get the list of all the recognizers in the recognition package.
+    recognizers_list: list = classes.get_list_of_classes_in_module(
+        imported_package=recognition, imported_base_class=Recognizer)
+    
+    # Get the list of all the vendors from the file.
+    vendors_list: list = list()
+    for recognizer in recognizers_list:
+        recognizer_instance = recognizer()
+        vendor_name: str = recognizer_instance.recognize_vendor(file_object=file_path)
+        if vendor_name:
+            vendors_list.append((vendor_name, recognizer_instance))
+    
+    # Get the families of the vendors.
+    for vendor_name, recognizer_instance in vendors_list:
+        family_name: str = recognizer_instance.recognize_family(bytes_list=file_bytes_list)
+        print(f"Vendor: {vendor_name}, Family: {family_name}")
+"""
+
+def get_list_of_classes_in_module(
+        imported_package,
+        imported_base_class
+) -> list:
+    """
+    Function that returns a list of classes that are subclasses of the imported_base_class from the imported_package.
+
+    Example:
+        # Package structure:
+        # unpackers
+        # ├── __init__.py
+        # ├── unpacker_base.py
+        # ├── unpacker_1.py
+        # ├── unpacker_2.py
+        # ├── unpacker_3.py
+        # └── ... (other unpacker modules)
+
+        # unpacker_base.py:
+        from abc import abstractmethod
+        class Unpacker:
+            @abstractmethod
+            def unpack(self, file_path):
+                pass
+
+        # unpacker_1.py:
+        from unpackers.unpacker_base import Unpacker
+        class Unpacker1(Unpacker):
+            def unpack(self, file_path):
+                print(f"Unpacking file with Unpacker1: {file_path}")
+
+        # main_script.py:
+        # Import the base class
+        from unpackers.unpacker_base import Unpacker
+        # Import the package
+        import unpackers
+        # Get the list of classes
+        unpacker_classes = get_list_of_classes_in_module(imported_package=unpackers, imported_base_class=Unpacker)
+
+        # Initialize the classes
+        for unpacker_class in unpacker_classes:
+            unpacker_instance = unpacker_class()
+            unpacker_instance.unpack("file_path")
+        ----------------------------
+        # You can also initialize the list of classes dynamically and after that execute methods.
+        # Example:
+        unpacker_classes = get_list_of_classes_in_module(imported_package=unpackers, imported_base_class=Unpacker)
+
+        instance_list: list = []
+        for unpacker_class in unpacker_classes:
+            instance_list.append(unpacker_class())
+
+        for instance in instance_list:
+            instance.unpack("file_path")
+
+    :param imported_package:
+    :param imported_base_class:
+    :return:
+    """
+    unpacker_classes = []
+
+    # Iterate over all modules in the 'imported_package' package
+    for loader, module_name, is_pkg in pkgutil.iter_modules(imported_package.__path__):
+        # Import the module
+        module = importlib.import_module(f"{imported_package.__name__}.{module_name}")
+
+        # Inspect module members to find Unpacker subclasses
+        for name, obj in inspect.getmembers(module, inspect.isclass):
+            if issubclass(obj, imported_base_class) and obj is not imported_base_class:
+                unpacker_classes.append(obj)
+
+    return unpacker_classes
+
+
 def create_empty_class():
     """
     Function creates empty class, you can add parameters to it dynamically.

atomicshop/basics/enums.py

@@ -32,10 +32,10 @@ def __comparison_usage_example(
         main folder.
 
     Usage:
-        from atomicshop.filesystem import get_file_paths_from_directory, ComparisonOperator
+        from atomicshop.filesystem import get_paths_from_directory, ComparisonOperator
 
         # Get full paths of all the 'engine_config.ini' files.
-        engine_config_path_list = get_file_paths_from_directory(
+        engine_config_path_list = get_paths_from_directory(
             directory_fullpath=some_directory_path,
             file_name_check_tuple=(config_file_name, ComparisonOperator.EQ))
     """

atomicshop/basics/exceptions.py

@@ -1,4 +1,3 @@
-# v1.0.3 - 28.03.2023 17:20
 import sys
 
 from .threads import current_thread_id
@@ -15,3 +14,8 @@ def print_exception() -> None:
     exc_type, exc_value, exc_traceback = sys.exc_info()
 
     print(f"{error_log_prefix} Thread {thread_id}: * Details: {exc_type}, {exc_value}")
+
+
+def get_exception_type_string(exception: Exception) -> str:
+    """ Get exception type string """
+    return type(exception).__name__

atomicshop/basics/list_of_classes.py

@@ -0,0 +1,29 @@
+from operator import attrgetter
+
+
+def sort_by_attributes(
+        list_instance: list,
+        attribute_list: list,
+        reverse: bool = False,
+        case_insensitive: bool = False
+):
+    """
+    Sort a list of objects by their attributes.
+
+    :param list_instance: list of objects.
+    :param attribute_list: list of attributes (strings). The sorting will be done by the attributes in the list.
+        In the appearing order in the list.
+    :param reverse: bool, sort in reverse order.
+    :param case_insensitive: bool, sorting will be case-insensitive.
+    """
+
+    for attribute in attribute_list:
+        if case_insensitive:
+            list_instance = sorted(
+                list_instance, key=lambda obj: getattr(obj, attribute).lower(), reverse=reverse
+            )
+        else:
+            list_instance = sorted(
+                list_instance, key=attrgetter(attribute), reverse=reverse
+            )
+    return list_instance