osbot-utils 1.7.7__py3-none-any.whl

osbot_utils/helpers/pubsub/PubSub__Server.py

@@ -0,0 +1,94 @@
+import queue
+from threading import Thread
+from queue import Queue
+
+from osbot_utils.helpers.pubsub.Event__Queue                        import Event__Queue
+from osbot_utils.helpers.pubsub.PubSub__Client                      import PubSub__Client
+from osbot_utils.helpers.pubsub.PubSub__Room import PubSub__Room
+from osbot_utils.helpers.pubsub.schemas.Schema__Event               import Schema__Event
+from osbot_utils.helpers.pubsub.schemas.Schema__Event__Connect      import Schema__Event__Connect
+from osbot_utils.helpers.pubsub.schemas.Schema__Event__Leave_Room   import Schema__Event__Leave_Room
+from osbot_utils.helpers.pubsub.schemas.Schema__Event__Disconnect   import Schema__Event__Disconnect
+from osbot_utils.helpers.pubsub.schemas.Schema__Event__Join_Room    import Schema__Event__Join_Room
+from osbot_utils.helpers.pubsub.schemas.Schema__Event__Message import Schema__Event__Message
+from osbot_utils.testing.Logging                                    import Logging
+from osbot_utils.utils.Dev                                          import pprint
+
+
+class PubSub__Server(Event__Queue):
+    #pubsub_db: PubSub__Sqlite
+    clients          : dict
+    clients_connected: set[PubSub__Client]
+    rooms            : dict[str, PubSub__Room]
+    logging          : Logging
+
+    def __init__ (self):
+        super().__init__()
+
+    # def db_table_clients(self):
+    #     return self.pubsub_db.table_clients()     # todo refactor to class that uses this as a base and uses sqlite to capture connections
+
+    def add_client(self, client: PubSub__Client):
+        client_id = client.client_id
+        if client_id:
+            self.clients[client_id] = client
+        return self
+
+    def client_connect(self, client):
+        self.clients_connected.add(client)
+
+    def client_disconnect(self, client):
+        self.clients_connected.discard(client)
+
+    def client_join_room(self, client, event):
+        room_name = event.room_name
+        if room_name:
+            self.room(room_name).clients.add(client)
+
+    def client_message(self, client, event):
+        pass
+
+    def client_leave_room(self, client, event):
+        room_name = event.room_name
+        if room_name:
+            self.room(room_name).clients.discard(client)
+
+    def get_client(self, client_id):
+        return self.clients.get(client_id)
+
+    def handle_event(self, event: Schema__Event):
+        event_type = type(event)
+        client     = self.clients.get(event.connection_id)
+        if client:
+            if   event_type is Schema__Event__Connect    : self.client_connect   (client)
+            elif event_type is Schema__Event__Disconnect : self.client_disconnect(client)
+            elif event_type is Schema__Event__Join_Room  : self.client_join_room (client, event)
+            elif event_type is Schema__Event__Leave_Room : self.client_leave_room(client, event)
+            elif event_type is Schema__Event__Message    : self.client_message   (client, event)
+            else:
+                return False
+
+        if self.log_events:
+            self.events.append(event)
+        return True
+
+    def log(self, message):
+        self.logging.debug(message)
+        return self
+
+    def new_client(self):
+        client = PubSub__Client(event_queue = self)
+        self.add_client(client)
+        return client
+
+    def room(self, room_name):
+        if room_name not in self.rooms:
+            new_room = PubSub__Room(room_name=room_name)
+            self.rooms[room_name] = new_room
+
+        return self.rooms.get(room_name)
+
+
+
+
+

osbot_utils/helpers/pubsub/PubSub__Sqlite.py

@@ -0,0 +1,24 @@
+from osbot_utils.decorators.methods.cache_on_self import cache_on_self
+from osbot_utils.helpers.pubsub.schemas.Schema__PubSub__Client import Schema__PubSub__Clients
+from osbot_utils.helpers.sqlite.Sqlite__Database import Sqlite__Database
+
+TABLE_NAME__PUB_SUB__CLIENTS   = 'pubsub_clients'
+TABLE_SCHEMA__PUB_SUB__CLIENTS = Schema__PubSub__Clients
+
+class PubSub__Sqlite(Sqlite__Database):
+
+    @cache_on_self
+    def table_clients(self):
+        return self.table(TABLE_NAME__PUB_SUB__CLIENTS)
+
+    def table_clients__create(self):
+        with self.table_clients() as _:
+            _.row_schema = TABLE_SCHEMA__PUB_SUB__CLIENTS
+            if _.exists() is False:
+                _.create()                      # create if it doesn't exist
+                return True
+        return False
+
+    def setup(self):
+        self.table_clients__create()
+        return self

