atomicshop 3.3.8__py3-none-any.whl → 3.10.0__py3-none-any.whl

atomicshop/archiver/zips.py

@@ -1,353 +0,0 @@
-import os
-import time
-import zipfile
-from io import BytesIO
-from typing import Union, Literal
-
-from .. import filesystem, print_api
-
-
-def is_zip_zipfile(file_object: Union[str, bytes]) -> bool:
-    """
-    Function checks if the file is a zip file.
-    :param file_object: can be two types:
-        string, full path to the file.
-        bytes or BytesIO, the bytes of the file.
-    :return: boolean.
-    """
-
-    try:
-        if isinstance(file_object, bytes):
-            with BytesIO(file_object) as file_object:
-                with zipfile.ZipFile(file_object) as zip_object:
-                    zip_object.testzip()
-                    return True
-        elif isinstance(file_object, str):
-            with zipfile.ZipFile(file_object) as zip_object:
-                zip_object.testzip()
-                return True
-    except zipfile.BadZipFile:
-        return False
-
-
-def is_zip_magic_number(file_path: str) -> bool:
-    """
-    Function checks if the file is a zip file using magic number.
-    :param file_path: string, full path to the file.
-    :return: boolean.
-
-    50 4B 03 04: This is the most common signature, found at the beginning of a ZIP file.
-        It signifies the start of a file within the ZIP archive and is present in almost all ZIP files.
-        Each file within the ZIP archive starts with this signature.
-    50 4B 05 06: This is the end of central directory record signature.
-        It's found at the end of a ZIP file and is essential for identifying the structure of the ZIP archive,
-        especially in cases where the file is split or is a multipart archive.
-    50 4B 07 08: This signature is used for spanned ZIP archives (also known as split or multi-volume ZIP archives).
-        It's found in the end of central directory locator for ZIP files that are split across multiple volumes.
-    """
-
-    with open(file_path, 'rb') as file:
-        # Read the first 4 bytes of the file
-        signature = file.read(4)
-
-    # Check if the signature matches any of the ZIP signatures
-    return signature in [b'PK\x03\x04', b'PK\x05\x06', b'PK\x07\x08']
-
-
-def extract_archive_with_zipfile(
-        archive_path: str,
-        extract_directory: str = None,
-        files_without_directories: bool = False,
-        remove_first_directory: bool = False,
-        print_kwargs: dict = None
-) -> str:
-    """
-    Function will extract the archive using standard library 'zipfile'.
-    This method preserves original date and time of the files inside the archive.
-
-    :param archive_path: string, full path to archived file.
-    :param extract_directory: string, full path to directory that the files will be extracted to.
-        If not specified, the files will be extracted to the same directory as the archived file, using the file name
-        without extension as the directory name.
-    :param files_without_directories: boolean, default 'False'.
-        'True': All the files in the archive will be extracted without subdirectories hierarchy.
-            Meaning, that if there are duplicate file names, the latest file with the same file name will overwrite
-            all the rest of the files with the same name.
-        'False': Subdirectory hierarchy will be preserved as it is currently in the archived file.
-    :param remove_first_directory: boolean, default is 'False'.
-        'True': all the files will be extracted without first directory in the hierarchy.
-            Example: package_some_name_1.1.1_build/subdir1/file.exe
-            Will be extracted as: subdir/file.exe
-    :param print_kwargs: dict, kwargs for print_api.
-
-    :return: string, full path to directory that the files were extracted to.
-    """
-
-    if print_kwargs is None:
-        print_kwargs = dict()
-
-    # If 'extract_directory' is not specified, extract to the same directory as the archived file.
-    if extract_directory is None:
-        extract_directory = (
-                filesystem.get_file_directory(archive_path) + os.sep +
-                filesystem.get_file_name_without_extension(archive_path))
-
-    print_api.print_api(f'Extracting to directory: {extract_directory}', **print_kwargs)
-
-    # initiating the archived file path as 'zipfile.ZipFile' object.
-    with zipfile.ZipFile(archive_path) as zip_object:
-        # '.infolist()' method of the object contains all the directories and files that are in the archive including
-        # information about each one, like date and time of archiving.
-        for zip_info in zip_object.infolist():
-            # '.filename' attribute of the 'infolist()' method is relative path to each directory and file.
-            # If 'filename' ends with '/' it is a directory (it doesn't matter if it is windows or *nix)
-            # If so, skip current iteration.
-            if zip_info.filename[-1] == '/':
-                continue
-
-            if files_without_directories:
-                # Put into 'filename' the string that contains only the filename without subdirectories.
-                zip_info.filename = os.path.basename(zip_info.filename)
-            elif remove_first_directory:
-                # Cut the first directory from the filename.
-                zip_info.filename = zip_info.filename.split('/', maxsplit=1)[1]
-
-            print_api.print_api(f'Extracting: {zip_info.filename}', **print_kwargs)
-
-            # Extract current file from the archive using 'zip_info' of the current file with 'filename' that we
-            # updated under specified parameters to specified directory.
-            zip_object.extract(zip_info, extract_directory)
-
-            # === Change the date and time of extracted file from current time to the time specified in 'zip_info'.
-            # Get full path to extracted file.
-            extracted_file_path: str = extract_directory + os.sep + zip_info.filename
-            # Create needed datetime object with original archived datetime from 'zip_info.date_time'.
-            date_time = time.mktime(zip_info.date_time + (0, 0, -1))
-            # Using 'os' library, changed the datetime of the file to the object created in previous step.
-            os.utime(extracted_file_path, (date_time, date_time))
-    print_api.print_api('Extraction done.', color="green", **print_kwargs)
-
-    return extract_directory
-
-
-def get_file_list_from_zip(file_path: str) -> list:
-    """
-    Function returns the list of file names and their relative directories inside the zip file.
-    :param file_path: string, full path to the zip file.
-    :return: list of strings.
-    """
-
-    with zipfile.ZipFile(file_path, 'r') as zip_object:
-        return zip_object.namelist()
-
-
-def archive_directory(
-        directory_path: str,
-        compression: Literal[
-            'store',
-            'deflate',
-            'bzip2',
-            'lzma'] = 'deflate',
-        include_root_directory: bool = True,
-        remove_original: bool = False
-) -> str:
-    """
-    Function archives the directory.
-    :param directory_path: string, full path to the directory.
-    :param compression: string, default is 'deflate'.
-        'store': No compression.
-        'deflate': Standard ZIP compression.
-        'bzip2': BZIP2 compression.
-            Provides better compression than Deflate but is typically slower. This method might not be supported by
-            all ZIP utilities.
-        'lzma': LZMA compression.
-            high compression ratios but is also slower compared to Deflate. This method is less commonly used and
-            may not be supported by all ZIP utilities.
-    :param include_root_directory: boolean, default is 'True'.
-        'True': The root directory will be included in the archive.
-        'False': The root directory will not be included in the archive.
-        True is usually the case in most archiving utilities.
-    :param remove_original: boolean, default is 'False'. If 'True', the original directory will be removed.
-    :return: string, full path to the archived file.
-    """
-
-    if compression == 'store':
-        compression_method = zipfile.ZIP_STORED
-    elif compression == 'deflate':
-        compression_method = zipfile.ZIP_DEFLATED
-    elif compression == 'bzip2':
-        compression_method = zipfile.ZIP_BZIP2
-    elif compression == 'lzma':
-        compression_method = zipfile.ZIP_LZMA
-    else:
-        raise ValueError(f"Unsupported compression method: {compression}")
-
-    archive_path: str = directory_path + '.zip'
-    with zipfile.ZipFile(archive_path, 'w', compression_method) as zip_object:
-        for root, _, files in os.walk(directory_path):
-            for file in files:
-                file_path = os.path.join(root, file)
-
-                # If including the root directory, use the relative path from the parent directory of the root
-                if include_root_directory:
-                    arcname = os.path.relpath(file_path, os.path.dirname(directory_path))
-                else:
-                    arcname = os.path.relpath(file_path, directory_path)
-
-                zip_object.write(file_path, arcname)
-
-    if remove_original:
-        filesystem.remove_directory(directory_path)
-
-    return archive_path
-
-
-# def search_file_in_zip(
-#         file_path: str = None,
-#         file_bytes: bytes = None,
-#         file_names_to_search: list[str] = None,
-#         case_sensitive: bool = True,
-#         return_first_only: bool = False,
-#         return_empty_list_per_file_name: bool = False,
-#         recursive: bool = False,
-#         callback_functions: list = None,
-#         extract_file_to_path: str = None
-# ) -> dict[str, list[bytes]]:
-#     """
-#     Function searches for the file names inside the zip file and returns a dictionary where the keys are the
-#     names of the callback functions and the values are lists of found file bytes.
-#     :param file_path: string, full path to the zip file.
-#     :param file_bytes: bytes, the bytes of the zip file.
-#     :param file_names_to_search: list of strings, the names of the files to search.
-#     :param case_sensitive: boolean, default is 'True'. Determines if file name search should be case sensitive.
-#     :param return_first_only: boolean, default is 'False'. Return only the first found file for each file name.
-#     :param return_empty_list_per_file_name: boolean, default is 'False'.
-#         True: Return empty list for each file name that wasn't found.
-#         False: Don't return empty list for each file name that wasn't found.
-#     :param recursive: boolean, default is 'False'. If True, search for file names recursively in nested zip files.
-#     :param callback_functions: list of callables, default is None. Each function takes a file name and should return a
-#         boolean that will tell the main function if this file is 'found' or not.
-#     :param extract_file_to_path: string, full path to the directory where the found files should be extracted.
-#     :return: dictionary of lists of bytes.
-#     """
-#
-#     def get_unique_filename(directory, filename):
-#         """
-#         Generates a unique filename by appending a number if the file already exists.
-#         """
-#         name, ext = os.path.splitext(filename)
-#         counter = 1
-#         unique_filename = filename
-#         while os.path.exists(os.path.join(directory, unique_filename)):
-#             unique_filename = f"{name}_{counter}{ext}"
-#             counter += 1
-#         return unique_filename
-#
-#     def is_zip_file(file, zip_obj):
-#         try:
-#             with zip_obj.open(file) as file_data:
-#                 with zipfile.ZipFile(BytesIO(file_data.read())) as zip_file:
-#                     if zip_file.testzip() is None:  # No errors found
-#                         return True
-#         except zipfile.BadZipFile:
-#             return False
-#         return False
-#
-#     def match_file_name(target, current):
-#         if case_sensitive:
-#             return current.endswith(target)
-#         else:
-#             return current.lower().endswith(target.lower())
-#
-#     def search_in_zip(zip_obj, file_names, results, found_set):
-#         for item in zip_obj.infolist():
-#             if item.filename.endswith('/'):  # Skip directories
-#                 continue
-#             is_nested_zip = recursive and is_zip_file(item.filename, zip_obj)
-#
-#             with zip_obj.open(item) as file_data:
-#                 archived_file_bytes = file_data.read()
-#
-#                 # This is needed to know if the file should be extracted to directory or not.
-#                 should_extract = False
-#
-#                 name_matched = False
-#                 if file_names is not None:
-#                     name_matched = any(match_file_name(file_name, item.filename) for file_name in file_names)
-#                     if name_matched:
-#                         should_extract = True
-#
-#                 callback_matched = False
-#                 if callback_functions:
-#                     for callback in callback_functions:
-#                         callback_result = callback(archived_file_bytes)
-#                         if callback_result:
-#                             callback_matched = True
-#                             # Initialize key for callback function name if not present
-#                             if callback.__name__ not in results:
-#                                 results[callback.__name__] = []
-#                             file_info = {
-#                                 'bytes': archived_file_bytes,
-#                                 'name': item.filename,
-#                                 'size': item.file_size,
-#                                 'modified_time': item.date_time
-#                             }
-#                             results[callback.__name__].append(file_info)
-#                             if return_first_only:
-#                                 found_set.add(item.filename)
-#
-#                             should_extract = True
-#                             break  # Stop checking other callbacks if one has found it
-#
-#                 if should_extract and extract_file_to_path:
-#                     unique_filename = get_unique_filename(extract_file_to_path, os.path.basename(item.filename))
-#                     with open(os.path.join(extract_file_to_path, unique_filename), 'wb') as f:
-#                         f.write(archived_file_bytes)
-#
-#                 if not callback_matched:
-#                     if is_nested_zip:
-#                         # If the file is a nested ZIP and hasn't matched a callback, search recursively
-#                         nested_zip_bytes = BytesIO(archived_file_bytes)
-#                         with zipfile.ZipFile(nested_zip_bytes) as nested_zip:
-#                             search_in_zip(nested_zip, file_names, results, found_set)
-#                     elif name_matched:
-#                         # Handle name match when no callbacks are provided or no callback matched
-#                         if item.filename not in results:
-#                             results[item.filename] = []
-#                         file_info = {
-#                             'bytes': archived_file_bytes,
-#                             'name': item.filename,
-#                             'size': item.file_size,
-#                             'modified_time': item.date_time
-#                         }
-#                         results[item.filename].append(file_info)
-#                         if return_first_only:
-#                             found_set.add(item.filename)  # Mark as found
-#
-#                 if file_names is not None and len(found_set) == len(file_names):
-#                     return  # All files found, stop searching
-#
-#     if file_names_to_search is None and callback_functions is None:
-#         raise ValueError("Either file_names_to_search or callback_functions must be provided.")
-#
-#     # Initialize results dictionary.
-#     if callback_functions:
-#         results = {callback.__name__: [] for callback in callback_functions}
-#     else:
-#         results = {}
-#
-#     found_set = set()
-#     if file_bytes is not None:
-#         with zipfile.ZipFile(BytesIO(file_bytes), 'r') as zip_ref:
-#             search_in_zip(zip_ref, file_names_to_search, results, found_set)
-#     elif file_path is not None:
-#         with zipfile.ZipFile(file_path, 'r') as zip_ref:
-#             search_in_zip(zip_ref, file_names_to_search, results, found_set)
-#     else:
-#         raise ValueError("Either file_path or file_bytes must be provided.")
-#
-#     if not return_empty_list_per_file_name:
-#         # Filter out keys with empty lists
-#         results = {key: value for key, value in results.items() if value}
-#
-#     return results

