sweetrpg-db 0.0.1__tar.gz

sweetrpg-db-0.0.1/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 SweetRPG
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

sweetrpg-db-0.0.1/PKG-INFO

@@ -0,0 +1,19 @@
+Metadata-Version: 2.1
+Name: sweetrpg-db
+Version: 0.0.1
+Home-page: https://sweetrpg.com
+Author: Paul Schifferer
+Author-email: dm@sweetrpg.com
+License: MIT
+Project-URL: Documentation, https://sweetrpg.github.io/db
+Classifier: Development Status :: 4 - Beta
+Classifier: Environment :: Web Environment
+Classifier: Framework :: Flask
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python
+Classifier: Topic :: Software Development :: Libraries :: Application Frameworks
+License-File: LICENSE
+
+# db.py

sweetrpg-db-0.0.1/README.md

@@ -0,0 +1 @@
+# db.py

sweetrpg-db-0.0.1/setup.cfg

@@ -0,0 +1,60 @@
+[bdist_wheel]
+universal = 1
+
+[metadata]
+name = sweetrpg-db
+version = attr: sweetrpg_db.__version__
+url = https://sweetrpg.com
+project_urls = 
+	Documentation = https://sweetrpg.github.io/db
+license = MIT
+author = Paul Schifferer
+author_email = dm@sweetrpg.com
+long_description = file: README.md
+classifiers = 
+	Development Status :: 4 - Beta
+	Environment :: Web Environment
+	Framework :: Flask
+	Intended Audience :: Developers
+	License :: OSI Approved :: MIT License
+	Operating System :: OS Independent
+	Programming Language :: Python
+	Topic :: Software Development :: Libraries :: Application Frameworks
+
+[options]
+packages = find:
+package_dir = = src
+include_package_data = true
+python_required = >=3.12
+
+[options.packages.find]
+where = src
+
+[options.entry_points]
+console_scripts = 
+	sweetrpg-db = sweetrpg_db.cli:main
+
+[tool:pytest]
+testpaths = tests
+filterwarnings = 
+	error
+
+[coverage:run]
+branch = True
+source = 
+	sweetrpg_db
+	tests
+
+[coverage:paths]
+source = 
+	src
+	*/site-packages
+
+[semantic_release]
+version_variable = src/sweetrpg_db/__init__.py:__version__
+branch = develop
+
+[egg_info]
+tag_build = 
+tag_date = 0
+

sweetrpg-db-0.0.1/setup.py

@@ -0,0 +1,15 @@
+from setuptools import setup
+
+# Metadata goes in setup.cfg. These are here for GitHub's dependency graph.
+setup(
+    name="sweetrpg-db",
+    install_requires=[
+        "dnspython~=2.0",
+        "marshmallow~=3.0",
+        "mongoengine~=0.27",
+        "PyMongo[srv]~=3.0",
+        "sweetrpg-model-core",
+        "sweetrpg-common",
+    ],
+    extras_require={},
+)

sweetrpg-db-0.0.1/src/sweetrpg_db/__init__.py

@@ -0,0 +1,15 @@
+# -*- coding: utf-8 -*-
+__author__ = "Paul Schifferer <dm@sweetrpg.com>"
+"""
+Metadata.
+"""
+
+__title__ = "sweetrpg-db"
+__description__ = "SweetRPG database modules"
+__url__ = "https://github.com/sweetrpg/db"
+__version__ = "0.0.1"
+__build__ = 0x000007
+__author_email__ = "dm@sweetrpg.com"
+__license__ = "MIT"
+__copyright__ = "Copyright 2024 SweetRPG"
+__cake__ = "\u2728 \U0001f370 \u2728"

sweetrpg-db-0.0.1/src/sweetrpg_db/exceptions.py

@@ -0,0 +1,11 @@
+# -*- coding: utf-8 -*-
+__author__ = "Paul Schifferer <dm@sweetrpg.com>"
+"""
+Common exceptions.
+"""
+
+
+class ObjectNotFound(Exception):
+    """An exception for objects not found."""
+
+    pass

sweetrpg-db-0.0.1/src/sweetrpg_db/mongodb/__init__.py

