rococo 0.1.2__tar.gz → 0.1.6__tar.gz

rococo-0.1.6/PKG-INFO

@@ -0,0 +1,126 @@
+Metadata-Version: 2.1
+Name: rococo
+Version: 0.1.6
+Summary: A Python library to help build things the way we want them built
+Home-page: https://github.com/EcorRouge/rococo
+Author: Jay Grieves
+Author-email: jaygrieves@gmail.com
+License: MIT
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: surrealdb==0.3.1
+Requires-Dist: boto3==1.28.55
+Requires-Dist: pika==1.3.2
+
+# rococo
+A Python library to help build things the way we want them built.
+
+
+## Basic Usage
+
+### Installation
+
+Install using pip:
+
+```bash
+pip install rococo
+```
+
+### Example
+
+#### Models
+
+```python
+from rococo.models import Person
+
+# Initialize a Person object from rococo's built-in models.
+someone = Person(first_name="John", last_name="Doe")
+
+# Prepare to save the object in the database adding/updating attributes for the object.
+someone.prepare_for_save(changed_by_id="jane_doe")
+
+someone.as_dict()
+
+{
+    'active': True,
+    'changed_by_id': 'jane_doe',
+    'changed_on': datetime.datetime(2023, 9, 20, 19, 50, 23, 532875),
+    'entity_id': 'e06876705b364640a20efc165f6ffb76',
+    'first_name': 'John',
+    'last_name': 'Doe',
+    'previous_version': '7e63a5d0aa0f43b5aa9c8cc0634c41f2',
+    'version': '08489d2bc5d74f78b7af0f2c1d9c5498'
+}
+```
+
+#### Messaging
+
+
+##### RabbitMQ
+```python
+# Producer
+from rococo.messaging import RabbitMqConnection
+
+with RabbitMqConnection('host', 'port', 'username', 'password', 'virtual_host') as conn:
+    conn.send_message('queue_name', {'message': 'data'})
+
+
+# Consumer
+from rococo.messaging import RabbitMqConnection
+
+def process_message(message_data: dict):
+    print(f"Processing message {message_data}...")
+
+with RabbitMqConnection('host', 'port', 'username', 'password', 'virtual_host') as conn:
+    conn.consume_messages('queue_name', process_message)
+```
+
+##### SQS
+```python
+# Producer
+from rococo.messaging import SqsConnection
+
+with SqsConnection(region_name='us-east-1') as conn:
+    conn.send_message('queue_name', {'message': 'data'})
+
+
+# Consumer
+from rococo.messaging import SqsConnection
+
+def process_message(message_data: dict):
+    print(f"Processing message {message_data}...")
+
+with SqsConnection(region_name='us-east-1') as conn:
+    conn.consume_messages('queue_name', process_message)
+
+# Note: since cleanup is not required for SQS connections, you can also do:
+conn = SqsConnection(region_name='us-east-1')
+conn.send_message('queue_name', {'message': 'data'})
+conn.consume_messages('queue_name', process_message)
+```
+
+#### Data
+
+##### SurrealDB
+```python
+from rococo.data import SurrealDbAdapter
+
+def get_db_connection():
+    endpoint = "ws://localhost:8000/rpc"
+    username = "myuser"
+    password = "mypassword"
+    namespace = "test"
+    database = "test"
+
+    return SurrealDbAdapter(endpoint, username, password, namespace, database)
+
+
+with get_db_connection() as db:
+    db.execute_query("""insert into person {
+        user: 'me',
+        pass: 'very_safe',
+        tags: ['python', 'documentation']
+    };""")
+    print(db.execute_query("SELECT * FROM person;", {}))
+```

rococo-0.1.6/README.md