atomicshop/file_types.py

@@ -1,24 +0,0 @@
-from typing import Union
-
-import magic
-
-
-def get_mime_type(file_object: Union[str, bytes]):
-    """
-    Determine the MIME type of the given input.
-    The input can be a file path (string) or a bytes object.
-
-    :param file_object: File path as a string or bytes object.
-    :return: MIME type as a string.
-    """
-    mime = magic.Magic(mime=True)
-
-    # Check if input is a file path (str) or bytes
-    if isinstance(file_object, str):
-        # Assuming input_data is a file path
-        return mime.from_file(file_object)
-    elif isinstance(file_object, bytes):
-        # Assuming input_data is bytes
-        return mime.from_buffer(file_object)
-    else:
-        raise TypeError("Input must be a file path (str) or bytes object.")

atomicshop/pbtkmultifile_argparse.py

@@ -1,88 +0,0 @@
-# v1.0.1 - 26.03.2023 23:50
-import sys
-import argparse
-from argparse import RawTextHelpFormatter
-
-
-class ArgparseWrapper:
-    """
-    # Usage in the main:
-    args = ArgparseWrapper().parser_arguments
-    # Defining variables to each argument
-    input_path: str = args.input
-    output_path: str = args.output
-    """
-
-    def __init__(self):
-        self.application_short: str = 'pbtkMultiFile'
-        self.application_full: str = 'pbtk Multi File wrapper'
-        self.version: str = '1.0.0'
-        self.description: str = 'Find ".proto" files in directory of binaries.'
-        self.description_full: str = f'{self.application_full} v{self.version}\n' \
-                                     f'Description: {self.description}'
-        self.usage_variable: str = "%(prog)s [-h] -in folder_with_binary_files -out full_path_to_output_files\n" \
-                                   "Input or Output path shouldn't end with separator. Example: '\\'."
-        self.parser_arguments = None
-
-        # Execute argparse.
-        self.define_argparse()
-
-    # Function to define argument parser
-    def define_argparse(self):
-        # Create the parser
-        # formatter_class=RawTextHelpFormatter: shows raw text and not the default argparse text parsing.
-        parser = argparse.ArgumentParser(description=self.description_full,
-                                         usage=self.usage_variable,
-                                         formatter_class=RawTextHelpFormatter)
-
-        # Add arguments
-        parser.add_argument('-in', '--input',
-                            action='store', type=str, metavar='PATH_TO_FOLDER_WITH_BINARY_FILES',
-                            required=True,
-                            help='Provide full path to folder that contains binary files.')
-        parser.add_argument('-out', '--output', action='store', type=str, metavar='PATH_TO_SAVE_EXPORTED_FILES',
-                            required=True,
-                            help='Provide full path where you want to store exported file.')
-
-        # A problem before executing 'parse_args()'.
-        # If we get directory path as argument, on windows we can get a path that ends with backslash:
-        # C:\Users\user\documents\
-        # This is the default behaviour of windows when copying path of only the directory.
-        # When the path contains spaces, we need to pass it with double quotes:
-        # "C:\Users\user\documents\some folder name\another\"
-        # When python receives the arguments from CMD they get already parsed, meaning python can do nothing about it.
-        # From input:
-        # python_script.py -in "C:\some folder name\another\" -out "C:\some folder name\another1\"
-        # You will get output:
-        # ['python_script.py',
-        #   '-in',
-        #   'C:\some folder name\another" -out C:\some',
-        #   'folder',
-        #   'name\another1"]
-        # 'parse_args()' gets its input from 'sys.argv'. Meaning, you will need to do some manipulations on that
-        # Before executing the argparse argument parsing.
-        # Probably the fix should be individual for each case.
-        # The simplest solution though is to tell the user not to use backslash in the end of directory in case
-        # of exception.
-
-        try:
-            # Execute parse_args()
-            parsed_arguments = parser.parse_args()
-        # The only thing that you can catch on without modifying Argparse code is 'SystemExit' exception.
-        # You can also provide just 'except' without anything, which isn't the best practice.
-        # Another fix would be to use
-        # argparse.ArgumentParser(exit_on_error=False)
-        # But as of python 3.10.8 it is not working yet.
-        except SystemExit as exception_object:
-            print('======================================')
-            print('[*] Info: Error in provided arguments.')
-            print('[*] Tip: Check if you have backslash "\\" in the end of folder path, if so remove it.')
-            print('======================================')
-            sys.exit()
-
-        # if the folder path argument in the middle will have backslash "\" it will cause an exception.
-        # If the backslash will be in the end, it will not cause exception, but the string will end with double quotes.
-        parsed_arguments.input = parsed_arguments.input.replace('"', '')
-        parsed_arguments.output = parsed_arguments.output.replace('"', '')
-
-        self.parser_arguments = parsed_arguments