@@ -0,0 +1,5 @@
+# -*- coding: utf-8 -*-
+__author__ = "Paul Schifferer <dm@sweetrpg.com>"
+"""
+Modules related to accessing MongoDB.
+"""

sweetrpg-db-0.0.1/src/sweetrpg_db/mongodb/options.py

@@ -0,0 +1,104 @@
+# -*- coding: utf-8 -*-
+__author__ = "Paul Schifferer <dm@sweetrpg.com>"
+"""
+Query options for accessing MongoDB.
+"""
+
+
+class QueryOptions(object):
+    """An object to store query options for a PyMongo find*() call."""
+
+    # https://flask-rest-jsonapi.readthedocs.io/en/latest/filtering.html
+    _filter_operators = {
+        "eq": "$eq",
+        "gt": "$gt",
+        "ge": "$gte",
+        "in_": "$in",
+        "lt": "$lt",
+        "le": "$lte",
+        "ne": "$ne",
+        "notin_": "$nin",
+        # '': '$and',
+        "isnot": "$not",
+        # '': '$nor',
+        # '': '$or',
+        "is_": "$exists",
+        # 'any': 'TODO',
+        # 'between': 'TODO',
+        # 'endswith': 'TODO',
+        # 'has': 'TODO',
+        # 'ilike': 'TODO',
+        # 'like': 'TODO',
+        # 'match': 'TODO',
+        # 'notilike': 'TODO',
+        # 'notlike': 'TODO',
+        # 'startswith': 'TODO',
+    }
+    _sort_values = {
+        "asc": 1,
+        "dsc": -1,
+    }
+
+    def __init__(self, filters: dict = {}, projection: list = [], skip: int = 0, limit: int = 0, sort: list = []):
+        """Initialize the QueryOptions object.
+        :param dict filters: A dictionary of filters to apply to the query.
+        :param list projection: A list of attribute names to include in the returned result. If `None`, all attributes are returned.
+        :param int skip: An offset to use for pagination.
+        :param int limit: The maximum number of results to return.
+        :param list sort: A list of key-value pairs specifying the attributes to sort on.
+        """
+        self.filters = filters
+        self.projection = projection
+        self.skip = skip
+        self.limit = limit
+        self.sort = sort
+
+    def __repr__(self):
+        return f"<QueryOptions(filters={self.filters}, projection={self.projection}, skip={self.skip}, limit={self.limit}, sort={self.sort})>"
+
+    def _process_filter(self, filter_info: dict):
+        name = filter_info["name"]
+        value = filter_info["val"]
+        op = self._filter_operators.get(filter_info["op"], "$eq")
+        return {name: {op: value}}
+
+    def set_filters(self, filters: dict = None, from_querystring: list = None):
+        """Sets filters for the query.
+
+        :param dict filters: A dictionary of filters to set.
+        :param list from_querystring: Filters to set in querystring format.
+        """
+        if filters is not None:
+            self.filters = filters
+        elif from_querystring is not None:
+            filters = {}
+            for f in from_querystring:
+                filters.update(self._process_filter(f))
+            self.filters = filters
+
+    def set_projection(self, projection: list = None, from_querystring: list = None):
+        """Sets projections for the query.
+
+        :param list projection: A list of field names to include in the query results.
+        :param list from_querystring: Projections to set in querystring format.
+        """
+        if projection is not None:
+            self.projection = projection
+        elif from_querystring is not None:
+            self.projection = from_querystring
+
+    def _process_sort(self, sort_item: dict):
+        name = sort_item["field"]
+        direction = self._sort_values.get(sort_item["order"], 1)
+        return name, direction
+
+    def set_sort(self, sort: list = None, from_querystring: list = None):
+        """Sets sorting for the query results.
+
+        :param list sort: A list of dictionaries containing field name and ordering.
+        :param list from_querystring: Sorts to set in querystring format.
+        """
+        if sort is not None:
+            self.sort = sort
+        elif from_querystring is not None:
+            self.sort = list(map(self._process_sort, from_querystring))

sweetrpg-db-0.0.1/src/sweetrpg_db/mongodb/repo.py