@@ -0,0 +1,111 @@
+# rococo
+A Python library to help build things the way we want them built.
+
+
+## Basic Usage
+
+### Installation
+
+Install using pip:
+
+```bash
+pip install rococo
+```
+
+### Example
+
+#### Models
+
+```python
+from rococo.models import Person
+
+# Initialize a Person object from rococo's built-in models.
+someone = Person(first_name="John", last_name="Doe")
+
+# Prepare to save the object in the database adding/updating attributes for the object.
+someone.prepare_for_save(changed_by_id="jane_doe")
+
+someone.as_dict()
+
+{
+    'active': True,
+    'changed_by_id': 'jane_doe',
+    'changed_on': datetime.datetime(2023, 9, 20, 19, 50, 23, 532875),
+    'entity_id': 'e06876705b364640a20efc165f6ffb76',
+    'first_name': 'John',
+    'last_name': 'Doe',
+    'previous_version': '7e63a5d0aa0f43b5aa9c8cc0634c41f2',
+    'version': '08489d2bc5d74f78b7af0f2c1d9c5498'
+}
+```
+
+#### Messaging
+
+
+##### RabbitMQ
+```python
+# Producer
+from rococo.messaging import RabbitMqConnection
+
+with RabbitMqConnection('host', 'port', 'username', 'password', 'virtual_host') as conn:
+    conn.send_message('queue_name', {'message': 'data'})
+
+
+# Consumer
+from rococo.messaging import RabbitMqConnection
+
+def process_message(message_data: dict):
+    print(f"Processing message {message_data}...")
+
+with RabbitMqConnection('host', 'port', 'username', 'password', 'virtual_host') as conn:
+    conn.consume_messages('queue_name', process_message)
+```
+
+##### SQS
+```python
+# Producer
+from rococo.messaging import SqsConnection
+
+with SqsConnection(region_name='us-east-1') as conn:
+    conn.send_message('queue_name', {'message': 'data'})
+
+
+# Consumer
+from rococo.messaging import SqsConnection
+
+def process_message(message_data: dict):
+    print(f"Processing message {message_data}...")
+
+with SqsConnection(region_name='us-east-1') as conn:
+    conn.consume_messages('queue_name', process_message)
+
+# Note: since cleanup is not required for SQS connections, you can also do:
+conn = SqsConnection(region_name='us-east-1')
+conn.send_message('queue_name', {'message': 'data'})
+conn.consume_messages('queue_name', process_message)
+```
+
+#### Data
+
+##### SurrealDB
+```python
+from rococo.data import SurrealDbAdapter
+
+def get_db_connection():
+    endpoint = "ws://localhost:8000/rpc"
+    username = "myuser"
+    password = "mypassword"
+    namespace = "test"
+    database = "test"
+
+    return SurrealDbAdapter(endpoint, username, password, namespace, database)
+
+
+with get_db_connection() as db:
+    db.execute_query("""insert into person {
+        user: 'me',
+        pass: 'very_safe',
+        tags: ['python', 'documentation']
+    };""")
+    print(db.execute_query("SELECT * FROM person;", {}))
+```

rococo-0.1.6/rococo/data/__init__.py

@@ -0,0 +1,3 @@
+from .base import DbAdapter
+from .surrealdb import SurrealDbAdapter
+

rococo-0.1.6/rococo/data/base.py

@@ -0,0 +1,13 @@
+from abc import abstractmethod
+
+
+class DbAdapter:
+
+    @abstractmethod
+    def execute_query(self, query: str):
+        """Abstract method for executing a query.
+        
+        Args:
+            query (str): The query to execute.
+        """
+        pass    

rococo-0.1.6/rococo/data/surrealdb.py

