osbot-utils 1.27.0__py3-none-any.whl → 1.29.0__py3-none-any.whl

osbot_utils/helpers/Zip_Bytes.py

@@ -0,0 +1,105 @@
+from osbot_utils.base_classes.Type_Safe import Type_Safe
+from osbot_utils.utils.Dev import pprint
+from osbot_utils.utils.Files import files_list, file_create_from_bytes, temp_file, parent_folder, parent_folder_create
+from osbot_utils.utils.Regex import list__match_regex, list__match_regexes
+from osbot_utils.utils.Zip import zip_bytes_empty, zip_bytes__files, zip_bytes__add_file, zip_bytes__add_files, \
+    zip_bytes__replace_files, zip_bytes__replace_file, zip_bytes__file_list, zip_bytes__file, \
+    zip_bytes__add_file__from_disk, zip_bytes__add_files__from_disk, zip_files, zip_file__files, zip_bytes__remove_files
+
+
+class Zip_Bytes(Type_Safe):
+    zip_bytes : bytes = None
+
+    def __init__(self):
+        super().__init__()
+        self.zip_bytes = zip_bytes_empty()
+
+    def __enter__(self):
+        return self
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        pass
+
+    def add_file(self, file_path, file_contents):
+        self.zip_bytes = zip_bytes__add_file(self.zip_bytes, file_path, file_contents)
+        return self
+
+    def add_file__from_disk(self, file_to_add, base_path=None):
+        if base_path is None:
+            base_path = parent_folder(file_to_add)
+        self.zip_bytes = zip_bytes__add_file__from_disk(self.zip_bytes, base_path, file_to_add)
+        return self
+
+    def add_files(self, files_to_add):
+        self.zip_bytes = zip_bytes__add_files(self.zip_bytes, files_to_add)
+        return self
+
+    def add_files__from_disk(self, base_path, files_to_add, path_prefix=None):
+        self.zip_bytes = zip_bytes__add_files__from_disk(self.zip_bytes, base_path, files_to_add, path_prefix=path_prefix)
+        return self
+
+    def add_folder__from_disk(self, folder_to_add, *patterns):
+        base_path           = folder_to_add
+        all_files_in_folder = files_list(folder_to_add)
+        files_to_add        = list__match_regexes(all_files_in_folder, *patterns)
+        return self.add_files__from_disk(base_path, files_to_add)
+
+    def add_folder__from_disk__with_prefix(self, folder_to_add, path_prefix, *patterns):
+        base_path           = folder_to_add
+        all_files_in_folder = files_list(folder_to_add)
+        files_to_add        = list__match_regexes(all_files_in_folder, *patterns)
+        return self.add_files__from_disk(base_path, files_to_add, path_prefix=path_prefix)
+
+    def add_from_zip_file(self, path_zip_file):
+        files_to_add = zip_file__files(path_zip_file)
+        self.add_files(files_to_add)
+        return self
+
+    def empty(self):
+        return self.size() == 0
+
+    def file(self, file_path):
+        return zip_bytes__file(self.zip_bytes, file_path)
+
+    def file_paths(self):
+        return self.files_list()
+
+    def files(self):
+        return zip_bytes__files(self.zip_bytes)
+
+    def files_list(self):
+        return zip_bytes__file_list(self.zip_bytes)
+
+    def list(self):
+        return self.files_list()
+
+    def print_files_list(self):
+        pprint(self.files_list())
+        return self
+
+    def remove_files(self, *patterns):
+        files_to_remove = list__match_regexes(self.files_list(), *patterns)
+        self.zip_bytes = zip_bytes__remove_files(self.zip_bytes, files_to_remove)
+        return self
+
+    def replace_files(self, files_to_replace):
+        self.zip_bytes = zip_bytes__replace_files(self.zip_bytes, files_to_replace)
+        return self
+
+    def replace_file(self, file_path, file_contents):
+        self.zip_bytes = zip_bytes__replace_file(self.zip_bytes, file_path, file_contents)
+        return self
+
+    def save(self, path=None):
+        if path is None:
+            path = temp_file(extension='.zip')
+        zip_file = file_create_from_bytes(bytes=self.zip_bytes, path=path)
+        return zip_file
+
+    def save_to(self, path):
+        parent_folder_create(path)           # make sure the parent folder exists
+        return self.save(path)
+
+
+    def size(self):
+        return len(self.files_list())

osbot_utils/testing/Temp_Folder.py