@@ -0,0 +1,238 @@
+# -*- coding: utf-8 -*-
+__author__ = "Paul Schifferer <dm@sweetrpg.com>"
+"""
+MongoDB repository module.
+"""
+
+from ..exceptions import ObjectNotFound
+from bson.objectid import ObjectId
+from bson.timestamp import Timestamp
+import datetime
+from .options import QueryOptions
+from pymongo.write_concern import WriteConcern
+import logging
+from mongoengine.queryset import QuerySet
+from mongoengine import Document
+
+
+class MongoDataRepository(object):
+    """A repository class for interacting with a MongoDB database."""
+
+    def __init__(self, **kwargs):
+        """Create a MongoDB repository instance.
+
+        :param kwargs: Keyword arguments for setting up the repository connection.
+        :key model: The class of the model for this connection.
+        :key document: The class of the document for this connection.
+        :key db: A :class:`PyMongo` object used for connecting to the database.
+        """
+        self.model_class = kwargs["model"]
+        self.document_class = kwargs["document"]
+        # self.db = kwargs.get("db")
+        # print(dir(self.document_class))
+        self.collection = kwargs["collection"]  # self.document_class.meta["collection"]
+
+    def __repr__(self):
+        return f"<MongoDataRepository(model_class={self.model_class}, document_class={self.document_class}, collection={self.collection})>"
+
+    def _handle_value(self, value):
+        """Convert a value to a string.
+
+        :param any value: The value to convert. Supports :class:`bson.objectid.ObjectId`,
+            :class:`datetime.datetime`, :class:`bson.timestamp.Timestamp`, and lists of
+            any of those types.
+        :return str: A string of the specified value.
+        """
+        if isinstance(value, ObjectId):
+            logging.debug("converting ObjectId('%s')...", value)
+            return str(value)
+        elif isinstance(value, datetime.datetime):
+            logging.debug("converting datetime value '%s'...", value)
+            d = value.replace(tzinfo=datetime.timezone.utc)
+            return d.isoformat(timespec="milliseconds")
+        elif isinstance(value, Timestamp):
+            logging.debug("converting Timestamp '%s'...", value)
+            return value.as_datetime()
+        elif isinstance(value, list):
+            logging.debug("converting list '%s'...", value)
+            return list(map(self._handle_value, value))
+
+        logging.debug("returning unprocessed value '%s'...", value)
+        return value
+
+    def _modify_record(self, record: dict) -> dict:
+        """Modify a record by converting any values to strings, and renaming the internal '_id'
+            field to 'id'.
+
+        :param dict record: The record to modify.
+        :return dict: The modified record.
+        """
+        modified_record = {}
+        for k, v in record.items():
+            logging.debug("k: %s, v: %s", k, v)
+            if k == "_id":
+                k = "id"
+            modified_value = self._handle_value(v)
+            modified_record[k] = modified_value
+            logging.debug("k: %s, v (modified): %s", k, modified_value)
+
+        return modified_record
+
+    def _adjust_sort(self, sort: tuple) -> str:
+        if sort[1] < 0:
+            return f"-{sort[0]}"
+        return f"+{sort[0]}"
+
+    def create(self, data: dict) -> Document:
+        """Inserts a new object in the database with the data provided.
+
+        :param dict data: The data for the object
+        :return Document: The inserted document.
+        """
+        logging.debug("data: %s", data)
+
+        # collection = self.db[self.collection]
+        logging.info("Creating new %s record with data %s...", self.document_class.__name__, data)
+        doc = self.document_class(**data)
+        logging.debug("doc: %s", doc)
+        # result = collection.with_options(write_concern=WriteConcern(w=3, j=True)).insert_one(data)
+        doc.validate()
+        doc.save()
+        logging.debug("saved doc: %s", doc)
+
+        return doc
+
+    def get(self, record_id: str, deleted: bool = False) -> Document:
+        """Fetch a single record from the database.
+
+        :param str record_id: The identifier for the record to fetch. This value is compared against the attribute specified in `id_attr`.
+        :param bool deleted: Include "deleted" objects in the query
+        :return Document: An instance of the object type from `model_class`.
+        """
+        logging.debug("record_id: %s", record_id)
+        id_value = record_id
+        if isinstance(id_value, str):
+            id_value = ObjectId(record_id)
+        logging.debug("id_value: %s", id_value)
+        query_filter = {"_id": id_value}
+        if not deleted:
+            query_filter.update({"deleted_at": {"$not": {"$type": "date"}}})
+        logging.debug("query_filter: %s", query_filter)
+
+        logging.info("Fetching %s record for ID %s...", self.document_class.__name__, id_value)
+        record = self.document_class.objects(__raw__=query_filter).first()  # QuerySet(self.document_class, self.collection)
+        # print(f"qs: {qs}")
+        # logging.debug("qs: %s", qs)
+        # record = None # qs.get(**query_filter)
+        logging.debug("record: %s", record)
+        # if not record:
+        #     raise ObjectNotFound(f"Record not found where for '{record_id}'")
+
+        return record
+
+    def query(self, options: QueryOptions, deleted: bool = False) -> list:
+        """Perform a query for objects in the database.
+
+        :param QueryOptions options: (Optional) Options specifying limits to the query's returned results
+        :return list: Returns a list of Document-subclass instances matching the query.
+        """
+        logging.debug("options: %s", options)
+        query_filter = options.filters or {}
+        if not deleted:
+            query_filter.update({"deleted_at": {"$not": {"$type": "date"}}})
+        logging.debug("query_filter: %s", query_filter)
+
+        logging.info("Searching for %s records matching filter %s...", self.document_class, query_filter)
+        records = (
+            self.document_class.objects(__raw__=query_filter)
+            .order_by(*list(map(self._adjust_sort, options.sort)))
+            .skip(options.skip)
+            .limit(options.limit)
+            .only(*options.projection)
+        )
+        # qs = QuerySet(self.document_class, self.collection)
+        # if options.skip > 0:
+        #     qs.skip(options.skip)
+        # if options.limit > 0:
+        #     qs.limit(options.limit)
+        # if len(options.projection) > 0:
+        #     qs.only(*options.projection)
+        # if len(options.sort) > 0:
+        #     qs.order_by(*options.sort)
+        # print(f"qs: {qs}")
+        # logging.debug("qs: %s", qs)
+        # query_set = self.document_class.objects.skip(options.skip).limit(options.limit).order_by(options.sort).only(*options.projection)
+        # records = list(qs.all())  # .all()
+        logging.debug("records: %s", records)
+
+        # modified_records = map(self._modify_record, records)
+        # logging.debug("modified_records: %s", modified_records)
+
+        return list(records)
+
+    def update(self, record_id: str, update: dict, deleted: bool = False) -> Document:
+        """Update the specified record.
+
+        :param str record_id: The ID of the record to update.
+        :param dict update: The data to update for the record.
+        :param bool deleted: Indicates whether the update operation should look for deleted records.
+        :return Document: The update version of the object.
+        """
+        id_value = record_id
+        if isinstance(id_value, str):
+            id_value = ObjectId(record_id)
+        # if self.id_attr == "_id":
+        #     logging.debug("ID attribute is '_id', converting to ObjectId")
+        #     id_value = ObjectId(record_id)
+        obj_filter = {"_id": id_value}
+        logging.debug("obj_filter: %s", obj_filter)
+
+        update_oper = {"$set": update}
+        logging.debug("update_oper: %s", update_oper)
+
+        logging.info("Marking %s record %s deleted...", self.model_class, id_value)
+        query_filter = {"_id": id_value}
+        if not deleted:
+            query_filter.update({"deleted_at": {"$not": {"$type": "date"}}})
+        logging.debug("query_filter: %s", query_filter)
+        # doc = self.document_class.objects.raw(query_filter).update(update_oper)
+        doc = self.get(record_id, deleted=deleted)
+        # if doc is None:
+        #     logging.info("No document found to update for record ID %s.", record_id)
+        #     return False
+        logging.debug("doc: %s", doc)
+        doc.update(**update)
+
+        return doc
+
+    def delete(self, record_id: str, actually: bool = False) -> bool:
+        """'Delete' the specified record. Deletion is accomplished by setting the `deleted_at` field to the current
+            timestamp, so that queries for the object will ignore it.
+
+        :param str record_id: The record ID of the object to delete. This can be a string or :class:`bson.objectid.ObjectId`.
+        :param bool actually: Actually delete the record instead of just marking it "deleted".
+        :return bool: A boolean indicating whether the record was able to be marked deleted.
+        :raises DoesNotExist:
+        """
+        id_value = record_id
+        if isinstance(id_value, str):
+            id_value = ObjectId(record_id)
+        doc = self.get(record_id)
+        # if doc is None:
+        #     logging.info("No document found to delete for record ID %s.", record_id)
+        #     return False
+
+        if actually:
+            logging.info("Deleting %s record %s...", self.model_class.__name__, id_value)
+            doc.delete()
+            return True
+        else:
+            logging.info("Marking %s record %s deleted...", self.model_class.__name__, id_value)
+            now = datetime.datetime.utcnow()
+            doc.deleted_at = now
+            updated_doc = doc.save()
+            logging.debug("updated_doc: %s", updated_doc)
+
+            return True
+
+        return False