@@ -0,0 +1,46 @@
+from surrealdb import Surreal
+import asyncio
+
+
+class SurrealDbAdapter():
+    """SurrealDB adapter for interacting with SurrealDB."""
+
+    def __init__(self, endpoint: str, username: str, password: str, namespace: str, db_name: str):
+        """Initializes a new SurrealDB adapter."""
+        self._endpoint = endpoint
+        self._username = username
+        self._password = password
+        self._namespace = namespace
+        self._db_name = db_name
+        self._db = None
+
+    def __enter__(self):
+        """Context manager entry point for preparing DB connection."""
+        self._event_loop = asyncio.new_event_loop()
+        self._db = self._event_loop.run_until_complete(self._prepare_db())
+        return self
+    
+    def __exit__(self, exc_type, exc_value, traceback):
+        """Context manager exit point for closing DB connection."""
+        self._event_loop.run_until_complete(self._db.close())
+        self._event_loop.stop()
+        self._event_loop = None
+        self._db = None
+
+    async def _prepare_db(self):
+        """Prepares the DB connection."""
+        db = Surreal(self._endpoint)
+        await db.connect()
+        await db.signin({"user": self._username, "pass": self._password})
+        await db.use(self._namespace, self._db_name)
+        return db
+    
+    def execute_query(self, sql, _vars=None):
+        """Executes a query against the DB."""
+        if _vars is None:
+            _vars = {}
+
+        if not self._db:
+            raise Exception("No connection to SurrealDB.")
+
+        return self._event_loop.run_until_complete(self._db.query(sql, _vars))

rococo-0.1.6/rococo/messaging/__init__.py

@@ -0,0 +1,3 @@
+from .base import Connection
+from .rabbitmq import RabbitMqConnection
+from .sqs import SqsConnection

rococo-0.1.6/rococo/messaging/base.py

@@ -0,0 +1,40 @@
+from abc import abstractmethod
+
+
+# An abstract Connection class that enforces the implementation of the send_message and consume_messages methods.
+
+class Connection:
+    """Abstract class for a connection to a message queue."""
+    
+    @abstractmethod
+    def send_message(self, queue_name: str, message: dict):
+        """
+        Sends a message to the specified queue.
+
+        Args:
+            queue_name (str): The name of the queue to send the message to.
+            message (dict): The message to send.
+        """
+        pass
+
+    @abstractmethod
+    def consume_messages(self, queue_name: str, callback_function: callable):
+        """
+        Consumes messages from the specified queue.
+
+        Args:
+            queue_name (str): The name of the queue to consume messages from.
+            callback_function (callable): The function to call when a message is received.
+        """
+        pass
+
+    
+    @abstractmethod
+    def __enter__(self):
+        """Performs any initialization required for the connection."""
+        pass
+
+    @abstractmethod
+    def __exit__(self, exc_type, exc_value, traceback):
+        """Performs any cleanup required for the connection."""
+        pass

rococo-0.1.6/rococo/messaging/rabbitmq.py

