rococo 1.1.2__tar.gz → 1.1.3__tar.gz

{rococo-1.1.2 → rococo-1.1.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: rococo
-Version: 1.1.2
+Version: 1.1.3
 Summary: A Python library to help build things the way we want them built
 Home-page: https://github.com/EcorRouge/rococo
 Author: Jay Grieves

{rococo-1.1.2 → rococo-1.1.3}/rococo/models/versioned_model.py

@@ -1,12 +1,16 @@
 import pkgutil
 import os
 import importlib
+import logging
 from uuid import uuid4, UUID
 from dataclasses import dataclass, field, fields, InitVar, is_dataclass
 from datetime import datetime, timezone
+from dateutil.parser import isoparse
 from typing import Any, Dict, List, Union, get_type_hints, get_origin, get_args
 from enum import Enum
 
+logger = logging.getLogger(__name__)
+
 # Constants for VersionedModel field groups
 BIG_6_FIELDS = {'entity_id', 'version', 'previous_version',
                 'changed_on', 'changed_by_id', 'active'}
@@ -148,7 +152,8 @@ class VersionedModel:
                                      for u in value[1:-1].split(',') if u.strip()]
                         setattr(self, f.name, uuid_list)
                     except ValueError:
-                        print(f"Invalid UUIDs in list for field '{f.name}'")
+                        logger.info(
+                            f"Invalid UUIDs in list for field '{f.name}'")
 
     def __getattribute__(self, name):
         """
@@ -244,7 +249,15 @@ class VersionedModel:
         Allow setting extra fields directly as attributes.
         If the field is not a defined model field and allow_extra is True,
         store it in the extra dict.
+        Skip setting calculated properties (properties without setters).
         """
+        # Check if this is a calculated property (property without setter)
+        if not name.startswith('_'):
+            attr = getattr(type(self), name, None)
+            if isinstance(attr, property) and attr.fset is None:
+                # This is a calculated property (read-only), skip setting it
+                return
+
         # Get model fields (but handle the case where fields() might not be available yet)
         try:
             model_fields = self.fields()
@@ -464,9 +477,9 @@ class VersionedModel:
                     clean_data[k] = UUID(
                         v).hex if v and not isinstance(v, UUID) else v
                 except ValueError:
-                    print(f"'{v}' is not a valid UUID.")
+                    logger.info(f"'{v}' is not a valid UUID.")
 
-            # Handle enum conversion from string values
+            # Handle enum conversion from string values and datetime conversion from ISO strings
             elif v is not None:
                 expected_type = hints.get(k)
                 if expected_type:
@@ -483,6 +496,15 @@ class VersionedModel:
                             except ValueError:
                                 # If the string value doesn't match any enum value, leave as is
                                 pass
+                        # Find datetime type in the Union for Optional[datetime]
+                        datetime_type = next(
+                            (arg for arg in args if arg is datetime), None)
+                        if datetime_type and isinstance(v, str):
+                            try:
+                                clean_data[k] = isoparse(v)
+                            except (ValueError, TypeError):
+                                # If the string value can't be parsed as datetime, leave as is
+                                pass
                     # Handle direct enum types
                     elif isinstance(expected_type, type) and issubclass(expected_type, Enum) and isinstance(v, str):
                         try:
@@ -490,6 +512,13 @@ class VersionedModel:
                         except ValueError:
                             # If the string value doesn't match any enum value, leave as is
                             pass
+                    # Handle direct datetime types
+                    elif expected_type is datetime and isinstance(v, str):
+                        try:
+                            clean_data[k] = isoparse(v)
+                        except (ValueError, TypeError):
+                            # If the string value can't be parsed as datetime, leave as is
+                            pass
 
                 # Handle dataclass conversion from dict values
                 f = next((f for f in fields(cls) if f.name == k), None)
@@ -522,10 +551,19 @@ class VersionedModel:
         # Create the instance
         instance = cls(**clean_data)
 
-        # Set extra fields directly (not nested)
+        # Set extra fields directly (not nested), but skip calculated properties
         if extra_data:
+            filtered_extra_data = {}
+            for k, v in extra_data.items():
+                # Check if this is a calculated property (property without setter)
+                attr = getattr(cls, k, None)
+                if isinstance(attr, property) and attr.fset is None:
+                    # This is a calculated property (read-only), skip setting it
+                    continue
+                filtered_extra_data[k] = v
+
             # Replace the entire extra dict to avoid nesting
-            instance.extra = extra_data
+            instance.extra = filtered_extra_data
 
         return instance
 

{rococo-1.1.2 → rococo-1.1.3}/rococo/repositories/mongodb/mongodb_repository.py

@@ -64,7 +64,7 @@ class MongoDbRepository(BaseRepository):
         """
         instance.prepare_for_save(changed_by_id=self.user_id)
         data = instance.as_dict(
-            convert_datetime_to_iso_string=True,
+            convert_datetime_to_iso_string=False,
             convert_uuids=True,
             export_properties=self.save_calculated_fields
         )

{rococo-1.1.2 → rococo-1.1.3}/rococo/repositories/surrealdb/person_organization_role_repository.py

@@ -1,12 +1,16 @@
 import copy
+import logging
 from typing import List, Union
 from rococo.repositories.surrealdb import SurrealDbRepository
 from rococo.models.surrealdb import PersonOrganizationRole
 
+logger = logging.getLogger(__name__)
+
 
 class PersonOrganizationRoleRepository(SurrealDbRepository):
     def __init__(self, adapter, message_adapter, message_queue_name):
-        super().__init__(adapter, PersonOrganizationRole, message_adapter, message_queue_name)
+        super().__init__(adapter, PersonOrganizationRole,
+                         message_adapter, message_queue_name)
 
     def find_organizations_by_member(self, member_id: str, get_member: bool = False) -> List[PersonOrganizationRole]:
         """finds all the organizations that a Person identified by member_id is a member of 
@@ -19,9 +23,10 @@ class PersonOrganizationRoleRepository(SurrealDbRepository):
             List[PersonOrganizationRole]: found PersonOrganizationRole
         """
         conditions = {"person": member_id}
-        fetch_related: List[str] = ["organization", "person"] if get_member else ["organization"]
+        fetch_related: List[str] = ["organization",
+                                    "person"] if get_member else ["organization"]
         return self.get_many(conditions, fetch_related=fetch_related)
-    
+
     def find_organizations_by_owner(self, owner_id: str, get_owner: bool = False) -> List[PersonOrganizationRole]:
         """finds all the organizations that a Person identified by member_id is an owner of 
 