sweetrpg-db-0.0.1/src/sweetrpg_db/schema/__init__.py

@@ -0,0 +1,5 @@
+# -*- coding: utf-8 -*-
+__author__ = "Paul Schifferer <dm@sweetrpg.com>"
+"""
+Schema modules.
+"""

sweetrpg-db-0.0.1/src/sweetrpg_db/utils.py

@@ -0,0 +1,5 @@
+# -*- coding: utf-8 -*-
+__author__ = "Paul Schifferer <dm@sweetrpg.com>"
+"""
+... nothing
+"""

sweetrpg-db-0.0.1/src/sweetrpg_db.egg-info/PKG-INFO

@@ -0,0 +1,19 @@
+Metadata-Version: 2.1
+Name: sweetrpg-db
+Version: 0.0.1
+Home-page: https://sweetrpg.com
+Author: Paul Schifferer
+Author-email: dm@sweetrpg.com
+License: MIT
+Project-URL: Documentation, https://sweetrpg.github.io/db
+Classifier: Development Status :: 4 - Beta
+Classifier: Environment :: Web Environment
+Classifier: Framework :: Flask
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python
+Classifier: Topic :: Software Development :: Libraries :: Application Frameworks
+License-File: LICENSE
+
+# db.py

sweetrpg-db-0.0.1/src/sweetrpg_db.egg-info/SOURCES.txt