@@ -0,0 +1,141 @@
+import json
+import pika
+import functools
+import threading
+import logging
+from typing import Callable
+
+from . import Connection
+
+logger = logging.getLogger(__name__)
+
+class RabbitMqConnection(Connection):
+    """A connection to a RabbitMQ message queue that allows to send and receive messages."""
+
+
+    def __init__(self, host: str, port: int, username: str, password: str, virtual_host: str = ''):
+        """
+        Initializes a new RabbitMQ connection.
+
+        Args:
+            host (str): The host of the RabbitMQ server.
+            port (int): The port of the RabbitMQ server.
+            username (str): The username to use when connecting to the RabbitMQ server.
+            password (str): The password to use when connecting to the RabbitMQ server.
+            virtual_host (str): The virtual host to use when connecting to the RabbitMQ server.
+        """
+        self._host = host
+        self._port = port
+        self._username = username
+        self._password = password
+        self._virtual_host = virtual_host
+
+        self._connection = None
+        self._channel = None
+
+    def __enter__(self):
+        """
+        Opens a connection to the RabbitMQ server.
+
+        Returns:
+            RabbitMqConnection: The connection to the RabbitMQ server.
+        """
+        self._connection = pika.BlockingConnection(
+            pika.ConnectionParameters(host=self._host, port=self._port, credentials=pika.PlainCredentials(self._username, self._password), 
+                                      virtual_host=self._virtual_host))
+        self._channel = self._connection.channel()
+
+        return self
+
+    def __exit__(self, exc_type, exc_value, traceback):
+        """
+        Closes the connection to the RabbitMQ server.
+        """
+        self._connection.close()
+        self._connection = None
+        self._channel = None
+
+
+    def send_message(self, queue_name: str, message: dict):
+        """
+        Sends a message to the specified queue.
+
+        Args:
+            queue_name (str): The name of the queue to send the message to.
+            message (dict): The message to send.
+        """
+        self._channel.basic_publish(exchange='', routing_key=queue_name, body=json.dumps(message))
+
+    def consume_messages(self, queue_name: str, callback_function: Callable[[dict], bool], num_threads: int = 1):
+        """
+        Consumes messages from the specified queue.
+
+        Args:
+            queue_name (str): The name of the queue to consume messages from.
+            callback_function (callable): The function to call when a message is received.
+        """
+
+        def _ack_message(ch, delivery_tag):
+            """Ack a message by its delivery tag if channel is open."""
+
+            if ch.is_open:
+                ch.basic_ack(delivery_tag)
+
+        def _do_work(ch, delivery_tag, body, callback):
+            """Callback function that processes the message."""
+
+            thread_id = threading.get_ident()
+            logger.info(
+                "Thread id: %s Delivery tag: %s Message body: %s",
+                thread_id,
+                delivery_tag,
+                body,
+            )
+            try:
+                success = callback(body)
+            except Exception:
+                logger.exception("Error processing message...")
+                success = False
+            logger.info(
+                "Thread id: %s Delivery tag: %s Message body: %s Processed...",
+                thread_id,
+                delivery_tag,
+                body,
+            )
+            cb = functools.partial(_ack_message, ch, delivery_tag)
+            logger.info(f"Sent ack for Delivery tag {delivery_tag}...")
+            self._connection.add_callback_threadsafe(cb)
+
+        def _on_message(ch, method_frame, _header_frame, body, args):
+            """Called when a message is received."""
+
+            body = json.loads(body.decode())
+            (callback,) = args
+            delivery_tag = method_frame.delivery_tag
+            t = threading.Thread(
+                target=_do_work, args=(ch, delivery_tag, body, callback)
+            )
+            t.start()
+            self._threads.append(t)
+
+        self._channel.queue_declare(queue=queue_name, durable=True)
+
+        self._threads = []
+        self._channel.basic_qos(prefetch_count=num_threads)
+
+        on_message_callback = functools.partial(_on_message, args=(callback_function,))
+        self._channel.basic_consume(
+            queue=queue_name, on_message_callback=on_message_callback
+        )
+
+        try:
+            logger.info(f"Listening to RabbitMQ queue {queue_name} on {self._host}:{self._port} with {num_threads} threads...")
+            self._channel.start_consuming()
+        except KeyboardInterrupt:
+            logger.info("Exiting gracefully...")
+            self._channel.stop_consuming()
+        finally:
+            # Wait for all to complete
+            for thread in self._threads:
+                thread.join()
+            self._connection.close()

rococo-0.1.6/rococo/messaging/sqs.py