@@ -96,6 +96,13 @@ class Temp_Folder:
         file_path = path_combine(self.full_path, target_file)
         return file_contents(file_path)
 
+    def files_contents(self):
+        result = {}
+        for file_path in self.files():
+            full_path         = path_combine(self.full_path, file_path)
+            result[file_path] = file_contents(full_path)
+        return result
+
     def files(self, show_parent_folder=False, include_folders=False):
         all_files = files_recursive(self.path(), include_folders=include_folders)
         if show_parent_folder:

osbot_utils/testing/Temp_Zip.py

@@ -1,7 +1,7 @@
 from osbot_utils.testing.Temp_Folder import Temp_Folder
 from osbot_utils.utils.Files import Files, is_folder, file_exists, file_name, file_move_to_folder, file_move, \
     file_move_to
-from osbot_utils.utils.Zip import zip_folder, zip_file_list
+from osbot_utils.utils.Zip import zip_folder, zip_file__list
 
 
 class Temp_Zip():
@@ -35,7 +35,7 @@ class Temp_Zip():
         return self.zip_file
 
     def files(self):
-        return zip_file_list(self.zip_file)
+        return zip_file__list(self.zip_file)
 
     def print_path(self):
         print()

osbot_utils/testing/Temp_Zip_In_Memory.py

@@ -3,7 +3,7 @@ import io
 from osbot_utils.testing.Temp_File import Temp_File
 from osbot_utils.testing.Temp_Folder import Temp_Folder
 from osbot_utils.utils.Files import is_file, is_folder, files_recursive, filter_parent_folder, temp_file
-from osbot_utils.utils.Zip import zip_files_to_bytes, zip_bytes_file_list, zip_bytes_add_file, zip_bytes_get_file
+from osbot_utils.utils.Zip import zip_files_to_bytes, zip_bytes__file_list, zip_bytes__add_file, zip_bytes__get_file
 
 
 class Temp_Zip_In_Memory:
@@ -76,14 +76,14 @@ class Temp_Zip_In_Memory:
         for items in self.targets_as_content:
             file_path     = items.get('file_path')
             file_contents = items.get('file_contents')
-            zip_bytes = zip_bytes_add_file(zip_bytes, file_path, file_contents)
+            zip_bytes = zip_bytes__add_file(zip_bytes, file_path, file_contents)
         return zip_bytes
 
     def zip_bytes_file_content(self, file_path):
-        return zip_bytes_get_file(self.zip_bytes(), file_path)
+        return zip_bytes__get_file(self.zip_bytes(), file_path)
 
     def zip_bytes_files(self):
-        return zip_bytes_file_list(self.zip_bytes())
+        return zip_bytes__file_list(self.zip_bytes())
 
     def zip_buffer(self):
         targets = self.target_files_with_root_folder()

osbot_utils/utils/Files.py

@@ -81,10 +81,12 @@ class Files:
         return glob.glob(path_pattern, recursive=recursive)
 
     @staticmethod
-    def files(path, pattern= '*.*'):                        # todo: check behaviour and improve ability to detect file (vs folders)
+    def files(path, pattern= '*', only_files=True):
         result = []
         for file in Path(path).rglob(pattern):
-            result.append(str(file))                        # todo: see if there is a better way to do this conversion to string
+            if only_files and is_not_file(file):
+                continue
+            result.append(str(file))                                  # todo: see if there is a better way to do this conversion to string
         return sorted(result)
 
     @staticmethod
@@ -196,7 +198,7 @@ class Files:
         return path
 
     @staticmethod
-    def folder_create_in_parent(path, name):
+    def folder_create_in_parent(path, name):                # todo: revise the naming of this method, since it really doesn't have to do with 'parent' (it will depend on value of name)
         folder_path = path_combine(path, name)
         return folder_create(folder_path)
 
@@ -466,6 +468,9 @@ def all_parent_folders(path=None, include_path=False):
             break
     return parent_directories
 
+def is_not_file(target):
+    return is_file(target) is False
+
 def file_move(source_file, target_file):
     if file_exists(source_file):
         file_copy(source_file, target_file)
@@ -486,6 +491,15 @@ def folders_names_in_folder(target):
     folders = folders_in_folder(target)
     return folders_names(folders)
 
+def parent_folder_create(target):
+    return folder_create(parent_folder(target))
+
+def parent_folder_exists(target):
+    return folder_exists(parent_folder(target))
+
+def parent_folder_not_exists(target):
+    return parent_folder_exists(target) is False
+
 def stream_to_bytes(stream):
     return stream.read()
 