atomicshop/script_as_string_processor.py

@@ -1,42 +0,0 @@
-"""Loading resources using stdlib importlib.resources APIs (Python 3.7+)
-https://docs.python.org/3/library/importlib.html#module-importlib.resources"""
-import importlib.resources
-from typing import Literal
-
-from .print_api import print_api
-
-
-class ScriptAsStringProcessor:
-    def __init__(self):
-        self.resources_directory_name: str = 'ssh_scripts'
-
-        # string variable that is going to be exchanged with variable from main script.
-        self.exchange_input_variable_string: str = "exchange_input_variable"
-        self.script_string: str = str()
-
-    def read_script_to_string(
-            self,
-            script_file_name: Literal['process_from_port', 'process_from_ipv4']
-    ):
-        self.script_string = importlib.resources.read_text(
-            f'{__package__}.{self.resources_directory_name}',
-            f'{script_file_name}.py')
-
-        return self
-
-    def put_variable_into_script_string(self, input_variable: any, print_kwargs: dict = None):
-        # Defining variables
-        function_result: str = str()
-
-        if self.exchange_input_variable_string in self.script_string:
-            # string.replace(old, new, count)
-            # old – old substring you want to replace.
-            # new – new substring which would replace the old substring.
-            # count – the number of times you want to replace the old substring with the new substring. (Optional)
-            # We want to replace our string only one time in the beginning.
-            function_result = self.script_string.replace(self.exchange_input_variable_string, str(input_variable), 1)
-        else:
-            message = f"The script string provided doesn't contain {self.exchange_input_variable_string}"
-            print_api(message, error_type=True, logger_method='error', **print_kwargs)
-
-        return function_result