@@ -0,0 +1,88 @@
+import json
+import boto3
+import logging
+import uuid
+
+from . import Connection
+
+logger = logging.getLogger(__name__)
+
+class SqsConnection(Connection):
+    """A connection to AWS SQS that allows sending and receiving messages to and from queues."""
+
+    def __init__(self, aws_access_key_id: str = None, aws_access_key_secret: str = None, region_name: str = None):
+        """Initializes a new SQS connection.
+
+        Args:
+            aws_access_key_id (str): The AWS access key ID.
+            aws_access_key_secret (str): The AWS access key secret.
+            region_name (str): The AWS region name.
+        """
+
+        self._aws_access_key_id = aws_access_key_id
+        self._aws_access_key_secret = aws_access_key_secret
+        self._region_name = region_name
+        self._sqs = boto3.resource('sqs', aws_access_key_id=self._aws_access_key_id, aws_secret_access_key=self._aws_access_key_secret, region_name=self._region_name)
+        self._queue_map = {}
+
+    def __enter__(self):
+        return self
+
+    def __exit__(self, exc_type, exc_value, traceback):
+        pass
+
+    def send_message(self, queue_name: str, message: dict):
+        """Sends a message to the specified SQS queue.
+        
+        Args:
+            queue_name (str): The name of the queue to send the message to.
+            message (dict): The message to send.
+        """
+        if queue_name in self._queue_map:
+            queue = self._queue_map[queue_name]
+        else:
+            queue = self._sqs.get_queue_by_name(QueueName=queue_name)
+
+        queue.send_message(QueueUrl=queue_name, MessageBody=json.dumps(message))
+
+    def consume_messages(self, queue_name: str, callback_function: callable):
+        """Consumes messages from the specified SQS queue.
+
+        Args:
+            queue_name (str): The name of the queue to consume messages from.
+            callback_function (callable): The function to call when a message is received.
+        """
+
+        def _delete_queue_message(queue, handle):
+            logger.info("Deleting message.")
+            queue.delete_messages(
+                Entries=[
+                    {
+                        'Id': str(uuid.uuid4()),
+                        'ReceiptHandle': handle
+                    },
+                ]
+            )
+
+        logger.info(f"Connecting to SQS queue: {queue_name}...")
+        queue = self._sqs.get_queue_by_name(QueueName=queue_name)
+
+        while True:
+            logger.info(f"Fetching messages from SQS queue: {queue_name}...")
+            responses = queue.receive_messages(
+                AttributeNames=['All'],
+                MaxNumberOfMessages=1,
+                WaitTimeSeconds=20
+            )
+            if not responses:
+                logger.info("No messages left in queue.")
+                continue
+
+            response = {}
+            try:
+                response = responses[0]
+                body = json.loads(response.body)
+                callback_function(body)
+            except Exception as _:
+                logger.exception("Error processing message...")
+            _delete_queue_message(queue, response.receipt_handle)

rococo-0.1.6/rococo/models/__init__.py

@@ -0,0 +1,7 @@
+from .versioned_model import VersionedModel
+
+from .login_method import LoginMethod
+from .organization import Organization
+from .otp_method import OtpMethod
+from .person import Person
+from .person_organization_role import PersonOrganizationRole

rococo-0.1.6/rococo/models/login_method.py

@@ -0,0 +1,15 @@
+from dataclasses import dataclass
+from typing import Optional
+
+from . import VersionedModel
+
+
+@dataclass
+class LoginMethod(VersionedModel):
+    """A login method model."""
+
+    person_id: str
+    method_type: str
+    method_data: Optional[dict]
+    email: Optional[str]
+    password: Optional[str]

rococo-0.1.6/rococo/models/organization.py

@@ -0,0 +1,10 @@
+from dataclasses import dataclass
+
+from . import VersionedModel
+
+
+@dataclass
+class Organization(VersionedModel):
+    """An organization model."""
+
+    name: str

rococo-0.1.6/rococo/models/otp_method.py

@@ -0,0 +1,15 @@
+from dataclasses import dataclass
+from typing import List
+
+from . import VersionedModel
+
+
+@dataclass
+class OtpMethod(VersionedModel):
+    """An OTP method model."""
+
+    person_id: str
+    secret: str
+    name: str
+    enabled: bool
+    recovery_codes: List[str]

rococo-0.1.6/rococo/models/person.py

@@ -0,0 +1,11 @@
+from dataclasses import dataclass
+
+from . import VersionedModel
+
+
+@dataclass
+class Person(VersionedModel):
+    """A person model."""
+
+    first_name: str
+    last_name: str

rococo-0.1.6/rococo/models/person_organization_role.py

@@ -0,0 +1,12 @@
+from dataclasses import dataclass
+
+from . import VersionedModel
+
+
+@dataclass
+class PersonOrganizationRole(VersionedModel):
+    """A person organization role model."""
+
+    person_id: str
+    organization_id: str
+    role: str

rococo-0.1.6/rococo/models/versioned_model.py