osbot_utils/utils/Regex.py

@@ -0,0 +1,25 @@
+import re
+
+from osbot_utils.utils.Status import status_error
+
+
+def list__match_regex(target, pattern):
+    return list__match_regexes(target, [pattern])
+
+def list__match_regexes(target, *patterns):
+    if len (patterns) == 0:
+        return target
+    compiled_patterns = []
+    for pattern in patterns:
+        try:
+            compiled_patterns.append(re.compile(pattern))                           # todo: find better way to handle regex errors
+        except Exception as error:
+            return status_error(message='Error compiling pattern: {pattern}', error=error)
+    matched_files = []
+    if target and type(target) is list:
+        for file in target:
+            for compiled_pattern in compiled_patterns:
+                if compiled_pattern.match(file):
+                    matched_files.append(file)
+                    break
+    return matched_files

osbot_utils/utils/Zip.py

@@ -6,10 +6,13 @@ import tarfile
 import zipfile
 from os.path import abspath
 
-from osbot_utils.utils.Files import temp_folder, folder_files, temp_file, is_file, file_copy, file_move
+from osbot_utils.utils.Files import temp_folder, folder_files, temp_file, is_file, file_copy, file_move, file_exists, \
+    file_contents_as_bytes
 
+#########################
+# actions on gz_tar_bytes
 
-def gz_tar_bytes_file_list(gz_bytes):
+def gz_tar_bytes__file_list(gz_bytes):
     gz_buffer_from_bytes = io.BytesIO(gz_bytes)
     with gzip.GzipFile(fileobj=gz_buffer_from_bytes, mode='rb') as gz:
         decompressed_data = gz.read()
@@ -17,7 +20,7 @@ def gz_tar_bytes_file_list(gz_bytes):
         with tarfile.open(fileobj=tar_buffer_from_bytes, mode='r:') as tar:
             return sorted(tar.getnames())
 
-def gz_tar_bytes_get_file(gz_bytes, tar_file_path):
+def gz_tar_bytes__get_file(gz_bytes, tar_file_path):
     gz_buffer_from_bytes = io.BytesIO(gz_bytes)
     with gzip.GzipFile(fileobj=gz_buffer_from_bytes, mode='rb') as gz:
         decompressed_data = gz.read()
@@ -29,7 +32,10 @@ def gz_tar_bytes_get_file(gz_bytes, tar_file_path):
             else:
                 raise FileNotFoundError(f"The file {tar_file_path} was not found in the tar archive.")
 
-def gz_zip_bytes_file_list(gz_bytes):
+#########################
+# actions on gz_zip_bytes
+
+def gz_zip_bytes__file_list(gz_bytes):
     gz_buffer_from_bytes = io.BytesIO(gz_bytes)
     with gzip.GzipFile(fileobj=gz_buffer_from_bytes, mode='rb') as gz:
         decompressed_data = gz.read()
@@ -37,28 +43,93 @@ def gz_zip_bytes_file_list(gz_bytes):
         with zipfile.ZipFile(zip_buffer_from_bytes, 'r') as zf:
             return sorted(zf.namelist())
 
-def unzip_file(zip_file, target_folder=None, format='zip'):
-    target_folder = target_folder or temp_folder()
-    shutil.unpack_archive(zip_file, extract_dir=target_folder, format=format)
-    return target_folder
+#########################
+# actions on zipped bytes
+
+def zip_bytes__add_file(zip_bytes, zip_file_path, file_contents):                                       # todo: see if this is actually a valid use case (or if we should be using replace in all scenarios)
+    return zip_bytes__add_files(zip_bytes, {zip_file_path: file_contents})
+
+def zip_bytes__add_file__from_disk(zip_bytes, base_path, file_to_add):
+    return zip_bytes__add_files__from_disk(zip_bytes, base_path, files_to_add=[file_to_add])
+
+def zip_bytes__add_files__from_disk(zip_bytes, base_path, files_to_add, replace_files=True, path_prefix=None):
+    zip_files_to_add = {}
+    if base_path[:-1] != '/':
+        base_path += "/"
+
+    for file_to_add in files_to_add:
+        if file_exists(file_to_add):
+            file_contents = file_contents_as_bytes(file_to_add)
+            zip_file_path = file_to_add.replace(base_path, '')
+            if path_prefix:
+                zip_file_path = path_prefix + zip_file_path
+            zip_files_to_add[zip_file_path] = file_contents
+
+    if replace_files:
+        return zip_bytes__replace_files(zip_bytes, zip_files_to_add)
+    else:
+        return zip_bytes__add_files(zip_bytes, zip_files_to_add)                        # todo: see if this is actually a valid use case (or if we should be using replace in all scenarios)
+
+def zip_bytes__add_files(zip_bytes, files_to_add):                                      # todo: see if this is actually a valid use case (or if we should be using replace in all scenarios)
+    zip_buffer = io.BytesIO(zip_bytes)                                                  # Create a BytesIO buffer from the input zip bytes
 