atomicshop/ssh_scripts/process_from_ipv4.py

@@ -1,37 +0,0 @@
-# importing the psutil library to get the source ports and get the process full command line from it.
-import psutil
-# 'psutil.Process(connection.pid).cmdline()' returns list of full command line parts, it is needed to reassemble
-# these parts to regular command line string.
-import shlex
-
-
-# User defined exception.
-class StopAllIterations(Exception):
-    pass
-
-
-# 'input_variable' will be string exchanged in the real script. It is the first line, so it won't take time to find the
-# line for the main script.
-# noinspection PyUnresolvedReferences
-remote_ipv4_list = exchange_input_variable
-
-
-try:
-    # for iteration in range(100):
-    # Iterating through all the connections on the computer.
-    for connection in psutil.net_connections(kind='all'):
-        # 'connection.raddr' is a tuple consisting of IPv4 address [0] and the port [1].
-        # Sometimes, if there's no remote address, "raddr" will be empty and since it's a tuple, we need to check that
-        # before getting the first [0] index.
-        if connection.raddr:
-            for address in remote_ipv4_list:
-                if connection.raddr[0] == address:
-                    # Get the command line from the connection PID.
-                    command_line = psutil.Process(connection.pid).cmdline()
-                    # Command line object is returned as list of parameters. We need 'shlex.join' to join the iterables
-                    # to regular, readable string.
-                    print(shlex.join(command_line))
-                    # Break the loops, when first match is found.
-                    raise StopAllIterations
-except StopAllIterations:
-    pass

