database-mongodb-local 0.0.1__py3-none-any.whl

database_mongodb_local/src/connector.py

@@ -0,0 +1,51 @@
+import os
+from functools import lru_cache
+
+from dotenv import load_dotenv
+from pymongo import MongoClient
+from pymongo.database import Database
+
+load_dotenv()
+
+DEFAULT_HOST = "localhost"
+DEFAULT_PORT = 27017
+
+
+def _is_mock() -> bool:
+    return os.getenv("MONGODB_MOCK", "false").lower() in ("1", "true", "yes")
+
+
+@lru_cache(maxsize=None)
+def _get_real_client() -> MongoClient:
+    host = os.getenv("MONGODB_HOST", DEFAULT_HOST)
+    port = int(os.getenv("MONGODB_PORT", DEFAULT_PORT))
+    username = os.getenv("MONGODB_USERNAME")
+    password = os.getenv("MONGODB_PASSWORD")
+
+    if username and password:
+        return MongoClient(host=host, port=port, username=username, password=password)
+    return MongoClient(host=host, port=port)
+
+
+class Connector:
+    """Single owner of MongoDB connection creation (information hiding).
+
+    Callers never build a client themselves — they ask Connector for a
+    database. When ``MONGODB_MOCK`` is set, a fresh in-memory mongomock
+    database is returned so tests run without a real MongoDB.
+    """
+
+    @staticmethod
+    def get_database(database_name: str) -> Database:
+        if _is_mock():
+            import mongomock
+            return mongomock.MongoClient()[database_name]
+        return _get_real_client()[database_name]
+
+    @staticmethod
+    def is_mongo_available() -> bool:
+        try:
+            _get_real_client().admin.command("ping")
+            return True
+        except Exception:
+            return False

database_mongodb_local/src/constants_src.py

@@ -0,0 +1,24 @@
+from logger_local.LoggerComponentEnum import LoggerComponentEnum
+
+DEVELOPER_EMAIL_ADDRESS = "dor3382@gmail.com"
+
+CRUD_MONGODB_CODE_LOGGER_OBJECT = {
+    "component_id": 1,
+    "component_name": "database-mongodb-local/GenericCrudMongodb",
+    "component_category": LoggerComponentEnum.ComponentCategory.Code.value,
+    "developer_email_address": DEVELOPER_EMAIL_ADDRESS,
+}
+
+CRUD_ML_CODE_LOGGER_OBJECT = {
+    "component_id": 2,
+    "component_name": "database-mongodb-local/GenericCrudMlMongoDB",
+    "component_category": LoggerComponentEnum.ComponentCategory.Code.value,
+    "developer_email_address": DEVELOPER_EMAIL_ADDRESS,
+}
+
+MAPPING_CODE_LOGGER_OBJECT = {
+    "component_id": 3,
+    "component_name": "database-mongodb-local/GenericMappingMongodb",
+    "component_category": LoggerComponentEnum.ComponentCategory.Code.value,
+    "developer_email_address": DEVELOPER_EMAIL_ADDRESS,
+}

database_mongodb_local/src/decorators.py

@@ -0,0 +1,27 @@
+import functools
+
+from pymongo.errors import (
+    ConnectionFailure,
+    DuplicateKeyError,
+    PyMongoError,
+    ServerSelectionTimeoutError,
+)
+
+from .exceptions import DatabaseConnectionError, DatabaseDuplicateError, DatabaseOperationError
+
+
+def handle_db_errors(func):
+    @functools.wraps(func)
+    def wrapper(*args, **kwargs):
+        try:
+            return func(*args, **kwargs)
+        except DuplicateKeyError as e:
+            raise DatabaseDuplicateError(
+                f"Duplicate key error in {func.__name__}: {e}") from e
+        except (ConnectionFailure, ServerSelectionTimeoutError) as e:
+            raise DatabaseConnectionError(
+                f"Connection error in {func.__name__}: {e}") from e
+        except PyMongoError as e:
+            raise DatabaseOperationError(
+                f"Database error in {func.__name__}: {e}") from e
+    return wrapper

database_mongodb_local/src/exceptions.py

@@ -0,0 +1,14 @@
+class DatabaseError(RuntimeError):
+    pass
+
+
+class DatabaseDuplicateError(DatabaseError):
+    pass
+
+
+class DatabaseConnectionError(DatabaseError):
+    pass
+
+
+class DatabaseOperationError(DatabaseError):
+    pass