-def zip_bytes_add_file(zip_bytes, zip_file_path, file_contents):
-    if type(file_contents) is str:
-        file_contents = file_contents.encode('utf-8')
-    elif type(file_contents) is not bytes:
-        return None
-    zip_buffer = io.BytesIO(zip_bytes)
     with zipfile.ZipFile(zip_buffer, 'a', zipfile.ZIP_DEFLATED) as zf:
-        zf.writestr(zip_file_path, file_contents)
+        for file_path, file_contents in files_to_add.items():
+            if isinstance(file_contents, str):
+                file_contents = file_contents.encode('utf-8')
+            elif not isinstance(file_contents, bytes):
+                continue
+            zf.writestr(file_path, file_contents)
 
     return zip_buffer.getvalue()
 
-def zip_bytes_get_file(zip_bytes, zip_file_path):
+def zip_bytes__file(zip_bytes, zip_file_path):
     zip_buffer = io.BytesIO(zip_bytes)
     with zipfile.ZipFile(zip_buffer, 'r') as zf:
-        return zf.read(zip_file_path)
+        if zip_file_path in zf.namelist():
+            return zf.read(zip_file_path)
+
+def zip_bytes__files(zip_bytes):
+    zip_buffer = io.BytesIO(zip_bytes)                      # Create a BytesIO buffer from the input zip bytes
+    files_dict = {}                                         # Create a dictionary to store file contents
+
+    with zipfile.ZipFile(zip_buffer, 'r') as zf:      # Open the zip file in read mode
+        for file_name in zf.namelist():                     # Iterate over each file in the zip archive
+            files_dict[file_name] = zf.read(file_name)      # Read the content of the file
+
+    return files_dict                                       # Return the dictionary with file contents
+
+def zip_bytes__file_list(zip_bytes):
+    zip_buffer_from_bytes = io.BytesIO(zip_bytes)
+    with zipfile.ZipFile(zip_buffer_from_bytes, 'r') as zf:
+        return sorted(zf.namelist())
+
+def zip_bytes__remove_file(zip_bytes, file_to_remove):
+    return zip_bytes__remove_files(zip_bytes, [file_to_remove])
+
+def zip_bytes__remove_files(zip_bytes, files_to_remove):
+    files_to_remove = set(files_to_remove)                                      # Convert files_to_remove to a set for faster lookup
+    zip_buffer      = io.BytesIO(zip_bytes)                                     # Create a BytesIO buffer from the input zip bytes
+    new_zip_buffer  = io.BytesIO()                                              # Create a new BytesIO buffer for the updated zip
+
+    with zipfile.ZipFile(zip_buffer, 'r') as original_zip:
+        with zipfile.ZipFile(new_zip_buffer, 'w') as new_zip:
+            for item in original_zip.infolist():                                # Iterate over each item in the original zip file
+                if item.filename not in files_to_remove:                        # Read the original content and write it to the new zip file
+                    new_zip.writestr(item, original_zip.read(item.filename))
+    return new_zip_buffer.getvalue()                                            # Get the updated zip content as bytes
+
+def zip_bytes__replace_file(zip_bytes, zip_file_path, file_contents):
+    files_to_replace = {zip_file_path: file_contents }
+    return zip_bytes__replace_files(zip_bytes, files_to_replace)
+
+def zip_bytes__replace_files(zip_bytes, files_to_replace):
+    zip_bytes__without_files       = zip_bytes__remove_files(zip_bytes               , set(files_to_replace))
+    zip_bytes__with_replaced_files = zip_bytes__add_files   (zip_bytes__without_files, files_to_replace     )
+    return zip_bytes__with_replaced_files
+
 
