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

atomicshop/file_io/file_io.py

@@ -1,8 +1,9 @@
 from typing import Union
 import functools
+import os
 
-from ..print_api import print_api
-from ..inspect_wrapper import get_target_function_default_args_and_combine_with_current
+from .. import print_api
+from .. import inspect_wrapper
 
 
 def get_write_file_mode_string_from_overwrite_bool(overwrite: bool) -> str:
@@ -17,9 +18,20 @@ def write_file_decorator(function_name):
     def wrapper_write_file_decorator(*args, **kwargs):
         # Put 'args' into 'kwargs' with appropriate key.
         # args, kwargs = put_args_to_kwargs(function_name, *args, **kwargs)
-        args, kwargs = get_target_function_default_args_and_combine_with_current(function_name, *args, **kwargs)
+        args, kwargs = inspect_wrapper.get_target_function_default_args_and_combine_with_current(
+            function_name, *args, **kwargs)
 
-        print_api(message=f"Writing file: {kwargs['file_path']}", **kwargs)
+        print_api.print_api(message=f"Writing file: {kwargs['file_path']}", **kwargs)
+
+        enable_long_file_path = kwargs.get('enable_long_file_path', False)
+        if enable_long_file_path and os.name == 'nt':
+            # A simpler string method would be to add '\\?\' to the beginning of the file path.
+            # kwargs['file_path'] = rf"\\?\{kwargs['file_path']}"
+
+            # Enable long file path.
+            from ctypes import windll
+            # Enable long file path.
+            windll.kernel32.SetFileAttributesW(kwargs['file_path'], 0x80)
 
         try:
             with open(kwargs['file_path'], kwargs['file_mode'], encoding=kwargs['encoding']) as output_file:
@@ -31,7 +43,7 @@ def write_file_decorator(function_name):
         except FileExistsError:
             message = f"Can't write file: {kwargs['file_path']}\n" \
                       f"File exists, you should enable force/overwrite mode."
-            print_api(message, error_type=True, logger_method='critical', **kwargs)
+            print_api.print_api(message, error_type=True, logger_method='critical', **kwargs)
 
     return wrapper_write_file_decorator
 
@@ -41,12 +53,13 @@ def read_file_decorator(function_name):
     def wrapper_read_file_decorator(*args, **kwargs):
         # Put 'args' into 'kwargs' with appropriate key.
         # args, kwargs = put_args_to_kwargs(function_name, *args, **kwargs)
-        args, kwargs = get_target_function_default_args_and_combine_with_current(function_name, *args, **kwargs)
+        args, kwargs = inspect_wrapper.get_target_function_default_args_and_combine_with_current(
+            function_name, *args, **kwargs)
 
         continue_loop: bool = True
         while continue_loop:
             try:
-                print_api(message=f"Reading file: {kwargs['file_path']}", **kwargs)
+                print_api.print_api(message=f"Reading file: {kwargs['file_path']}", **kwargs)
                 with open(kwargs['file_path'], kwargs['file_mode'], encoding=kwargs['encoding']) as input_file:
                     # Pass the 'output_file' object to kwargs that will pass the object to the executing function.
                     kwargs['file_object'] = input_file
@@ -54,19 +67,19 @@ def read_file_decorator(function_name):
                     return function_name(**kwargs)
             except FileNotFoundError:
                 message = f"File doesn't exist: {kwargs['file_path']}"
-                print_api(message, error_type=True, logger_method='critical', **kwargs)
+                print_api.print_api(message, error_type=True, logger_method='critical', **kwargs)
                 raise
             except UnicodeDecodeError as exception_object:
                 if kwargs["encoding"] != 'utf-8':
                     message = f'File decode error, current encoding: {kwargs["encoding"]}. Will try "utf-8".'
-                    print_api(message, logger_method='error', **kwargs)
+                    print_api.print_api(message, logger_method='error', **kwargs)
                     kwargs["encoding"] = 'utf-8'
                     pass
                     continue
                 else:
                     message = f'File decode error.\n' \
                               f'{exception_object}'
-                    print_api(message, merror_type=True, logger_method='critical', **kwargs)
+                    print_api.print_api(message, merror_type=True, logger_method='critical', **kwargs)
                     continue_loop = False
 
     return wrapper_read_file_decorator