osbot_utils/helpers/pubsub/schemas/Schema__Event.py

@@ -0,0 +1,15 @@
+from osbot_utils.base_classes.Kwargs_To_Self import Kwargs_To_Self
+from osbot_utils.utils.Misc import random_guid
+
+
+class Schema__Event(Kwargs_To_Self):
+    connection_id: str
+    event_id     : str
+    event_data   : dict
+    event_message: str
+    event_target : str
+    event_type   : str
+    timestamp    : int
+
+    def __repr__(self):
+        return f'<{self.__class__.__name__}: {self.event_id}>'

osbot_utils/helpers/pubsub/schemas/Schema__Event__Connect.py

@@ -0,0 +1,7 @@
+from osbot_utils.base_classes.Kwargs_To_Self import Kwargs_To_Self
+from osbot_utils.helpers.pubsub.schemas.Schema__Event import Schema__Event
+from osbot_utils.utils.Misc import random_guid
+
+
+class Schema__Event__Connect(Schema__Event):
+    event_type : str  = 'connect'

osbot_utils/helpers/pubsub/schemas/Schema__Event__Disconnect.py

@@ -0,0 +1,7 @@
+from osbot_utils.base_classes.Kwargs_To_Self import Kwargs_To_Self
+from osbot_utils.helpers.pubsub.schemas.Schema__Event import Schema__Event
+from osbot_utils.utils.Misc import random_guid
+
+
+class Schema__Event__Disconnect(Schema__Event):
+    event_type : str  = 'disconnect'

osbot_utils/helpers/pubsub/schemas/Schema__Event__Join_Room.py

@@ -0,0 +1,8 @@
+from osbot_utils.base_classes.Kwargs_To_Self import Kwargs_To_Self
+from osbot_utils.helpers.pubsub.schemas.Schema__Event import Schema__Event
+from osbot_utils.utils.Misc import random_guid
+
+
+class Schema__Event__Join_Room(Schema__Event):
+    event_type : str = 'join-room'
+    room_name  : str

osbot_utils/helpers/pubsub/schemas/Schema__Event__Leave_Room.py

@@ -0,0 +1,8 @@
+from osbot_utils.base_classes.Kwargs_To_Self import Kwargs_To_Self
+from osbot_utils.helpers.pubsub.schemas.Schema__Event import Schema__Event
+from osbot_utils.utils.Misc import random_guid
+
+
+class Schema__Event__Leave_Room(Schema__Event):
+    event_type : str = 'leave-room'
+    room_name  : str

osbot_utils/helpers/pubsub/schemas/Schema__Event__Message.py

@@ -0,0 +1,7 @@
+from osbot_utils.base_classes.Kwargs_To_Self import Kwargs_To_Self
+from osbot_utils.helpers.pubsub.schemas.Schema__Event import Schema__Event
+from osbot_utils.utils.Misc import random_guid
+
+
+class Schema__Event__Message(Schema__Event):
+    pass

osbot_utils/helpers/pubsub/schemas/Schema__PubSub__Client.py

@@ -0,0 +1,8 @@
+from osbot_utils.base_classes.Kwargs_To_Self import Kwargs_To_Self
+
+
+class Schema__PubSub__Clients(Kwargs_To_Self):
+    client_id            : str
+    status               : str
+    timestamp_connect    : int
+    timestamp_disconnect : str

osbot_utils/helpers/sqlite/Capture_Sqlite_Error.py