@@ -0,0 +1,17 @@
+LICENSE
+README.md
+setup.cfg
+setup.py
+src/sweetrpg_db/__init__.py
+src/sweetrpg_db/exceptions.py
+src/sweetrpg_db/utils.py
+src/sweetrpg_db.egg-info/PKG-INFO
+src/sweetrpg_db.egg-info/SOURCES.txt
+src/sweetrpg_db.egg-info/dependency_links.txt
+src/sweetrpg_db.egg-info/entry_points.txt
+src/sweetrpg_db.egg-info/requires.txt
+src/sweetrpg_db.egg-info/top_level.txt
+src/sweetrpg_db/mongodb/__init__.py
+src/sweetrpg_db/mongodb/options.py
+src/sweetrpg_db/mongodb/repo.py
+src/sweetrpg_db/schema/__init__.py

sweetrpg-db-0.0.1/src/sweetrpg_db.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

sweetrpg-db-0.0.1/src/sweetrpg_db.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+sweetrpg-db = sweetrpg_db.cli:main

sweetrpg-db-0.0.1/src/sweetrpg_db.egg-info/requires.txt

@@ -0,0 +1,6 @@
+dnspython~=2.0
+marshmallow~=3.0
+mongoengine~=0.27
+PyMongo[srv]~=3.0
+sweetrpg-model-core
+sweetrpg-common

sweetrpg-db-0.0.1/src/sweetrpg_db.egg-info/top_level.txt

@@ -0,0 +1 @@
+sweetrpg_db