@@ -78,7 +91,7 @@ def write_file(
         file_path: str,
         file_mode: str = 'w',
         encoding: str = None,
-        convert_list_to_string: bool = False,
+        enable_long_file_path: bool = False,
         file_object=None,
         **kwargs) -> None:
     """
@@ -90,18 +103,19 @@ def write_file(
         Default is 'w'.
     :param encoding: string, write the file with encoding. Example: 'utf-8'. 'None' is default, since it is default
         in 'open()' function.
-    :param convert_list_to_string: Boolean, if True, the list of strings will be converted to one string with '\n'
-        separator between the lines.
+    :param enable_long_file_path: Boolean, by default Windows has a limit of 260 characters for file path. If True,
+        the long file path will be enabled, and the limit will be 32,767 characters.
     :param file_object: file object of the 'open()' function in the decorator. Decorator executes the 'with open()'
         statement and passes to this function. That's why the default is 'None', since we get it from the decorator.
     :return:
     """
 
     if isinstance(content, list):
-        if convert_list_to_string:
-            content = '\n'.join(content)
-        else:
-            file_object.writelines(content)
+        for line in content:
+            if not line.endswith("\n"):
+                file_object.write(line + "\n")
+            else:
+                file_object.write(line)
     elif isinstance(content, str):
         file_object.write(content)
     # THis will happen if the content is bytes and the file mode is 'wb'.

atomicshop/file_io/jsons.py