-def zip_bytes_extract_to_folder(zip_bytes, target_folder=None):
+def zip_bytes__unzip(zip_bytes, target_folder=None):
     target_folder = target_folder or temp_folder()              # Use the provided target folder or create a temporary one
     zip_buffer = io.BytesIO(zip_bytes)                          # Create a BytesIO buffer from the zip bytes
     with zipfile.ZipFile(zip_buffer, 'r') as zf:          # Open the zip file from the buffer
@@ -66,10 +137,33 @@ def zip_bytes_extract_to_folder(zip_bytes, target_folder=None):
     return target_folder                                        # Return the path of the target folder
 
 
-def zip_bytes_file_list(zip_bytes):
-    zip_buffer_from_bytes = io.BytesIO(zip_bytes)
-    with zipfile.ZipFile(zip_buffer_from_bytes, 'r') as zf:
-        return sorted(zf.namelist())
+########################
+# actions on zipped file
+
+def zip_file__list(path_zip_file):
+    if is_file(path_zip_file):
+        with zipfile.ZipFile(path_zip_file) as zip_file:
+            return sorted(zip_file.namelist())
+    return []
+
+def zip_file__files(path_zip_file):
+    if is_file(path_zip_file):
+        zip_bytes = file_contents_as_bytes(path_zip_file)
+        return zip_bytes__files(zip_bytes)
+    return []
+
+def zip_file__unzip(path_zip_file, target_folder=None, format='zip'):
+    target_folder = target_folder or temp_folder()
+    shutil.unpack_archive(path_zip_file, extract_dir=target_folder, format=format)
+    return target_folder
+
+# zip creation actions
+def zip_bytes_empty():
+
+    zip_buffer = io.BytesIO()                                               # Create a BytesIO buffer to hold the zip file
+    with zipfile.ZipFile(zip_buffer, mode='w') as _:                        # Use the zipfile.ZipFile class to create an empty zip file
+        pass                                                                # No files to add, so we just create the zip structure
+    return zip_buffer.getvalue()                                            # Get the zip file content as bytes
 
 def zip_bytes_to_file(zip_bytes, target_file=None):
     if target_file is None:
@@ -103,7 +197,6 @@ def zip_folder_to_file (root_dir, target_file):
     zip_file = zip_folder(root_dir)
     return file_move(zip_file, target_file)
 
-
 def zip_folder_to_bytes(root_dir):      # todo add unit test
     zip_buffer = io.BytesIO()                                                   # Create a BytesIO buffer to hold the zipped file
     with zipfile.ZipFile(zip_buffer, 'w', zipfile.ZIP_DEFLATED) as zf:          # Create a ZipFile object with the buffer as the target
@@ -115,12 +208,6 @@ def zip_folder_to_bytes(root_dir):      # todo add unit test
     zip_buffer.seek(0)                                                          # Reset buffer position
     return zip_buffer
 
-def zip_file_list(path):
-    if is_file(path):
-        with zipfile.ZipFile(path) as zip_file:
-            return sorted(zip_file.namelist())
-    return []
-
 def zip_files(base_folder, file_pattern="*.*", target_file=None):
     base_folder = abspath(base_folder)
     file_list   = folder_files(base_folder, file_pattern)
@@ -134,8 +221,18 @@ def zip_files(base_folder, file_pattern="*.*", target_file=None):
 
         return target_file
 
-
+###########################
 # extra function's mappings
-file_unzip                = unzip_file
-folder_zip                = zip_folder
-zip_bytes_unzip_to_folder = zip_bytes_extract_to_folder
+
+file_unzip                   = zip_file__unzip
+folder_zip                   = zip_folder
+
+unzip_file                   = zip_file__unzip
+
+zip_bytes__extract_to_folder = zip_bytes__unzip
+zip_bytes__file_contents     = zip_bytes__file
+zip_bytes__get_file          = zip_bytes__file
+zip_bytes__unzip_to_folder   = zip_bytes__unzip
+
+zip_list_files               = zip_file__list
+zip_file__file_list          = zip_file__list

osbot_utils/version

@@ -1 +1 @@
-v1.27.0
+v1.29.0