atomicshop/ssh_scripts/process_from_port.py

@@ -1,27 +0,0 @@
-# importing the psutil library to get the source ports and get the process full command line from it.
-import psutil
-# 'psutil.Process(connection.pid).cmdline()' returns list of full command line parts, it is needed to reassemble
-# these parts to regular command line string.
-import shlex
-
-# 'input_variable' will be string exchanged in the real script. It is the first line, so it won't take time to find the
-# line for the main script.
-# noinspection PyUnresolvedReferences
-source_port = exchange_input_variable
-
-# Iterating through all the connections on the computer.
-for connection in psutil.net_connections():
-    # 'connection.laddr' is a tuple consisting of IPv4 address [0] and the port [1].
-    if connection.laddr[1] == source_port:
-        # Get the command line from the connection PID.
-        command_line = psutil.Process(connection.pid).cmdline()
-        # Command line object is returned as list of parameters. We need 'shlex.join' to join the iterables
-        # to regular, readable string.
-        result = shlex.join(command_line)
-        # If the result is still a PID, we'll try to get process name.
-        if result.isnumeric():
-            # Get the process name from the connection PID.
-            result = psutil.Process(connection.pid).name()
-        print(result)
-        # Break the loop, when first match is found.
-        break

atomicshop/wrappers/_process_wrapper_curl.py