@@ -133,3 +133,52 @@ def is_dict_json_serializable(
             raise e
         else:
             return False, str(e)
+
+
+def append_to_json(
+        dict_or_list: Union[dict, list],
+        json_file_path: str,
+        indent=None,
+        use_default_indent=False,
+        enable_long_file_path=False,
+        print_kwargs: dict = None
+) -> None:
+    """
+    Append dictionary or list of dictionaries to json file.
+
+    :param dict_or_list: dictionary or list of dictionaries to append.
+    :param json_file_path: full file path to the json file.
+    :param indent: integer number of spaces for indentation.
+        If 'ident=0' new lines still will be created. The most compact is 'indent=None' (from documentation)
+        So, using default as 'None' and not something else.
+    :param use_default_indent: boolean. Default indent for 'json' format in many places is '2'. So, if you don't want
+        to set 'indent=2', just set this to 'True'.
+    :param enable_long_file_path: Boolean, by default Windows has a limit of 260 characters for file path. If True,
+        the long file path will be enabled, and the limit will be 32,767 characters.
+    :param print_kwargs: dict, the print_api arguments.
+    :return:
+    """
+
+    # Read existing data from the file
+    try:
+        with open(json_file_path, 'r') as f:
+            current_json_file = json.load(f)
+    except FileNotFoundError:
+        current_json_file: list = []
+
+    # Append the new message to the existing data
+    final_json_list_of_dicts: list[dict] = []
+    if isinstance(current_json_file, list):
+        current_json_file.append(dict_or_list)
+        final_json_list_of_dicts = current_json_file
+    elif isinstance(current_json_file, dict):
+        final_json_list_of_dicts.append(current_json_file)
+        final_json_list_of_dicts.append(dict_or_list)
+    else:
+        error_message = "The current file is neither a list nor a dictionary."
+        raise TypeError(error_message)
+
+    # Write the data back to the file
+    write_json_file(
+        final_json_list_of_dicts, json_file_path, indent=indent, use_default_indent=use_default_indent,
+        enable_long_file_path=enable_long_file_path, **print_kwargs)

atomicshop/file_io/tomls.py

@@ -5,11 +5,17 @@ try:
     import tomllib
 except ModuleNotFoundError:
     # This is library from pypi.
+    # noinspection PyPackageRequirements
     import tomli as tomllib
 
 from . import file_io
 
 
+class TomlValueNotImplementedError(Exception):
+    pass
+
+
+# noinspection PyUnusedLocal
 @file_io.read_file_decorator
 def read_toml_file(file_path: str,
                    file_mode: str = 'rb',
@@ -31,6 +37,7 @@ def read_toml_file(file_path: str,
     return tomllib.load(file_object)
 
 
+# noinspection PyUnusedLocal
 @file_io.write_file_decorator
 def write_toml_file(
         toml_content: dict,
@@ -84,3 +91,135 @@ def dumps(toml_dict: dict):
         toml_string += process_item(key, value)
 
     return toml_string
+
+
+def update_toml_file_with_new_config(
+        main_config_file_path: str,
+        changes_config_file_path: str = None,
+        changes_dict: dict = None,
+        new_config_file_path: str = None
+) -> None:
+    """
+    Update the old toml config file with the new values from the new toml config file.
+    This will update only the changed values.
+    If the values from the changes file aren't present in the main config file, they will not be added.
+
+    :param main_config_file_path: string, path to the main config file that you want to use as the main reference.
+        If you provide the 'new_config_file_path', then changes to the 'main_config_file_path' will be written there.
+    :param changes_config_file_path: string, the config file path that have the changes.
+        Only changed values will be updated to the 'main_config_file_path'.
+    :param changes_dict: dict, the dictionary with the changes.
+        Instead of providing the 'changes_config_file_path', you can provide only the dictionary with the changes.
+    :param new_config_file_path: string, path to the new config file.
+        If provided, the changes will be written to this file.
+        If not, the changes will be written to the 'main_config_file_path'.
+    """
+
+    if not changes_config_file_path and not changes_dict:
+        raise ValueError("You must provide either 'changes_config_file_path' or 'changes_dict'.")
+    if changes_config_file_path and changes_dict:
+        raise ValueError("You can't provide both 'changes_config_file_path' and 'changes_dict'.")
+
+    with open(main_config_file_path, 'r') as file:
+        main_config_file_text_lines: list = file.readlines()
+
+    main_config_file_text_lines_backup: list = list(main_config_file_text_lines)
+
+    # Read the new config file.
+    main_config_file_dict: dict = read_toml_file(main_config_file_path)
+
+    if not changes_dict:
+        changes_dict: dict = read_toml_file(changes_config_file_path)
+
+    # Update the config text lines.
+    for category, settings in main_config_file_dict.items():
+        if category not in changes_dict:
+            continue
+
+        for key, value in settings.items():
+            # If the key is in the old config file, use the old value.
+            if key not in changes_dict[category]:
+                continue
+
+            if main_config_file_dict[category][key] != changes_dict[category][key]:
+                # Get the line of the current category line.
+                current_category_line_index_in_text = None
+                for current_category_line_index_in_text, line in enumerate(main_config_file_text_lines):
+                    if f"[{category}]" in line:
+                        break
+
+                # Get the index inside the main config file dictionary of the current category.
+                main_config_list_of_keys: list = list(main_config_file_dict.keys())
+                current_category_index_in_main_config_dict = main_config_list_of_keys.index(category)
+
+                try:
+                    next_category_name = list(
+                        main_config_file_dict.keys())[current_category_index_in_main_config_dict + 1]
+                except IndexError:
+                    next_category_name = list(main_config_file_dict.keys())[-1]
+
+                next_category_line_index_in_text = None
+                for next_category_line_index_in_text, line in enumerate(main_config_file_text_lines):
+                    if f"[{next_category_name}]" in line:
+                        break
+
+                # In case the current and the next categories are the same and the last in the file.
+                if next_category_line_index_in_text == current_category_line_index_in_text:
+                    next_category_line_index_in_text = len(main_config_file_text_lines)
+
+                string_to_check_list: list = list()
+                if isinstance(value, bool):
+                    string_to_check_list.append(f"{key} = {str(value).lower()}")
+                elif isinstance(value, int):
+                    string_to_check_list.append(f"{key} = {value}")
+                elif isinstance(value, str):
+                    string_to_check_list.append(f"{key} = '{value}'")
+                    string_to_check_list.append(f'{key} = "{value}"')
+                else:
+                    raise TomlValueNotImplementedError(f"Value type '{type(value)}' not implemented.")
+
+                # next_category_line_index_in_text = main_config_file_text_lines.index(f"[{next_category_name}]\n")
+                # Find the index of this line in the text file between current category line and
+                # the next category line.
+                line_index = None
+                found_line = False
+                for line_index in range(current_category_line_index_in_text, next_category_line_index_in_text):
+                    if found_line:
+                        line_index = line_index - 1
+                        break
+                    for string_to_check in string_to_check_list:
+                        if string_to_check in main_config_file_text_lines[line_index]:
+                            found_line = True
+                            break
+
+                if found_line:
+                    # If there are comments, get only them from the line. Comment will also get the '\n' character.
+                    # noinspection PyUnboundLocalVariable
+                    comment = main_config_file_text_lines[line_index].replace(string_to_check, '')
+
+                    object_type = type(changes_dict[category][key])
+                    if object_type == bool:
+                        value_string_to_set = str(changes_dict[category][key]).lower()
+                    elif object_type == str:
+                        value_string_to_set = f"'{changes_dict[category][key]}'"
+                    elif object_type == int:
+                        value_string_to_set = str(changes_dict[category][key])
+
+                    # noinspection PyUnboundLocalVariable
+                    line_to_set = f"{key} = {value_string_to_set}{comment}"
+                    # Replace the line with the old value.
+                    main_config_file_text_lines[line_index] = line_to_set
+
+                    main_config_file_dict[category][key] = changes_dict[category][key]
+
+    if new_config_file_path:
+        file_path_to_write = new_config_file_path
+    else:
+        file_path_to_write = main_config_file_path
+
+    if not main_config_file_text_lines == main_config_file_text_lines_backup:
+        # Write the final config file.
+        with open(file_path_to_write, 'w') as file:
+            file.writelines(main_config_file_text_lines)
+    else:
+        print("No changes to the config file.")