@@ -0,0 +1,51 @@
+import sqlite3
+from functools import wraps
+from osbot_utils.utils.Dev import pprint
+
+def capture_sqlite_error(func):
+    @wraps(func)
+    def wrapper(*args, **kwargs):
+        return_value = None
+        with Capture_Sqlite_Error() as error_capture:
+            try:
+                return_value = func(*args, **kwargs)
+            except Exception as e:
+                raise e
+        if error_capture.error_details:
+            print()
+            pprint('****** SQLITE ERROR DETECTED ******')
+            pprint(error_capture.error_details)
+        return return_value
+
+    return wrapper
+
+class Capture_Sqlite_Error:
+    def __init__(self):
+        self.error_details = {}
+
+    def __enter__(self):
+        return self
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        if exc_val:  # Check if an exception occurred
+            if isinstance(exc_val, sqlite3.ProgrammingError):  # Check for SQLite ProgrammingError
+                self.process_programming_error(exc_val)
+                return True  # Prevent the exception from propagating
+            elif isinstance(exc_val, sqlite3.Error):  # Handle other generic sqlite3 errors
+                self.process_generic_sqlite_error(exc_val)
+                return True
+        return False  # Allow exceptions not handled here to propagate
+
+    def process_programming_error(self, exc_val):
+        error_message = str(exc_val)
+        self.error_details = {
+            'error_code': 'ProgrammingError',
+            'error_message': error_message
+        }
+
+    def process_generic_sqlite_error(self, exc_val):
+        error_message = str(exc_val)
+        self.error_details = {
+            'error_code': type(exc_val).__name__,
+            'error_message': error_message
+        }

osbot_utils/helpers/sqlite/Sqlite__Cursor.py

@@ -0,0 +1,87 @@
+from osbot_utils.base_classes.Kwargs_To_Self import Kwargs_To_Self
+from osbot_utils.decorators.methods.cache import cache
+from osbot_utils.decorators.methods.cache_on_self import cache_on_self
+from osbot_utils.helpers.sqlite.Sqlite__Database import Sqlite__Database
+from osbot_utils.utils.Status import status_ok, status_error, status_exception
+
+
+class Sqlite__Cursor(Kwargs_To_Self):
+    database : Sqlite__Database
+
+    @cache_on_self
+    def cursor(self):
+        return self.connection().cursor()
+
+    def commit(self):
+        self.connection().commit()
+        return self
+
+    def connection(self):
+        return self.database.connection()
+
+    def execute(self, sql_query, *params):
+        try:
+            self.cursor().execute(sql_query, *params)
+            return status_ok()
+        except Exception as error:
+            return status_exception(error=f'{error}')
+
+    def execute_and_commit(self, sql_query, *params):                   # todo: refactor this with the execute method
+        try:
+            self.cursor().execute(sql_query, *params)
+            self.connection().commit()
+            return status_ok()
+        except Exception as error:
+            return status_exception(error=f'{error}')
+
+    def execute__fetch_all(self,sql_query, *params):
+        self.execute(sql_query,*params)
+        return self.cursor().fetchall()
+
+    def execute__fetch_one(self,sql_query, *params):
+        self.execute(sql_query, *params)
+        return self.cursor().fetchone()
+
+    def fetch_all(self):
+        return self.cursor().fetchall()
+
+    def fetch_one(self):
+        return self.cursor().fetchone()
+
+    def table_create(self, table_name, fields):
+        if table_name and fields:
+            sql_query = f"CREATE TABLE {table_name} ({', '.join(fields)})"
+            return self.execute(sql_query=sql_query)
+        return status_error(message='table_name, fields cannot be empty')
+
+    def table_delete(self, table_name):
+        sql_query = f"DROP TABLE IF EXISTS {table_name};"
+        return  self.execute(sql_query=sql_query)
+
+    def table_exists(self, table_name):
+        self.execute("SELECT name FROM sqlite_master WHERE type='table' AND name=?", (table_name,))
+        return self.cursor().fetchone() is not None
+
+    def table_schema(self, table_name):
+        sql_query = f"PRAGMA table_info({table_name});"
+        self.execute(sql_query)
+        columns   = self.cursor().fetchall()
+        return columns
+
+    def table__sqlite_master(self):                            # todo: refactor into separate class
+        sql_query = "SELECT * FROM sqlite_master"
+        self.execute(sql_query)
+        return self.cursor().fetchall()
+
+    def tables(self):
+        sql_query = "SELECT * FROM sqlite_master WHERE type='table';"                   # Query to select all table names from the sqlite_master table
+        self.execute(sql_query)
+        return self.cursor().fetchall()
+
+    def tables_names(self):
+        cell_name = 'name'
+        sql_query = f"SELECT {cell_name} FROM sqlite_master WHERE type='table';"                   # Query to select all table names from the sqlite_master table
+        self.execute(sql_query)
+        all_rows   = self.cursor().fetchall()
+        all_values = [cell.get(cell_name) for cell in all_rows]
+        return all_values