@@ -0,0 +1,69 @@
+from uuid import uuid4
+from dataclasses import dataclass, field, fields
+from datetime import datetime
+from typing import Any, Dict, List
+
+
+@dataclass(kw_only=True)
+class VersionedModel:
+    """A base class for versioned models with common (Big 6) attributes."""
+
+    entity_id: str = uuid4().hex
+    version: str = uuid4().hex
+    previous_version: str = '00000000000000000000000000000000'
+    active: bool = True
+    changed_by_id: str = '00000000000000000000000000000000'
+    changed_on: datetime = field(default_factory=lambda: datetime.utcnow())
+
+    @classmethod
+    def fields(cls) -> List[str]:
+        """Get a list of field names for this model.
+        
+        Returns:
+            List[str]: A list of field names.
+        """
+        return [f.name for f in fields(cls)]
+
+    def as_dict(self, convert_datetime_to_iso_string: bool = False) -> Dict[str, Any]:
+        """Convert this model to a dictionary.
+
+        Args:
+            convert_datetime_to_iso_string (bool, optional): Whether to convert datetime objects to ISO strings. Defaults to False.
+
+        Returns:
+            Dict[str, Any]: A dictionary representation of this model.
+        """
+        results = self.__dict__
+
+        if convert_datetime_to_iso_string:
+            for key, value in results.items():
+                if isinstance(value, datetime):
+                    results[key] = value.isoformat()
+
+        return results
+
+    @classmethod
+    def from_dict(cls, model_dict: dict):
+        """Create a model from a dictionary.
+
+        Args:
+            model_dict (dict): A dictionary representation of a model.
+
+        Returns:
+            VersionedModel: A model object.
+        """
+        for key in model_dict:
+            if key in cls.__dict__:
+                cls.__dict__[key] = model_dict[key]
+
+    def prepare_for_save(self, changed_by_id: str):
+        """
+        Prepare this model for saving to the database.
+
+        Args:
+            changed_by_id (str): The ID of the user making the change.
+        """
+        self.previous_version = self.version
+        self.version = uuid4().hex
+        self.changed_on = datetime.utcnow()
+        self.changed_by_id = changed_by_id

rococo-0.1.6/rococo.egg-info/PKG-INFO

@@ -0,0 +1,126 @@
+Metadata-Version: 2.1
+Name: rococo
+Version: 0.1.6
+Summary: A Python library to help build things the way we want them built
+Home-page: https://github.com/EcorRouge/rococo
+Author: Jay Grieves
+Author-email: jaygrieves@gmail.com
+License: MIT
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: surrealdb==0.3.1
+Requires-Dist: boto3==1.28.55
+Requires-Dist: pika==1.3.2
+
+# rococo
+A Python library to help build things the way we want them built.
+
+
+## Basic Usage
+
+### Installation
+
+Install using pip:
+
+```bash
+pip install rococo
+```
+
+### Example
+
+#### Models
+
+```python
+from rococo.models import Person
+
+# Initialize a Person object from rococo's built-in models.
+someone = Person(first_name="John", last_name="Doe")
+
+# Prepare to save the object in the database adding/updating attributes for the object.
+someone.prepare_for_save(changed_by_id="jane_doe")
+
+someone.as_dict()
+
+{
+    'active': True,
+    'changed_by_id': 'jane_doe',
+    'changed_on': datetime.datetime(2023, 9, 20, 19, 50, 23, 532875),
+    'entity_id': 'e06876705b364640a20efc165f6ffb76',
+    'first_name': 'John',
+    'last_name': 'Doe',
+    'previous_version': '7e63a5d0aa0f43b5aa9c8cc0634c41f2',
+    'version': '08489d2bc5d74f78b7af0f2c1d9c5498'
+}
+```
+
+#### Messaging
+
+
+##### RabbitMQ
+```python
+# Producer
+from rococo.messaging import RabbitMqConnection
+
+with RabbitMqConnection('host', 'port', 'username', 'password', 'virtual_host') as conn:
+    conn.send_message('queue_name', {'message': 'data'})
+
+
+# Consumer
+from rococo.messaging import RabbitMqConnection
+
+def process_message(message_data: dict):
+    print(f"Processing message {message_data}...")
+
+with RabbitMqConnection('host', 'port', 'username', 'password', 'virtual_host') as conn:
+    conn.consume_messages('queue_name', process_message)
+```
+
+##### SQS
+```python
+# Producer
+from rococo.messaging import SqsConnection
+
+with SqsConnection(region_name='us-east-1') as conn:
+    conn.send_message('queue_name', {'message': 'data'})
+
+
+# Consumer
+from rococo.messaging import SqsConnection
+
+def process_message(message_data: dict):
+    print(f"Processing message {message_data}...")
+
+with SqsConnection(region_name='us-east-1') as conn:
+    conn.consume_messages('queue_name', process_message)
+
+# Note: since cleanup is not required for SQS connections, you can also do:
+conn = SqsConnection(region_name='us-east-1')
+conn.send_message('queue_name', {'message': 'data'})
+conn.consume_messages('queue_name', process_message)
+```
+
+#### Data
+
+##### SurrealDB
+```python
+from rococo.data import SurrealDbAdapter
+
+def get_db_connection():
+    endpoint = "ws://localhost:8000/rpc"
+    username = "myuser"
+    password = "mypassword"
+    namespace = "test"
+    database = "test"
+
+    return SurrealDbAdapter(endpoint, username, password, namespace, database)
+
+
+with get_db_connection() as db:
+    db.execute_query("""insert into person {
+        user: 'me',
+        pass: 'very_safe',
+        tags: ['python', 'documentation']
+    };""")
+    print(db.execute_query("SELECT * FROM person;", {}))
+```