@@ -1,27 +0,0 @@
-# v1.0.2 - 21.03.2023 13:40
-import sys
-import shlex
-
-from .. import process
-from .. import web
-
-
-def download_file_with_curl(file_url: str, target_directory: str) -> None:
-    """
-    The function receives url and target filesystem directory to download the file.
-
-    :param file_url: full URL to download the file.
-    :param target_directory: The directory on the filesystem to save the file to.
-    """
-
-    # Get only the filename from URL.
-    file_name = web.get_filename_from_url(file_url=file_url)
-
-    cmd: str = f'curl -L {file_url} --output "{target_directory}"'
-    cmd_list: list = shlex.split(cmd)
-
-    output_list: list = process.execute_with_live_output(cmd=cmd_list)
-    # If there was error in curl.
-    if 'curl: ' in output_list[-1]:
-        print('Curl error. Exiting...')
-        sys.exit()

atomicshop/wrappers/_process_wrapper_tar.py

@@ -1,21 +0,0 @@
-# v1.0.2 - 21.03.2023 18:30
-import shlex
-
-from .. import process
-
-
-def extract_archive_with_tar(file_path: str, target_directory: str) -> None:
-    """
-    Function extracts the archive to target directory.
-
-    :param file_path: Full file path to archived file to extract.
-    :param target_directory: The directory on the filesystem to extract the file to.
-    :return: None
-    """
-
-    # -v: Verbose, shows list of extracted files.
-    # -C: Output directory.
-    cmd: str = f'tar -xzvf "{file_path}" -C "{target_directory}"'
-    cmd_list: list = shlex.split(cmd)
-
-    output_list = process.execute_with_live_output(cmd=cmd_list)