osbot_utils/helpers/sqlite/Sqlite__Database.py

@@ -0,0 +1,137 @@
+import sqlite3
+
+from osbot_utils.base_classes.Kwargs_To_Self import Kwargs_To_Self
+from osbot_utils.decorators.methods.cache import cache
+from osbot_utils.decorators.methods.cache_on_self import cache_on_self
+
+from osbot_utils.utils.Files import current_temp_folder, path_combine, folder_create, file_exists, file_delete
+from osbot_utils.utils.Misc import  random_filename
+
+SQLITE_DATABASE_PATH__IN_MEMORY = ':memory:'
+FOLDER_NAME_TEMP_DATABASES      = '_temp_sqlite_databases'
+TEMP_DATABASE__FILE_NAME_PREFIX = 'random_sqlite_db__'
+TEMP_DATABASE__FILE_EXTENSION   = '.sqlite'
+
+class Sqlite__Database(Kwargs_To_Self):
+    db_path         : str  = None
+    closed          : bool = False
+    connected       : bool = False
+    deleted         : bool = False
+    in_memory       : bool = True                       # default to an in-memory database
+    auto_schema_row : bool = False                      # option to map the table's schema_row when creating an table object
+
+    def __init__(self, **kwargs):
+        super().__init__(**kwargs)
+        if self.db_path:                        # if self.db_path is set via the ctor (then it means that this is not in memory)
+            self.in_memory = False              # todo: see if this is not better done with a direct method for a getter/setter
+
+    def close(self):
+        if self.closed is False:
+            self.connection().close()
+            self.closed    = True
+            self.connected = False
+            return True
+        return False
+
+    # def config(self, key):
+    #     return self.table_config().data().get(key)
+
+    @cache_on_self
+    def connect(self):
+        connection_string      = self.connection_string()
+        connection             = sqlite3.connect(connection_string)
+        connection.row_factory = self.dict_factory                      # this returns a dict as the row value of every query
+        self.connected         = True
+        return connection
+
+    def connection(self):
+        return self.connect()
+
+    def connection_string(self):
+        if self.in_memory:
+            return SQLITE_DATABASE_PATH__IN_MEMORY
+        if not self.db_path:
+            self.db_path = self.path_temp_database()
+        return self.db_path
+
+    @cache_on_self
+    def cursor(self):
+        from osbot_utils.helpers.sqlite.Sqlite__Cursor import Sqlite__Cursor
+        return Sqlite__Cursor(database=self)
+
+    def delete(self):
+        if self.in_memory:          # can't delete an in-memory database
+            return False
+        if self.deleted:
+            return False
+        self.close()
+        if file_delete(self.db_path):
+            self.deleted = True
+            return True
+        return False
+
+    def dict_factory(self, cursor, row):                        # from https://docs.python.org/3/library/sqlite3.html#how-to-create-and-use-row-factories
+        fields = [column[0] for column in cursor.description]
+        return {key: value for key, value in zip(fields, row)}
+
+    def exists(self):
+        if self.in_memory:
+            return True
+        return file_exists(self.db_path)
+
+    def path_temp_database(self, file_name=None):
+        if file_name is None:
+            file_name = TEMP_DATABASE__FILE_NAME_PREFIX + random_filename(extension=TEMP_DATABASE__FILE_EXTENSION)
+        return path_combine(self.path_temp_databases(), file_name)
+
+    def path_temp_databases(self):
+        path_temp_databases  = path_combine(current_temp_folder(), FOLDER_NAME_TEMP_DATABASES)      # use current temp folder has the parent folder
+        folder_create(path_temp_databases)                                                          # make sure it exists
+        return path_temp_databases
+
+    def save_to(self, path):
+        connection = self.connection()
+        file_conn  = sqlite3.connect(path)
+        connection.backup(file_conn)
+        file_conn.close()
+        return path
+
+
+    def table(self, table_name):
+        from osbot_utils.helpers.sqlite.Sqlite__Table import Sqlite__Table              # need to import here due to circular imports
+        table = Sqlite__Table(database=self, table_name=table_name)
+        if self.auto_schema_row:
+            table.row_schema__set_from_field_types()                            # todo: see if we shouldn't just propagate the auto_schema_row to the Sqlite__Table and do that on the ctor
+        return table
+
+    # def table_config(self):
+    #     from osbot_utils.helpers.sqlite.tables.Sqlite__Table__Config import Sqlite__Table__Config
+    #     table_config = Sqlite__Table__Config(database=self)
+    #     table_config.setup()
+    #     return table_config
+
+    def table__sqlite_master(self):
+        return self.table('sqlite_master')
+
+    def tables(self):
+        tables = []
+        for table_data in self.tables_raw():
+            table_name = table_data.get('name')
+            table      = self.table(table_name)
+            tables.append(table)
+        return tables
+
+    def tables_raw(self):
+        return self.cursor().tables()
+
+    def tables_names(self, include_sqlite_master=False):
+        table_names = self.table__sqlite_master().select_field_values('name')
+        if include_sqlite_master:
+            table_names.append('sqlite_master')
+        return table_names
+
+
+
+
+
+