rococo-0.1.6/rococo.egg-info/SOURCES.txt

@@ -0,0 +1,23 @@
+LICENSE
+README.md
+setup.py
+rococo/__init__.py
+rococo.egg-info/PKG-INFO
+rococo.egg-info/SOURCES.txt
+rococo.egg-info/dependency_links.txt
+rococo.egg-info/requires.txt
+rococo.egg-info/top_level.txt
+rococo/data/__init__.py
+rococo/data/base.py
+rococo/data/surrealdb.py
+rococo/messaging/__init__.py
+rococo/messaging/base.py
+rococo/messaging/rabbitmq.py
+rococo/messaging/sqs.py
+rococo/models/__init__.py
+rococo/models/login_method.py
+rococo/models/organization.py
+rococo/models/otp_method.py
+rococo/models/person.py
+rococo/models/person_organization_role.py
+rococo/models/versioned_model.py

rococo-0.1.6/rococo.egg-info/requires.txt

@@ -0,0 +1,3 @@
+surrealdb==0.3.1
+boto3==1.28.55
+pika==1.3.2

{rococo-0.1.2 → rococo-0.1.6}/setup.py

@@ -1,9 +1,9 @@
-from setuptools import setup
+from setuptools import setup, find_packages
 
 setup(
     name='rococo',
-    version='0.1.2',
-    packages=['rococo'],
+    version='0.1.6',
+    packages=find_packages(),
     url='https://github.com/EcorRouge/rococo',
     license='MIT',
     author='Jay Grieves',
@@ -11,5 +11,10 @@ setup(
     description='A Python library to help build things the way we want them built',
     long_description=open('README.md').read(),
     long_description_content_type='text/markdown',
+    install_requires=[
+        'surrealdb==0.3.1',
+        'boto3==1.28.55',
+        'pika==1.3.2'
+    ],
     python_requires=">=3.10"
 )

rococo-0.1.2/PKG-INFO

@@ -1,51 +0,0 @@
-Metadata-Version: 2.1
-Name: rococo
-Version: 0.1.2
-Summary: A Python library to help build things the way we want them built
-Home-page: https://github.com/EcorRouge/rococo
-Author: Jay Grieves
-Author-email: jaygrieves@gmail.com
-License: MIT
-Requires-Python: >=3.10
-Description-Content-Type: text/markdown
-License-File: LICENSE
-
-# rococo
-A Python library to help build things the way we want them built.
-
-
-## Basic Usage
-
-### Installation
-
-Install using pip:
-
-```bash
-pip install rococo
-```
-
-### Example
-
-```python
-from rococo.models import Person
-
-# Initialize a Person object from rococo's built-in models.
-someone = Person(first_name="John", last_name="Doe")
-
-# Prepare to save the object in the database adding/updating attributes for the object.
-someone.prepare_for_save(changed_by_id="jane_doe")
-
-someone.as_dict()
-
-{
-    'active': True,
-    'changed_by_id': 'jane_doe',
-    'changed_on': datetime.datetime(2023, 9, 20, 19, 50, 23, 532875),
-    'entity_id': 'e06876705b364640a20efc165f6ffb76',
-    'first_name': 'John',
-    'last_name': 'Doe',
-    'previous_version': '7e63a5d0aa0f43b5aa9c8cc0634c41f2',
-    'version': '08489d2bc5d74f78b7af0f2c1d9c5498'
-}
-```
-

rococo-0.1.2/README.md

@@ -1,39 +0,0 @@
-# rococo
-A Python library to help build things the way we want them built.
-
-
-## Basic Usage
-
-### Installation
-
-Install using pip:
-
-```bash
-pip install rococo
-```
-
-### Example
-
-```python
-from rococo.models import Person
-
-# Initialize a Person object from rococo's built-in models.
-someone = Person(first_name="John", last_name="Doe")
-
-# Prepare to save the object in the database adding/updating attributes for the object.
-someone.prepare_for_save(changed_by_id="jane_doe")
-
-someone.as_dict()
-
-{
-    'active': True,
-    'changed_by_id': 'jane_doe',
-    'changed_on': datetime.datetime(2023, 9, 20, 19, 50, 23, 532875),
-    'entity_id': 'e06876705b364640a20efc165f6ffb76',
-    'first_name': 'John',
-    'last_name': 'Doe',
-    'previous_version': '7e63a5d0aa0f43b5aa9c8cc0634c41f2',
-    'version': '08489d2bc5d74f78b7af0f2c1d9c5498'
-}
-```
-

rococo-0.1.2/rococo.egg-info/PKG-INFO

@@ -1,51 +0,0 @@
-Metadata-Version: 2.1
-Name: rococo
-Version: 0.1.2
-Summary: A Python library to help build things the way we want them built
-Home-page: https://github.com/EcorRouge/rococo
-Author: Jay Grieves
-Author-email: jaygrieves@gmail.com
-License: MIT
-Requires-Python: >=3.10
-Description-Content-Type: text/markdown
-License-File: LICENSE
-
-# rococo
-A Python library to help build things the way we want them built.
-
-
-## Basic Usage
-
-### Installation
-
-Install using pip:
-
-```bash
-pip install rococo
-```
-
-### Example
-
-```python
-from rococo.models import Person
-
-# Initialize a Person object from rococo's built-in models.
-someone = Person(first_name="John", last_name="Doe")
-
-# Prepare to save the object in the database adding/updating attributes for the object.
-someone.prepare_for_save(changed_by_id="jane_doe")
-
-someone.as_dict()
-
-{
-    'active': True,
-    'changed_by_id': 'jane_doe',
-    'changed_on': datetime.datetime(2023, 9, 20, 19, 50, 23, 532875),
-    'entity_id': 'e06876705b364640a20efc165f6ffb76',
-    'first_name': 'John',
-    'last_name': 'Doe',
-    'previous_version': '7e63a5d0aa0f43b5aa9c8cc0634c41f2',
-    'version': '08489d2bc5d74f78b7af0f2c1d9c5498'
-}
-```
-

rococo-0.1.2/rococo.egg-info/SOURCES.txt

@@ -1,8 +0,0 @@
-LICENSE
-README.md
-setup.py
-rococo/__init__.py
-rococo.egg-info/PKG-INFO
-rococo.egg-info/SOURCES.txt
-rococo.egg-info/dependency_links.txt
-rococo.egg-info/top_level.txt