database_mongodb_local/src/generic_crud.py

@@ -0,0 +1,341 @@
+from datetime import datetime, timezone
+from typing import Any, Optional
+
+from bson import ObjectId
+from pymongo.collection import Collection
+from pymongo.errors import DuplicateKeyError
+
+from logger_local.MetaLogger import ABCMetaLogger
+
+from database_infrastructure_local.generic_crud_abstract import GenericCrudAbstract
+
+from .connector import Connector
+from .constants_src import CRUD_MONGODB_CODE_LOGGER_OBJECT
+from .decorators import handle_db_errors
+
+
+class GenericCrudMongodb(GenericCrudAbstract, metaclass=ABCMetaLogger,
+                         object=CRUD_MONGODB_CODE_LOGGER_OBJECT):
+    """MongoDB implementation of the shared GenericCrud interface.
+
+    To keep the interface consistent across MySQL, PostgreSQL and MongoDB,
+    this class uses the same method names and parameters as the MySQL DAL:
+    ``schema_name`` maps to a MongoDB database and ``table_name`` maps to a
+    MongoDB collection.
+    """
+
+    def __init__(self, *,
+                 default_schema_name: str,
+                 default_table_name: str,
+                 is_test_data: bool = False) -> None:
+        self.default_schema_name = default_schema_name
+        self.default_table_name = default_table_name
+        self.is_test_data = is_test_data
+        self._db = Connector.get_database(default_schema_name)
+
+    def _collection(self, table_name: str = None) -> Collection:
+        return self._db[table_name or self.default_table_name]
+
+    def _live_filter(self, extra: dict = None) -> dict:
+        """Returns a filter that excludes soft-deleted documents.
+
+        All select/update/delete operations automatically apply this filter —
+        documents with a non-null end_timestamp are invisible to callers.
+        Use undelete_by_id to restore a soft-deleted document.
+        """
+        f = dict(extra or {})
+        f["end_timestamp"] = None
+        return f
+
+    # ------------------------------------------------------------------ insert
+
+    @handle_db_errors
+    def insert(self, *, schema_name: str = None, table_name: str = None,
+               data_dict: dict = None,
+               ignore_duplicate: bool = False,
+               commit_changes: bool = True) -> Optional[ObjectId]:
+        table_name = table_name or self.default_table_name
+        data_dict = dict(data_dict or {})
+        data_dict.setdefault("end_timestamp", None)
+        data_dict.setdefault("is_test_data", self.is_test_data)
+        data_dict["created_timestamp"] = datetime.now(timezone.utc)
+        data_dict["updated_timestamp"] = datetime.now(timezone.utc)
+        try:
+            result = self._collection(table_name).insert_one(data_dict)
+            return result.inserted_id
+        except DuplicateKeyError:
+            if ignore_duplicate:
+                return None
+            raise
+
+    @handle_db_errors
+    def insert_if_not_exists_by_field(self, *, table_name: str = None,
+                                      field: str,
+                                      data_dict: dict) -> Optional[ObjectId]:
+        table_name = table_name or self.default_table_name
+        existing = self._collection(table_name).find_one(
+            self._live_filter({field: data_dict[field]}), {"_id": 1})
+        if existing:
+            return None
+        return self.insert(table_name=table_name, data_dict=data_dict)
+
+    @handle_db_errors
+    def insert_if_not_exists(self, *, table_name: str = None,
+                             data_dict: dict = None,
+                             data_dict_compare: dict = None) -> Optional[ObjectId]:
+        table_name = table_name or self.default_table_name
+        data_dict_compare = data_dict_compare or data_dict
+        existing = self._collection(table_name).find_one(
+            self._live_filter(data_dict_compare), {"_id": 1})
+        if existing:
+            return existing["_id"]
+        return self.insert(table_name=table_name, data_dict=data_dict)
+
+    @handle_db_errors
+    def insert_many(self, *, table_name: str = None,
+                    data_dicts: list[dict]) -> int:
+        if not data_dicts:
+            return 0
+        table_name = table_name or self.default_table_name
+        now = datetime.now(timezone.utc)
+        docs = [dict(d) for d in data_dicts]
+        for doc in docs:
+            doc.setdefault("end_timestamp", None)
+            doc.setdefault("is_test_data", self.is_test_data)
+            doc.setdefault("created_timestamp", now)
+            doc.setdefault("updated_timestamp", now)
+        result = self._collection(table_name).insert_many(docs)
+        return len(result.inserted_ids)
+
+    # ------------------------------------------------------------------ upsert
+
+    @handle_db_errors
+    def upsert(self, *, table_name: str = None,
+               data_dict: dict = None,
+               data_dict_compare: dict = None) -> Optional[ObjectId]:
+        table_name = table_name or self.default_table_name
+        data_dict = dict(data_dict or {})
+        data_dict["updated_timestamp"] = datetime.now(timezone.utc)
+
+        if not data_dict_compare:
+            return self.insert(table_name=table_name, data_dict=data_dict)
+
+        existing = self._collection(table_name).find_one(
+            self._live_filter(data_dict_compare), {"_id": 1})
+        if existing:
+            self._collection(table_name).update_one(
+                {"_id": existing["_id"]}, {"$set": data_dict})
+            return existing["_id"]
+        return self.insert(table_name=table_name, data_dict=data_dict)
+
+    # ------------------------------------------------------------------ update
+
+    @handle_db_errors
+    def update_by_id(self, *, table_name: str = None,
+                     document_id: ObjectId,
+                     data_dict: dict) -> int:
+        return self.update_by_where(
+            table_name=table_name,
+            where={"_id": document_id},
+            data_dict=data_dict)
+
+    @handle_db_errors
+    def update_by_column_and_value(self, *, table_name: str = None,
+                                   column_name: str,
+                                   column_value: Any,
+                                   data_dict: dict) -> int:
+        return self.update_by_where(
+            table_name=table_name,
+            where={column_name: column_value},
+            data_dict=data_dict)
+
+    @handle_db_errors
+    def update_by_where(self, *, table_name: str = None,
+                        where: dict,
+                        data_dict: dict) -> int:
+        """``where`` is a MongoDB filter dict (the MongoDB equivalent of a SQL WHERE clause)."""
+        table_name = table_name or self.default_table_name
+        data_dict = dict(data_dict)
+        data_dict["updated_timestamp"] = datetime.now(timezone.utc)
+        result = self._collection(table_name).update_many(
+            self._live_filter(where), {"$set": data_dict})
+        return result.modified_count
+
+    # ------------------------------------------------------------------ delete
+
+    @handle_db_errors
+    def delete_by_id(self, *, table_name: str = None,
+                     document_id: ObjectId) -> int:
+        return self.delete_by_where(
+            table_name=table_name,
+            where={"_id": document_id})
+
+    @handle_db_errors
+    def delete_by_column_and_value(self, *, table_name: str = None,
+                                   column_name: str,
+                                   column_value: Any) -> int:
+        return self.delete_by_where(
+            table_name=table_name,
+            where={column_name: column_value})
+
+    @handle_db_errors
+    def delete_by_where(self, *, table_name: str = None,
+                        where: dict) -> int:
+        """``where`` is a MongoDB filter dict (the MongoDB equivalent of a SQL WHERE clause)."""
+        table_name = table_name or self.default_table_name
+        result = self._collection(table_name).update_many(
+            self._live_filter(where),
+            {"$set": {"end_timestamp": datetime.now(timezone.utc)}})
+        return result.modified_count
+
+    @handle_db_errors
+    def undelete_by_id(self, *, table_name: str = None,
+                       document_id: ObjectId) -> int:
+        table_name = table_name or self.default_table_name
+        result = self._collection(table_name).update_one(
+            {"_id": document_id}, {"$set": {"end_timestamp": None}})
+        return result.modified_count
+
+    # ------------------------------------------------------------------ select
+
+    @handle_db_errors
+    def select_one_dict_by_id(self, *,
+                              table_name: str = None,
+                              document_id: ObjectId) -> Optional[dict]:
+        return self.select_one_dict_by_where(
+            table_name=table_name,
+            where={"_id": document_id})
+
+    @handle_db_errors
+    def select_one_dict_by_column_and_value(self, *,
+                                            table_name: str = None,
+                                            column_name: str,
+                                            column_value: Any,
+                                            fields: dict = None) -> Optional[dict]:
+        return self.select_one_dict_by_where(
+            table_name=table_name,
+            where={column_name: column_value},
+            fields=fields)
+
+    @handle_db_errors
+    def select_one_dict_by_where(self, *,
+                                 table_name: str = None,
+                                 where: dict = None,
+                                 fields: dict = None) -> Optional[dict]:
+        """``where`` is a MongoDB filter dict (the MongoDB equivalent of a SQL WHERE clause)."""
+        table_name = table_name or self.default_table_name
+        return self._collection(table_name).find_one(
+            self._live_filter(where or {}), fields)
+
+    @handle_db_errors
+    def select_multi_dict_by_column_and_value(self, *,
+                                              table_name: str = None,
+                                              column_name: str,
+                                              column_value: Any,
+                                              fields: dict = None,
+                                              limit: int = 0,
+                                              order_by: list = None) -> list[dict]:
+        return self.select_multi_dict_by_where(
+            table_name=table_name,
+            where={column_name: column_value},
+            fields=fields, limit=limit, order_by=order_by)
+
+    @handle_db_errors
+    def select_multi_dict_by_where(self, *,
+                                   table_name: str = None,
+                                   where: dict = None,
+                                   fields: dict = None,
+                                   limit: int = 0,
+                                   order_by: list = None) -> list[dict]:
+        """``where`` is a MongoDB filter dict (the MongoDB equivalent of a SQL WHERE clause)."""
+        table_name = table_name or self.default_table_name
+        cursor = self._collection(table_name).find(
+            self._live_filter(where or {}), fields)
+        if order_by:
+            cursor = cursor.sort(order_by)
+        if limit:
+            cursor = cursor.limit(limit)
+        return list(cursor)
+
+    @handle_db_errors
+    def select_one_value_by_column_and_value(self, *,
+                                             table_name: str = None,
+                                             column_name: str,
+                                             column_value: Any,
+                                             field: str) -> Any:
+        return self.select_one_value_by_where(
+            table_name=table_name,
+            where={column_name: column_value},
+            field=field)
+
+    @handle_db_errors
+    def select_one_value_by_where(self, *,
+                                  table_name: str = None,
+                                  where: dict = None,
+                                  field: str) -> Any:
+        doc = self.select_one_dict_by_where(
+            table_name=table_name,
+            where=where,
+            fields={field: 1})
+        return doc.get(field) if doc else None
+
+    @handle_db_errors
+    def select_multi_value_by_column_and_value(self, *,
+                                               table_name: str = None,
+                                               column_name: str,
+                                               column_value: Any,
+                                               field: str,
+                                               limit: int = 0) -> list:
+        return self.select_multi_value_by_where(
+            table_name=table_name,
+            where={column_name: column_value},
+            field=field, limit=limit)
+
+    @handle_db_errors
+    def select_multi_value_by_where(self, *,
+                                    table_name: str = None,
+                                    where: dict = None,
+                                    field: str,
+                                    limit: int = 0) -> list:
+        docs = self.select_multi_dict_by_where(
+            table_name=table_name,
+            where=where,
+            fields={field: 1},
+            limit=limit)
+        return [doc.get(field) for doc in docs if field in doc]
+
+    @handle_db_errors
+    def get_num_of_rows(self, *, table_name: str = None,
+                        where: dict = None) -> int:
+        table_name = table_name or self.default_table_name
+        return self._collection(table_name).count_documents(
+            self._live_filter(where or {}))
+
+    @handle_db_errors
+    def foreach(self, *,
+                function: callable,
+                table_name: str = None,
+                where: dict = None,
+                batch_size: int = 100) -> None:
+        table_name = table_name or self.default_table_name
+        skip = 0
+        while True:
+            batch = list(self._collection(table_name).find(
+                self._live_filter(where or {}),
+                skip=skip,
+                limit=batch_size))
+            if not batch:
+                break
+            for doc in batch:
+                function(doc)
+            skip += batch_size
+
+    @handle_db_errors
+    def merge_entities(self, *,
+                       entity_id1: ObjectId,
+                       entity_id2: ObjectId,
+                       table_name: str = None) -> None:
+        self.delete_by_id(document_id=entity_id1, table_name=table_name)
+
+    def close(self) -> None:
+        pass