osbot_utils/helpers/sqlite/Sqlite__Field.py

@@ -0,0 +1,70 @@
+import inspect
+import typing
+from decimal import Decimal
+from enum import auto, Enum
+from typing import Optional, Union
+
+from osbot_utils.base_classes.Kwargs_To_Self import Kwargs_To_Self
+from osbot_utils.helpers.sqlite.models.Sqlite__Field__Type import Sqlite__Field__Type
+
+
+class Sqlite__Field(Kwargs_To_Self):
+    cid              : int
+    name             : str
+    type             : Sqlite__Field__Type
+    notnull          : bool
+    dflt_value       : Optional[Union[int, str, float, bytes]]
+    pk               : bool
+    autoincrement    : bool
+    unique           : bool
+    is_foreign_key   : bool                                                 # Indicates if the field is a foreign key
+    references_table : Optional[str]                                        # The table the foreign key references
+    references_column: Optional[str]                                        # The column in the referenced table
+    on_delete_action : Optional[str]                                        # Action on delete (e.g., CASCADE, SET NULL)
+    precision        : Optional[int]                                        # Precision for decimal types
+    scale            : Optional[int]                                        # Scale for decimal types
+    check_constraint : Optional[str]                                        # Check constraint expression
+
+    def text_for_create_table(self):
+        parts = [self.name]  # Start with name
+
+        if self.type == Sqlite__Field__Type.DECIMAL and self.precision is not None and self.scale is not None:
+            parts.append(f"DECIMAL({self.precision}, {self.scale})")
+        else:
+            parts.append(self.type.name)
+        if self.pk:
+            parts.append("PRIMARY KEY")
+            if self.autoincrement:
+                parts.append("AUTOINCREMENT")
+        if self.unique:
+            parts.append("UNIQUE")
+        if self.notnull:
+            parts.append("NOT NULL")
+
+
+        if self.check_constraint:
+            parts.append(f"CHECK ({self.check_constraint})")
+
+        if self.is_foreign_key and self.references_table and self.references_column:
+            fk_constraint = f"FOREIGN KEY ({self.name}) REFERENCES {self.references_table} ({self.references_column})"
+            if self.on_delete_action:
+                fk_constraint += f" ON DELETE {self.on_delete_action}"
+            return fk_constraint
+
+        return " ".join(parts)
+
+    @classmethod
+    def fix_from_json_data(cls, json_data):
+        if type(json_data) is dict:
+            type_type = json_data.get('type')
+            mapped_type = Sqlite__Field__Type.type_map().get(type_type)
+            if mapped_type:
+                json_data['type'] = mapped_type
+                return mapped_type
+
+
+    @classmethod
+    def from_json(cls, json_data):
+        cls.fix_from_json_data(json_data)
+        return super(Sqlite__Field, cls).from_json(json_data)
+

osbot_utils/helpers/sqlite/Sqlite__Globals.py

@@ -0,0 +1,5 @@
+from osbot_utils.base_classes.Kwargs_To_Self import Kwargs_To_Self
+
+DEFAULT_FIELD_NAME__ID             = 'id'
+ROW_BASE_CLASS                     = Kwargs_To_Self
+SQL_TABLE__MODULE_NAME__ROW_SCHEMA = 'Dynamic_Class__Sqlite__Table'