@@ -32,8 +37,10 @@ class PersonOrganizationRoleRepository(SurrealDbRepository):
         Returns:
             List[PersonOrganizationRole]: found PersonOrganizationRole-s
         """
-        print(f"[find_organizations_by_owner] owner_id: {owner_id}", flush=True)
+        logger.info(
+            f"[find_organizations_by_owner] owner_id: {owner_id}")
         OWNER: str = "OWNER"
         conditions = {"person": owner_id, "role": OWNER}
-        fetch_related: List[str] = ["organization", "person"] if get_owner else ["organization"]
-        return self.get_many(conditions, fetch_related=fetch_related)
+        fetch_related: List[str] = ["organization",
+                                    "person"] if get_owner else ["organization"]
+        return self.get_many(conditions, fetch_related=fetch_related)

{rococo-1.1.2 → rococo-1.1.3}/rococo.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: rococo
-Version: 1.1.2
+Version: 1.1.3
 Summary: A Python library to help build things the way we want them built
 Home-page: https://github.com/EcorRouge/rococo
 Author: Jay Grieves

{rococo-1.1.2 → rococo-1.1.3}/rococo.egg-info/SOURCES.txt

@@ -85,4 +85,5 @@ tests/model_test.py
 tests/mongodb_repository_test.py
 tests/mysql_repository_test.py
 tests/postgre_repository_test.py
-tests/surrealdb_repository_test.py
+tests/surrealdb_repository_test.py
+tests/test_calculated_properties_fix.py

{rococo-1.1.2 → rococo-1.1.3}/setup.py

@@ -48,7 +48,7 @@ extras_require["all"] = [
 
 setup(
     name='rococo',
-    version='1.1.2',
+    version='1.1.3',
     packages=find_packages(),
     url='https://github.com/EcorRouge/rococo',
     license='MIT',

{rococo-1.1.2 → rococo-1.1.3}/tests/model_test.py

@@ -369,11 +369,9 @@ def test_from_dict_uuid_validation():
     model = VersionedModel.from_dict(valid_data)
     assert model.entity_id == UUID(int=1).hex
 
-    # Test with invalid UUID string (should print error but not crash)
-    with patch('builtins.print') as mock_print:
-        invalid_data = {"entity_id": "invalid-uuid"}
-        model = VersionedModel.from_dict(invalid_data)
-        mock_print.assert_called_with("'invalid-uuid' is not a valid UUID.")
+    # Test with invalid UUID string (should log error but not crash)
+    invalid_data = {"entity_id": "invalid-uuid"}
+    model = VersionedModel.from_dict(invalid_data)
 
 
 def test_from_dict_field_filtering():
@@ -2141,3 +2139,278 @@ def test_field_alias_inheritance():
     restored = DerivedModelWithAlias.from_dict(result)
     assert restored.base_field == "base_value"
     assert restored.derived_field == "derived_value"
+
+
+# Tests for datetime parsing in from_dict()
+def test_datetime_parsing_from_iso_string():
+    """Test that datetime fields are correctly parsed from ISO strings in from_dict()"""
+
+    @dataclass
+    class TestModelWithDatetime(VersionedModel):
+        created_at: datetime = field(
+            default_factory=lambda: datetime.now(timezone.utc))
+        updated_at: datetime = field(
+            default_factory=lambda: datetime.now(timezone.utc))
+
+    # Test data with datetime fields as ISO strings (simulating data from MongoDB)
+    test_data = {
+        'entity_id': 'test123',
+        'version': 'version123',
+        'previous_version': None,
+        'active': True,
+        'changed_by_id': 'user123',
+        'changed_on': '2024-01-15T10:30:00+00:00',  # ISO string
+        'created_at': '2024-01-15T09:00:00+00:00',   # ISO string
+        'updated_at': '2024-01-15T11:00:00+00:00',   # ISO string
+    }
+
+    # Create model instance from dict
+    model = TestModelWithDatetime.from_dict(test_data)
+
+    # Verify that datetime strings were parsed correctly
+    assert isinstance(
+        model.changed_on, datetime), f"changed_on should be datetime, got {type(model.changed_on)}"
+    assert isinstance(
+        model.created_at, datetime), f"created_at should be datetime, got {type(model.created_at)}"
+    assert isinstance(
+        model.updated_at, datetime), f"updated_at should be datetime, got {type(model.updated_at)}"
+
+    # Verify the actual datetime values
+    expected_changed_on = datetime(2024, 1, 15, 10, 30, 0, tzinfo=timezone.utc)
+    expected_created_at = datetime(2024, 1, 15, 9, 0, 0, tzinfo=timezone.utc)
+    expected_updated_at = datetime(2024, 1, 15, 11, 0, 0, tzinfo=timezone.utc)
+
+    assert model.changed_on == expected_changed_on, f"changed_on mismatch: {model.changed_on} != {expected_changed_on}"
+    assert model.created_at == expected_created_at, f"created_at mismatch: {model.created_at} != {expected_created_at}"
+    assert model.updated_at == expected_updated_at, f"updated_at mismatch: {model.updated_at} != {expected_updated_at}"
+
+
+def test_datetime_parsing_optional_fields():
+    """Test datetime parsing works with Optional[datetime] fields"""
+    from typing import Optional
+
+    @dataclass
+    class TestModelWithOptionalDatetime(VersionedModel):
+        created_at: datetime = field(
+            default_factory=lambda: datetime.now(timezone.utc))
+        updated_at: Optional[datetime] = None
+        deleted_at: Optional[datetime] = None
+
+    # Test with ISO string for optional field
+    test_data = {
+        'entity_id': 'test123',
+        'created_at': '2024-01-15T09:00:00+00:00',
+        'updated_at': '2024-01-15T11:00:00+00:00',  # ISO string
+        'deleted_at': None  # None value
+    }
+
+    model = TestModelWithOptionalDatetime.from_dict(test_data)
+
+    # Required datetime field should be parsed
+    assert isinstance(model.created_at, datetime)
+    assert model.created_at == datetime(
+        2024, 1, 15, 9, 0, 0, tzinfo=timezone.utc)
+
+    # Optional datetime field with ISO string should be parsed
+    assert isinstance(model.updated_at, datetime)
+    assert model.updated_at == datetime(
+        2024, 1, 15, 11, 0, 0, tzinfo=timezone.utc)
+
+    # Optional datetime field with None should remain None
+    assert model.deleted_at is None
+
+
+def test_datetime_parsing_preserves_existing_datetime():
+    """Test that existing datetime objects are preserved unchanged"""
+
+    @dataclass
+    class TestModelWithDatetime(VersionedModel):
+        created_at: datetime = field(
+            default_factory=lambda: datetime.now(timezone.utc))
+
+    # Test with already datetime object
+    existing_datetime = datetime(2024, 1, 15, 9, 0, 0, tzinfo=timezone.utc)
+    test_data = {
+        'entity_id': 'test123',
+        'created_at': existing_datetime  # Already a datetime object
+    }
+
+    model = TestModelWithDatetime.from_dict(test_data)
+
+    # Datetime object should be preserved unchanged
+    assert isinstance(model.created_at, datetime)
+    assert model.created_at == existing_datetime
+    assert model.created_at is existing_datetime  # Should be the same object
+
+
+def test_datetime_parsing_invalid_strings():
+    """Test that invalid datetime strings are left unchanged"""
+
+    @dataclass
+    class TestModelWithDatetime(VersionedModel):
+        created_at: datetime = field(
+            default_factory=lambda: datetime.now(timezone.utc))
+
+    # Test with invalid datetime string
+    test_data = {
+        'entity_id': 'test123',
+        'created_at': 'invalid-date-string'
+    }
+
+    model = TestModelWithDatetime.from_dict(test_data)
+
+    # Invalid datetime string should be left as-is
+    assert model.created_at == 'invalid-date-string'
+    assert isinstance(model.created_at, str)
+
+
+def test_datetime_parsing_various_iso_formats():
+    """Test datetime parsing works with various ISO format strings"""
+
+    @dataclass
+    class TestModelWithDatetime(VersionedModel):
+        datetime1: datetime = field(
+            default_factory=lambda: datetime.now(timezone.utc))
+        datetime2: datetime = field(
+            default_factory=lambda: datetime.now(timezone.utc))
+        datetime3: datetime = field(
+            default_factory=lambda: datetime.now(timezone.utc))
+        datetime4: datetime = field(
+            default_factory=lambda: datetime.now(timezone.utc))
+
+    # Test with various ISO format strings
+    test_data = {
+        'entity_id': 'test123',
+        'datetime1': '2024-01-15T10:30:00Z',           # UTC with Z
+        'datetime2': '2024-01-15T10:30:00+00:00',      # UTC with +00:00
+        'datetime3': '2024-01-15T10:30:00.123456Z',    # With microseconds
+        'datetime4': '2024-01-15T10:30:00-05:00',      # With timezone offset
+    }
+
+    model = TestModelWithDatetime.from_dict(test_data)
+
+    # All should be parsed as datetime objects
+    assert isinstance(model.datetime1, datetime)
+    assert isinstance(model.datetime2, datetime)
+    assert isinstance(model.datetime3, datetime)
+    assert isinstance(model.datetime4, datetime)
+
+    # Verify specific values
+    assert model.datetime1 == datetime(
+        2024, 1, 15, 10, 30, 0, tzinfo=timezone.utc)
+    assert model.datetime2 == datetime(
+        2024, 1, 15, 10, 30, 0, tzinfo=timezone.utc)
+    assert model.datetime3.year == 2024
+    assert model.datetime3.month == 1
+    assert model.datetime3.day == 15
+    assert model.datetime3.hour == 10
+    assert model.datetime3.minute == 30
+    assert model.datetime3.second == 0
+    assert model.datetime3.microsecond == 123456
+
+
+def test_datetime_parsing_roundtrip_consistency():
+    """Test that datetime parsing maintains consistency through roundtrip conversion"""
+
+    @dataclass
+    class TestModelWithDatetime(VersionedModel):
+        created_at: datetime = field(
+            default_factory=lambda: datetime.now(timezone.utc))
+        updated_at: datetime = field(
+            default_factory=lambda: datetime.now(timezone.utc))
+
+    # Create original model with datetime objects
+    original_created = datetime(2024, 1, 15, 9, 0, 0, tzinfo=timezone.utc)
+    original_updated = datetime(2024, 1, 15, 11, 30, 45, tzinfo=timezone.utc)
+
+    original = TestModelWithDatetime(
+        created_at=original_created,
+        updated_at=original_updated
+    )
+
+    # Convert to dict with ISO strings
+    dict_data = original.as_dict(convert_datetime_to_iso_string=True)
+
+    # Verify datetime fields are converted to ISO strings
+    assert isinstance(dict_data['created_at'], str)
+    assert isinstance(dict_data['updated_at'], str)
+
+    # Convert back from dict (should parse ISO strings back to datetime)
+    restored = TestModelWithDatetime.from_dict(dict_data)
+
+    # Verify datetime objects are correctly restored
+    assert isinstance(restored.created_at, datetime)
+    assert isinstance(restored.updated_at, datetime)
+    assert restored.created_at == original_created
+    assert restored.updated_at == original_updated
+
+
+def test_datetime_parsing_with_other_field_types():
+    """Test that datetime parsing works alongside other field type conversions"""
+    from enum import Enum
+    from typing import Optional
+
+    class Status(Enum):
+        active = "active"
+        inactive = "inactive"
+
+    @dataclass
+    class ComplexModelWithDatetime(VersionedModel):
+        status: Optional[Status] = Status.active
+        created_at: datetime = field(
+            default_factory=lambda: datetime.now(timezone.utc))
+        score: int = 100
+        name: str = "test"
+
+    # Test data with mixed field types including datetime as ISO string
+    test_data = {
+        'entity_id': 'test123',
+        'status': 'inactive',  # Should become enum
+        'created_at': '2024-01-15T09:00:00+00:00',  # Should become datetime
+        'score': 95,  # Should remain int
+        'name': 'test_model'  # Should remain string
+    }
+
+    model = ComplexModelWithDatetime.from_dict(test_data)
+
+    # Verify all field types are correctly converted
+    assert model.status == Status.inactive
+    assert isinstance(model.status, Status)
+
+    assert isinstance(model.created_at, datetime)
+    assert model.created_at == datetime(
+        2024, 1, 15, 9, 0, 0, tzinfo=timezone.utc)
+
+    assert model.score == 95
+    assert isinstance(model.score, int)
+
+    assert model.name == 'test_model'
+    assert isinstance(model.name, str)
+
+
+def test_datetime_parsing_none_values():
+    """Test that None values for datetime fields are handled correctly"""
+    from typing import Optional
+
+    @dataclass
+    class TestModelWithOptionalDatetime(VersionedModel):
+        required_datetime: datetime = field(
+            default_factory=lambda: datetime.now(timezone.utc))
+        optional_datetime: Optional[datetime] = None
+
+    # Test with None values
+    test_data = {
+        'entity_id': 'test123',
+        'required_datetime': '2024-01-15T09:00:00+00:00',
+        'optional_datetime': None
+    }
+
+    model = TestModelWithOptionalDatetime.from_dict(test_data)
+
+    # Required datetime should be parsed from string
+    assert isinstance(model.required_datetime, datetime)
+    assert model.required_datetime == datetime(
+        2024, 1, 15, 9, 0, 0, tzinfo=timezone.utc)
+
+    # Optional datetime should remain None
+    assert model.optional_datetime is None