{osbot_utils-1.27.0.dist-info → osbot_utils-1.29.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: osbot_utils
-Version: 1.27.0
+Version: 1.29.0
 Summary: OWASP Security Bot - Utils
 Home-page: https://github.com/owasp-sbot/OSBot-Utils
 License: MIT
@@ -22,7 +22,7 @@ Description-Content-Type: text/markdown
 
 Powerful Python util methods and classes that simplify common apis and tasks.
 
-![Current Release](https://img.shields.io/badge/release-v1.27.0-blue)
+![Current Release](https://img.shields.io/badge/release-v1.29.0-blue)
 [![codecov](https://codecov.io/gh/owasp-sbot/OSBot-Utils/graph/badge.svg?token=GNVW0COX1N)](https://codecov.io/gh/owasp-sbot/OSBot-Utils)
 
 

{osbot_utils-1.27.0.dist-info → osbot_utils-1.29.0.dist-info}/RECORD

@@ -63,6 +63,7 @@ osbot_utils/helpers/Print_Table.py,sha256=LEXbyqGg_6WSraI4cob4bNNSu18ddqvALp1zGK
 osbot_utils/helpers/Python_Audit.py,sha256=shpZlluJwqJBAlad6xN01FkgC1TsQ48RLvR5ZjmrKa4,1539
 osbot_utils/helpers/Random_Seed.py,sha256=14btja8LDN9cMGWaz4fCNcMRU_eyx49gas-_PQvHgy4,634
 osbot_utils/helpers/Type_Registry.py,sha256=Ajk3SyMSKDi2g9SJYUtTgg7PZkAgydaHcpbGuEN3S94,311
+osbot_utils/helpers/Zip_Bytes.py,sha256=GQAwNEoMXdG7CU1RDhIJ51vkgfbJZnUxjlMUmFGHL1M,3937
 osbot_utils/helpers/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 osbot_utils/helpers/ast/Ast.py,sha256=lcPQOSxXI6zgmMnIVF9WM6ISqViWX-sq4d_UC0CDG8s,1155
 osbot_utils/helpers/ast/Ast_Base.py,sha256=5rHMupBlN_n6lOC31UnSW_lWqxqxaE31v0gn-t32OgQ,3708
@@ -251,11 +252,11 @@ osbot_utils/testing/Stderr.py,sha256=wi1gfjpsxnBK3aOl2jzCTWI-0En1HtPgEin97148_MQ
 osbot_utils/testing/Stdout.py,sha256=XQ9OlOW1aHXY1TiNu8O5b75RoDnoaX5RyMHml3OjlKw,459
 osbot_utils/testing/Temp_Env_Vars.py,sha256=oFuaegBlaV0aySkPe1Nzf-mdIKN03oTUKNfKijGz__M,751
 osbot_utils/testing/Temp_File.py,sha256=yZBL9MmcNU4PCQ4xlF4rSss4GylKoX3T_AJF-BlQhdI,1693
-osbot_utils/testing/Temp_Folder.py,sha256=gewV0L3B4ScKyorkVOQaQ-vz4DbeVRnqxCMS9A0eVLo,4953
+osbot_utils/testing/Temp_Folder.py,sha256=Dbcohr2ciex6w-kB79R41Nuoa0pgpDbKtPGnlMmJ73k,5194
 osbot_utils/testing/Temp_Sys_Path.py,sha256=gOMD-7dQYQlejoDYUqsrmuZQ9DLC07ymPZB3zYuNmG4,256
 osbot_utils/testing/Temp_Web_Server.py,sha256=0A-gZsd0_3wRj2YuBEOWyV2rhT6dcS2BlArngPXGTtk,3186
-osbot_utils/testing/Temp_Zip.py,sha256=Qaxu7J4zpdYn3bXgYOLT5BYRWu8-QgkUBA-LtqpNoS0,1487
-osbot_utils/testing/Temp_Zip_In_Memory.py,sha256=LhZZR3jQtRywdQNC71hvFk1I3Yek4eMPXpNTT8S6zHo,3278
+osbot_utils/testing/Temp_Zip.py,sha256=gppbJchk4tw_bu-7Vt6iJS9mGxeCvNNMMDzeVKHqRv8,1489
+osbot_utils/testing/Temp_Zip_In_Memory.py,sha256=ibDIWt3K4CX558PbkLbX3InHyWYZcwQwajFm1kAPW5U,3284
 osbot_utils/testing/Unit_Test.py,sha256=MReR_wDGbbXFDPz7cmuGflcTxRB6TBnO9mYqRpSq8Pk,1304
 osbot_utils/testing/Unzip_File.py,sha256=V5H97XO9rlvG5EYOSzAH4kTtAH1ohZ8R8ImvJh46ZNg,1177
 osbot_utils/testing/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -265,7 +266,7 @@ osbot_utils/utils/Csv.py,sha256=oHLVpjRJqrLMz9lubMCNEoThXWju5rNTprcwHc1zq2c,1012
 osbot_utils/utils/Dev.py,sha256=HibpQutYy_iG8gGV8g1GztxNN4l29E4Bi7UZaVL6-L8,1203
 osbot_utils/utils/Env.py,sha256=uYLhqVXqqgfh03Zmf9Vdy9zFdFf0rasW6lteh_VM1xQ,5078
 osbot_utils/utils/Exceptions.py,sha256=KyOUHkXQ_6jDTq04Xm261dbEZuRidtsM4dgzNwSG8-8,389
-osbot_utils/utils/Files.py,sha256=fWASqyfhUttKw4g3AfbhzplUPZL228nBzBSVqgLylvQ,20374
+osbot_utils/utils/Files.py,sha256=bZFvjyC4TAmFH6RSp3Xvj_xBxfybCT2cE7x2qNTQmeE,20834
 osbot_utils/utils/Functions.py,sha256=0E6alPJ0fJpBiJgFOWooCOi265wSRyxxXAJ5CELBnso,3498
 osbot_utils/utils/Http.py,sha256=Z8V149M2HDrKBoXkDD5EXgqTGx6vQoUqXugXK__wcuw,4572
 osbot_utils/utils/Int.py,sha256=PmlUdU4lSwf4gJdmTVdqclulkEp7KPCVUDO6AcISMF4,116
@@ -277,14 +278,15 @@ osbot_utils/utils/Objects.py,sha256=WFH3oeXR1CU03oyzXfcIlktcoXQuKw9cIJn8xTs02AE,
 osbot_utils/utils/Png.py,sha256=V1juGp6wkpPigMJ8HcxrPDIP4bSwu51oNkLI8YqP76Y,1172
 osbot_utils/utils/Process.py,sha256=lr3CTiEkN3EiBx3ZmzYmTKlQoPdkgZBRjPulMxG-zdo,2357
 osbot_utils/utils/Python_Logger.py,sha256=tx8N6wRKL3RDHboDRKZn8SirSJdSAE9cACyJkxrThZ8,12792
+osbot_utils/utils/Regex.py,sha256=0ubgp8HKsS3PNe2H6XlzMIcUuV7jhga3VkQVDNOJWuA,866
 osbot_utils/utils/Status.py,sha256=Yq4s0TelXgn0i2QjCP9V8mP30GabXp_UL-jjM6Iwiw4,4305
 osbot_utils/utils/Str.py,sha256=kxdY8ROX4FdJtCaMTfOc8fK_xcDICprNkefHu2MMNU4,2585
 osbot_utils/utils/Toml.py,sha256=dqiegndCJF7V1YT1Tc-b0-Bl6QWyL5q30urmQwMXfMQ,1402
 osbot_utils/utils/Version.py,sha256=Ww6ChwTxqp1QAcxOnztkTicShlcx6fbNsWX5xausHrg,422
-osbot_utils/utils/Zip.py,sha256=yGTRuE1gaUMZ8T_lnM0PAU31Kwd-TrzEuuWysJVgHGA,6868
+osbot_utils/utils/Zip.py,sha256=t9txUxJzLBEHot6WJwF0iTTUQ1Gf_V2pVwsWzAqw_NU,12163
 osbot_utils/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-osbot_utils/version,sha256=geP7KEJu4xooR8XnusEbz-qnkD4i7bGqu2XFp8jXSIo,8
-osbot_utils-1.27.0.dist-info/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
-osbot_utils-1.27.0.dist-info/METADATA,sha256=DGQYf9EpRkKvgPfZZ2Z2xQVy8sLD6ODZwAUZfvr68nU,1266
-osbot_utils-1.27.0.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
-osbot_utils-1.27.0.dist-info/RECORD,,
+osbot_utils/version,sha256=Cnimb4t_Vj3piSoNKuKNxuAK7SFZPFgzcFqpUzq2s2A,8
+osbot_utils-1.29.0.dist-info/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+osbot_utils-1.29.0.dist-info/METADATA,sha256=CBXxh-9F_qSZWcp7WC1L7HM7_DtuHivZ5rp5STqAS9U,1266
+osbot_utils-1.29.0.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
+osbot_utils-1.29.0.dist-info/RECORD,,