osbot-utils 1.11.0__tar.gz → 1.13.0__tar.gz

{osbot_utils-1.11.0 → osbot_utils-1.13.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: osbot_utils
-Version: 1.11.0
+Version: 1.13.0
 Summary: OWASP Security Bot - Utils
 Home-page: https://github.com/owasp-sbot/OSBot-Utils
 License: MIT
@@ -11,7 +11,6 @@ Classifier: License :: OSI Approved :: MIT License
 Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
-Requires-Dist: python-dotenv
 Project-URL: Repository, https://github.com/owasp-sbot/OSBot-Utils
 Description-Content-Type: text/markdown
 
@@ -19,14 +18,14 @@ 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.11.0-blue)
+![Current Release](https://img.shields.io/badge/release-v1.13.0-blue)
 [![codecov](https://codecov.io/gh/owasp-sbot/OSBot-Utils/graph/badge.svg?token=GNVW0COX1N)](https://codecov.io/gh/owasp-sbot/OSBot-Utils)
 
 
 
 ## Install - Release 1.x
 
-**for main branch**: add to requirements.txt
+**for main branch**: just get it from pypi
 
 ```
 pip install osbot-utils

{osbot_utils-1.11.0 → osbot_utils-1.13.0}/README.md

@@ -2,14 +2,14 @@
 
 Powerful Python util methods and classes that simplify common apis and tasks.
 
-![Current Release](https://img.shields.io/badge/release-v1.11.0-blue)
+![Current Release](https://img.shields.io/badge/release-v1.13.0-blue)
 [![codecov](https://codecov.io/gh/owasp-sbot/OSBot-Utils/graph/badge.svg?token=GNVW0COX1N)](https://codecov.io/gh/owasp-sbot/OSBot-Utils)
 
 
 
 ## Install - Release 1.x
 
-**for main branch**: add to requirements.txt
+**for main branch**: just get it from pypi
 
 ```
 pip install osbot-utils

{osbot_utils-1.11.0 → osbot_utils-1.13.0}/osbot_utils/helpers/sqlite/Sqlite__Cursor.py

@@ -84,4 +84,7 @@ class Sqlite__Cursor(Kwargs_To_Self):
         self.execute(sql_query)
         all_rows   = self.cursor().fetchall()
         all_values = [cell.get(cell_name) for cell in all_rows]
-        return all_values
+        return all_values
+
+    def vacuum(self):
+        return self.execute("VACUUM")

{osbot_utils-1.11.0 → osbot_utils-1.13.0}/osbot_utils/helpers/sqlite/Sqlite__Database.py

@@ -130,8 +130,11 @@ class Sqlite__Database(Kwargs_To_Self):
             table_names.append('sqlite_master')
         return table_names
 
+    def purge_database(self):       # this fells like a better name than vacuum :)
+        return self.vacuum()
 
-
+    def vacuum(self):
+        return self.cursor().vacuum()
 
 
 

{osbot_utils-1.11.0 → osbot_utils-1.13.0}/osbot_utils/helpers/sqlite/Sqlite__Table.py

@@ -130,6 +130,7 @@ class Sqlite__Table(Kwargs_To_Self):
         rows              = table_sqlite_master.cursor().execute__fetch_all(sql_query, params)
         return table_sqlite_master.list_of_field_name_from_rows(rows, field_name)
 
+
     def new_row_obj(self, row_data=None):
         if self.row_schema:
             new_obj = self.row_schema()
@@ -154,6 +155,7 @@ class Sqlite__Table(Kwargs_To_Self):
                         picked_row_data[field_name] = field_value
                 return picked_row_data
         return row_data
+
     def parse_row(self, row):
         if row and self.auto_pickle_blob:
             fields = self.fields__cached()
@@ -169,6 +171,14 @@ class Sqlite__Table(Kwargs_To_Self):
     def print(self, **kwargs):
         return Print_Table(**kwargs).print(self.rows())
 
+    def row(self, where, fields=None):
+        if fields is None:
+            return self.select_row_where(**where)
+
+        sql_query, params = self.sql_builder(limit=1).query_select_fields_with_conditions(fields, where)
+        row               = self.cursor().execute__fetch_one(sql_query, params)
+        return self.parse_row(row)
+
     def row_add(self, row_obj=None):
         invalid_reason = self.sql_builder().validate_row_obj(row_obj)
         if invalid_reason:

osbot_utils-1.13.0/osbot_utils/helpers/sqlite/domains/Sqlite__DB__Files.py

@@ -0,0 +1,45 @@
+from osbot_utils.decorators.lists.index_by import index_by
+from osbot_utils.decorators.methods.cache_on_self import cache_on_self
+from osbot_utils.helpers.sqlite.domains.Sqlite__DB__Local import Sqlite__DB__Local
+from osbot_utils.helpers.sqlite.tables.Sqlite__Table__Files import Sqlite__Table__Files
+
+
+class Sqlite__DB__Files(Sqlite__DB__Local):
+
+    def __init__(self, db_path=None, db_name=None):
+        super().__init__(db_path=db_path, db_name=db_name)
+
+    def add_file(self, path, contents=None, metadata=None):
+        return self.table_files().add_file(path, contents, metadata)
+
+    def clear_table(self):
+        self.table_files().clear()
+
+    def delete_file(self, path):
+        return self.table_files().delete_file(path)
+
+    def file(self, path, include_contents=False):
+        return self.table_files().file(path, include_contents=include_contents)
+
+    def file_exists(self, path):
+        return self.table_files().file_exists(path)
+
+    def file_names(self):
+        return self.table_files().select_field_values('path')
+    @cache_on_self
+    def table_files(self):
+        return Sqlite__Table__Files(database=self).setup()
+
+    @index_by
+    def files(self,include_contents=False):
+        return self.table_files().files(include_contents=include_contents)
+
+    def files__with_content(self):
+        return self.files(include_contents=True)
+
+    def files__by_path(self):
+        return self.files(index_by='path')
+
+    def setup(self):
+        self.table_files()
+        return self

{osbot_utils-1.11.0 → osbot_utils-1.13.0}/osbot_utils/helpers/sqlite/domains/Sqlite__DB__Local.py

@@ -10,7 +10,8 @@ class Sqlite__DB__Local(Sqlite__Database):
     db_name: str
 
     def __init__(self, db_path=None, db_name=None):
-        self.db_name = db_name or random_text('db_local') + '.sqlite'
+        if hasattr(self, 'db_name') is False:
+            self.db_name = db_name or random_text('db_local') + '.sqlite'
         super().__init__(db_path=db_path or self.path_local_db())
 
     def path_db_folder(self):

osbot_utils-1.13.0/osbot_utils/helpers/sqlite/tables/Sqlite__Table__Files.py

@@ -0,0 +1,86 @@
+from osbot_utils.base_classes.Kwargs_To_Self import Kwargs_To_Self
+from osbot_utils.helpers.sqlite.Sqlite__Table import Sqlite__Table
+from osbot_utils.utils.Misc import timestamp_utc_now, bytes_sha256, str_sha256
+from osbot_utils.utils.Status import status_warning, status_ok
+
+SQLITE__TABLE_NAME__FILES = 'files'
+
+class Schema__Table__Files(Kwargs_To_Self):
+    path     : str
+    contents : bytes
+    metadata : bytes
+    timestamp: int
+
+
+class Sqlite__Table__Files(Sqlite__Table):
+    auto_pickle_blob    : bool = True
+    set_timestamp       : bool = True
+
+    def __init__(self, **kwargs):
+        self.table_name = SQLITE__TABLE_NAME__FILES
+        self.row_schema  = Schema__Table__Files
+        super().__init__(**kwargs)
+
+    def add_file(self, path, contents=None, metadata= None):
+        if self.contains(path=path):                                                    # don't allow multiple entries for the same file path (until we add versioning support)
+            return status_warning(f"File not added, since file with path '{path}' already exists in the database")
+        if metadata is None:
+            metadata = {}
+        metadata.update(self.create_contents_metadata(contents))
+        row_data    = self.create_node_data(path, contents, metadata)
+        new_row_obj = self.add_row_and_commit(**row_data)
+        return status_ok(message='file added', data= new_row_obj)
+
+    def create_contents_metadata(self, contents):
+        file_size       = len(contents)
+        file_is_binary = type(contents) is bytes
+        if file_is_binary:
+            file_hash  = bytes_sha256(contents)
+        else:
+            file_hash = str_sha256(str(contents))
+        return dict(file_contents=dict(hash      = file_hash      ,
+                                       is_binary = file_is_binary ,
+                                       size      = file_size      ))
+
+    def delete_file(self, path):
+        if self.not_contains(path=path):                                                    # don't allow multiple entries for the same file path (until we add versioning support)
+            return status_warning(f"File not deleted, since file with path '{path}' did not exist in the database")
+
+        self.rows_delete_where(path=path)
+        return status_ok(message='file deleted')
+
+    def create_node_data(self, path, contents=None, metadata= None):
+        node_data = {'path'    : path     ,
+                     'contents': contents ,
+                     'metadata': metadata }
+        if self.set_timestamp:
+            node_data['timestamp'] = timestamp_utc_now()
+        return node_data
+
+    def field_names_without_content(self):                      # todo: refactor to get this directly from the schema
+        return ['id', 'path', 'metadata', 'timestamp']          #       and so that these values are not hard-coded here
+
+    def file(self, path, include_contents=True):
+        if include_contents:
+            fields = ['*']
+        else:
+            fields = self.field_names_without_content()
+        return self.row(where=dict(path=path), fields = fields)
+
+    def file_without_contents(self, path):
+        return self.file(path, include_contents=False)
+
+    def file_exists(self, path):
+        return self.contains(path=path)
+
+    def files(self, include_contents=False):
+        if include_contents:
+            return self.rows()
+        fields_names = self.field_names_without_content()
+        return self.rows(fields_names)
+
+    def setup(self):
+        if self.exists() is False:
+            self.create()
+            self.index_create('path')
+        return self

{osbot_utils-1.11.0 → osbot_utils-1.13.0}/osbot_utils/testing/Temp_File.py

@@ -1,11 +1,11 @@
-from osbot_utils.utils.Files import Files, file_delete, folder_delete_all, files_list, file_create, file_name, \
+from osbot_utils.utils.Files import Files, file_delete, folder_delete_all, files_list, file_create, \
     parent_folder, file_exists, file_contents
 from osbot_utils.utils.Misc import random_filename
 
 
 class Temp_File:
-    def __init__(self, contents='...', extension='tmp'):
-        self.tmp_file            = random_filename(extension)
+    def __init__(self, contents='...', extension='tmp',file_name=None, ):
+        self.tmp_file            = file_name or random_filename(extension)
         self.tmp_folder          = None
         self.file_path           = None
         self.original_contents   = contents
@@ -30,7 +30,7 @@ class Temp_File:
         return file_exists(self.file_path)
 
     def file_name(self):
-        return file_name(self.path())
+        return Files.file_name(self.path())
 
     def files_in_folder(self):
         return files_list(self.tmp_folder)

osbot_utils-1.13.0/osbot_utils/utils/Env.py

@@ -0,0 +1,76 @@
+# In Misc.py
+import os
+
+from osbot_utils.utils.Files import all_parent_folders
+from osbot_utils.utils.Misc import list_set
+from osbot_utils.utils.Str import strip_quotes
+
+
+def env_value(var_name):
+    return env_vars().get(var_name, None)
+
+def env_vars_list():
+    return list_set(env_vars())
+
+def env_vars(reload_vars=False):
+    """
+    if reload_vars reload data from .env file
+    then return dictionary with current environment variables
+    """
+    if reload_vars:
+        load_dotenv()
+    vars = os.environ
+    data = {}
+    for key in vars:
+        data[key] = vars[key]
+    return data
+
+def env_load_from_file(path, override=False):
+    if os.path.exists(path):
+        with open(path) as f:
+            for line in f:
+                line = line.strip()
+                if not line or line.startswith('#'):                # Strip whitespace and ignore comments
+                    continue
+                key, value = line.split(sep='=', maxsplit=1)        # Split the line into key and value
+                value = strip_quotes(value.strip())                 # Handle case when the value is in quotes
+                if override or key.strip() not in os.environ:       # Set the environment variable
+                    os.environ[key.strip()] = value.strip()
+
+def env_unload_from_file(path):
+    if os.path.exists(path):
+        with open(path) as f:
+            for line in f:
+                line = line.strip()
+                if not line or line.startswith('#'):  # Strip whitespace and ignore comments
+                    continue
+                key, _ = line.split(sep='=', maxsplit=1)  # Split the line into key and value
+                key = key.strip()
+                if key in os.environ:  # Remove the environment variable if it exists
+                    del os.environ[key]
+
+def load_dotenv(dotenv_path=None, override=False):
+    if dotenv_path:                                                 # If a specific dotenv path is provided, load from it
+        env_load_from_file(dotenv_path, override)
+    else:
+        directories = all_parent_folders(include_path=True)         # Define the possible directories to search for the .env file (which is this and all parent folders)
+        for directory in directories:                               # Iterate through the directories and load the .env file if found
+            env_path = os.path.join(directory, '.env')              # Define the path to the .env file
+            if os.path.exists(env_path):                            # If we found one
+                env_load_from_file(env_path, override)              # Process it
+                break                                               # Stop after loading the first .env file                                                     # Stop after loading the first .env file
+
+
+def unload_dotenv(dotenv_path=None):
+    if dotenv_path:                                                 # If a specific dotenv path is provided, unload from it
+        env_unload_from_file(dotenv_path)
+    else:
+        directories = all_parent_folders(include_path=True)         # Define the possible directories to search for the .env file (which is this and all parent folders)
+        for directory in directories:                               # Iterate through the directories and unload the .env file if found
+            env_path = os.path.join(directory, '.env')              # Define the path to the .env file
+            if os.path.exists(env_path):                            # If we found one
+                env_unload_from_file(env_path)                      # Process it
+                break                                               # Stop after unloading the first .env file
+
+
+env_load = load_dotenv

{osbot_utils-1.11.0 → osbot_utils-1.13.0}/osbot_utils/utils/Files.py

@@ -21,7 +21,7 @@ class Files:
     def copy(source:str, destination:str) -> str:
         if file_exists(source):                                     # make sure source file exists
             destination_parent_folder = parent_folder(destination)  # get target parent folder
-            folder_create(destination_parent_folder)                # ensure targer folder exists       # todo: check if this is still needed (we should be using a copy method that creates the required fodlers)
+            folder_create(destination_parent_folder)                # ensure target folder exists       # todo: check if this is still needed (we should be using a copy method that creates the required fodlers)
             return shutil.copy(source, destination)                 # copy file and returns file destination
 
     @staticmethod
@@ -308,7 +308,11 @@ class Files:
     @staticmethod
     def path_combine(path1, path2):
         if type(path1) in [str, Path] and type(path2) in [str, Path]:
-            return abspath(join(str(path1), str(path2)))
+            parent_path = str(path1)
+            sub_path    = str(path2)
+            if sub_path.startswith('/'):
+                sub_path = sub_path[1:]
+            return abspath(join(parent_path,sub_path))
 
     @staticmethod
     def parent_folder(path):
@@ -424,13 +428,53 @@ class Files:
             file.write(contents)
         return path
 
-# todo: refactor the methods above into static methods
+# todo: refactor the methods above into static methods (as bellow)
 
+def all_parent_folders(path=None, include_path=False):
+    if path is None:
+        path = os.getcwd()
+    parent_directories = []
 
+    # Optionally include the starting path
+    if include_path:
+        parent_directories.append(path)
+
+    while True:                                         # Split the path into parts
+        path, tail = os.path.split(path)
+        if tail:
+            parent_directories.append(path)
+        else:
+            if path and path not in parent_directories:  # to handle the root path case
+                parent_directories.append(path)
+            break
+
+    return parent_directories
+def file_move(source_file, target_file):
+    if file_exists(source_file):
+        file_copy(source_file, target_file)
+        if file_exists(target_file):
+            if file_delete(source_file):
+                return True
+    return False
+
+def folders_names_in_folder(target):
+    folders = folders_in_folder(target)
+    return folders_names(folders)
+
+def stream_to_bytes(stream):
+    return stream.read()
+
+def stream_to_file(stream, path=None):
+    if path is None:                        # if path is not defined
+        path = Files.temp_file()            # save it to a temp file
+    with open(path, 'wb') as file:          # Write the content to the file
+        file.write(stream.read())
+    return path
 
 # helper methods
 # todo: all all methods above (including the duplicated mappings at the top)
 
+bytes_to_file                  = Files.write_bytes
 create_folder                  = Files.folder_create
 create_folder_in_parent        = Files.folder_create_in_parent
 create_temp_file               = Files.write
@@ -465,6 +509,7 @@ file_open_gz                   = Files.open_gz
 file_open_bytes                = Files.open_bytes
 file_to_base64                 = Files.file_to_base64
 file_from_base64               = Files.file_from_base64
+file_from_bytes                = Files.write_bytes
 file_save                      = Files.save
 file_sha256                    = Files.contents_sha256
 file_size                      = Files.file_size

{osbot_utils-1.11.0 → osbot_utils-1.13.0}/osbot_utils/utils/Objects.py

@@ -7,8 +7,6 @@ import pickle
 import types
 from typing import get_origin, Union, get_args
 
-from dotenv import load_dotenv
-
 from osbot_utils.utils.Misc import list_set
 from osbot_utils.utils.Str  import str_unicode_escape, str_max_width
 
@@ -88,24 +86,6 @@ def enum_from_value(enum_type, value):
     except KeyError:
         raise ValueError(f"Value '{value}' is not a valid member of {enum_type.__name__}.")     # Handle the case where the value does not match any Enum member
 
-def env_value(var_name):
-    return env_vars().get(var_name, None)
-
-def env_vars_list():
-    return list_set(env_vars())
-
-def env_vars(reload_vars=False):
-    """
-    if reload_vars reload data from .env file
-    then return dictionary with current environment variables
-    """
-    if reload_vars:
-        load_dotenv()
-    vars = os.environ
-    data = {}
-    for key in vars:
-        data[key] = vars[key]
-    return data
 
 def get_field(target, field, default=None):
     if target is not None:

{osbot_utils-1.11.0 → osbot_utils-1.13.0}/osbot_utils/utils/Str.py

@@ -3,13 +3,19 @@ from html import escape, unescape
 
 from osbot_utils.utils.Files import safe_file_name
 
+# todo: refactor this this class all str related methods (mainly from the Misc class)
 
-def html_escape(value):
+def html_escape(value: str):
     return escape(value)
 
-def html_unescape(value):
+def html_unescape(value: str):
     return unescape(value)
 
+def strip_quotes(value: str):                           # Remove surrounding quotes (single or double)
+    if (value.startswith("'") and value.endswith("'")) or (value.startswith('"') and value.endswith('"')):
+        return value[1:-1]
+    return value
+
 def str_dedent(value, strip=True):
     result = textwrap.dedent(value)
     if strip:

{osbot_utils-1.11.0 → osbot_utils-1.13.0}/osbot_utils/utils/Zip.py

@@ -1,11 +1,41 @@
+import gzip
 import io
 import os
 import shutil
+import tarfile
 import zipfile
 from os.path import abspath
 
-from osbot_utils.utils.Files import temp_folder, folder_files, temp_file, is_file
+from osbot_utils.utils.Files import temp_folder, folder_files, temp_file, is_file, file_copy, file_move
+
+
+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()
+        tar_buffer_from_bytes = io.BytesIO(decompressed_data)                       # Assuming the decompressed data is a tag file, process it
+        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):
+    gz_buffer_from_bytes = io.BytesIO(gz_bytes)
+    with gzip.GzipFile(fileobj=gz_buffer_from_bytes, mode='rb') as gz:
+        decompressed_data = gz.read()
+        tar_buffer_from_bytes = io.BytesIO(decompressed_data)
+        with tarfile.open(fileobj=tar_buffer_from_bytes, mode='r:') as tar:
+            extracted_file = tar.extractfile(tar_file_path)
+            if extracted_file:
+                return extracted_file.read()
+            else:
+                raise FileNotFoundError(f"The file {tar_file_path} was not found in the tar archive.")
 
+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()
+        zip_buffer_from_bytes = io.BytesIO(decompressed_data)                   # Assuming the decompressed data is a zip file, process it
+        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()
@@ -28,6 +58,14 @@ def zip_bytes_get_file(zip_bytes, zip_file_path):
     with zipfile.ZipFile(zip_buffer, 'r') as zf:
         return zf.read(zip_file_path)
 
+def zip_bytes_extract_to_folder(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
+        zf.extractall(target_folder)                            # Extract all files to the target folder
+    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:
@@ -61,6 +99,11 @@ def zip_files_to_bytes(target_files, root_folder=None):
 def zip_folder(root_dir, format='zip'):
     return shutil.make_archive(base_name=root_dir, format=format, root_dir=root_dir)
 
+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

osbot_utils-1.13.0/osbot_utils/version

@@ -0,0 +1 @@
+v1.13.0

{osbot_utils-1.11.0 → osbot_utils-1.13.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name        = "osbot_utils"
-version     = "v1.11.0"
+version     = "v1.13.0"
 description = "OWASP Security Bot - Utils"
 authors     = ["Dinis Cruz <dinis.cruz@owasp.org>"]
 license     = "MIT"
@@ -10,12 +10,6 @@ repository  = "https://github.com/owasp-sbot/OSBot-Utils"
 
 [tool.poetry.dependencies]
 python          = "^3.11"
-python-dotenv   = "*"
-
-#[tool.poetry.group.test.dependencies]
-#pytest          = "*"
-#pytest-cov      = "*"
-#coveralls       = "*"
 
 
 [build-system]

osbot_utils-1.11.0/osbot_utils/helpers/sqlite/domains/Sqlite__DB__Files.py

@@ -1,23 +0,0 @@
-from osbot_utils.decorators.methods.cache_on_self import cache_on_self
-from osbot_utils.helpers.sqlite.domains.Sqlite__DB__Local import Sqlite__DB__Local
-from osbot_utils.helpers.sqlite.tables.Sqlite__Table__Files import Sqlite__Table__Files
-
-
-class Sqlite__DB__Files(Sqlite__DB__Local):
-
-    def __init__(self, db_path=None, db_name=None):
-        super().__init__(db_path=db_path, db_name=db_name)
-
-    def add_file(self, path, contents=None, metadata=None):
-        return self.table_files().add_file(path, contents, metadata)
-
-    @cache_on_self
-    def table_files(self):
-        return Sqlite__Table__Files(database=self).setup()
-
-    def files(self):
-        return self.table_files().files()
-
-    def setup(self):
-        self.table_files()
-        return self

osbot_utils-1.11.0/osbot_utils/helpers/sqlite/tables/Sqlite__Table__Files.py

@@ -1,45 +0,0 @@
-from osbot_utils.base_classes.Kwargs_To_Self import Kwargs_To_Self
-from osbot_utils.helpers.sqlite.Sqlite__Table import Sqlite__Table
-from osbot_utils.utils.Misc import timestamp_utc_now
-
-SQLITE__TABLE_NAME__FILES = 'files'
-
-class Schema__Table__Files(Kwargs_To_Self):
-    path     : str
-    contents : bytes
-    metadata : bytes
-    timestamp: int
-
-
-class Sqlite__Table__Files(Sqlite__Table):
-    auto_pickle_blob    : bool = True
-    set_timestamp       : bool = True
-
-    def __init__(self, **kwargs):
-        self.table_name = SQLITE__TABLE_NAME__FILES
-        self.row_schema  = Schema__Table__Files
-        super().__init__(**kwargs)
-
-    def add_file(self, path, contents=None, metadata= None):
-        if self.contains(path=path):                                     # don't allow multiple entries for the same file path (until we add versioning support)
-            return None
-        row_data = self.create_node_data(path, contents, metadata)
-        return self.add_row_and_commit(**row_data)
-
-    def create_node_data(self, path, contents=None, metadata= None):
-        node_data = {'path'    : path     ,
-                     'contents': contents ,
-                     'metadata': metadata }
-        if self.set_timestamp:
-            node_data['timestamp'] = timestamp_utc_now()
-        return node_data
-
-
-    def files(self):
-        return self.rows()
-
-    def setup(self):
-        if self.exists() is False:
-            self.create()
-            self.index_create('path')
-        return self