navigator-session 0.7.0__py3-none-any.whl → 0.8.1__py3-none-any.whl

navigator_session/data.py

@@ -12,6 +12,11 @@ from .conf import (
     SESSION_ID,
     SESSION_STORAGE
 )
+try:
+    from pydantic import BaseModel as PydanticBaseModel
+except ImportError:
+    PydanticBaseModel = None
+
 
 class ModelHandler(jsonpickle.handlers.BaseHandler):
     """ModelHandler.
@@ -30,11 +35,44 @@ class ModelHandler(jsonpickle.handlers.BaseHandler):
 
 jsonpickle.handlers.registry.register(BaseModel, ModelHandler, base=True)
 
+if PydanticBaseModel:
+    class PydanticHandler(jsonpickle.handlers.BaseHandler):
+        """PydanticHandler.
+        This class can handle with serializable Pydantic Models.
+        """
+        def flatten(self, obj, data):
+            data['__dict__'] = self.context.flatten(obj.__dict__, reset=False)
+            return data
+
+        def restore(self, obj):
+            module_and_type = obj['py/object']
+            mdl = loadclass(module_and_type)
+            cls = mdl.__new__(mdl) if hasattr(mdl, '__new__') else object.__new__(mdl)
+            cls.__dict__ = self.context.restore(obj['__dict__'], reset=False)
+            return cls
+
+    jsonpickle.handlers.registry.register(PydanticBaseModel, PydanticHandler, base=True)
+
+
 class SessionData(MutableMapping[str, Any]):
     """Session dict-like object.
+
+    Supports both serializable data (stored in _data and persisted) and
+    in-memory objects (stored in _objects, not persisted).
+
+    Non-serializable objects (class instances, etc.) are automatically
+    stored in _objects when assigned via session.key = value or session['key'] = value.
     """
 
     _data: Union[str, Any] = {}
+    _objects: dict[str, Any] = {}
+
+    # Internal attributes that should not be stored in _data or _objects
+    _internal_attrs = frozenset({
+        '_data', '_objects', '_changed', '_id_', '_identity', '_new',
+        '_max_age', '_now', '__created__', '_created', '_dow', '_doy',
+        '_time', 'args'
+    })
 
     def __init__(
         self,
@@ -45,8 +83,10 @@ class SessionData(MutableMapping[str, Any]):
         identity: Optional[Any] = None,
         max_age: Optional[int] = None
     ) -> None:
-        self._changed = False
-        self._data = {}
+        # Initialize internal storage first (before any attribute access)
+        object.__setattr__(self, '_data', {})
+        object.__setattr__(self, '_objects', {})
+        object.__setattr__(self, '_changed', False)
         # Unique ID:
         self._id_ = (data.get(SESSION_ID, None) if data else id) or uuid.uuid4().hex
         # Session Identity
@@ -75,7 +115,86 @@ class SessionData(MutableMapping[str, Any]):
         self.args = args
 
     def __repr__(self) -> str:
-        return f'<NAV-Session [new:{self.new}, created:{self.created}] {self._data!r}>'
+        return (
+            f'<NAV-Session [new:{self.new}, created:{self.created}] '
+            f'data={self._data!r}, objects={list(self._objects.keys())}>'
+        )
+
+    # --- Serialization helpers ---
+
+    def _is_serializable(self, value: Any) -> bool:
+        """Check if a value can be reliably serialized and restored with jsonpickle.
+
+        Returns True for primitive types, dicts, lists, and known serializable models.
+        Returns False for arbitrary class instances that may not restore properly
+        in a different process/context.
+        """
+        # Primitive types are always serializable
+        if value is None or isinstance(value, (bool, int, float, str, bytes)):
+            return True
+
+        # Dicts and lists need recursive check
+        if isinstance(value, dict):
+            return all(self._is_serializable(v) for v in value.values())
+        if isinstance(value, (list, tuple, set, frozenset)):
+            return all(self._is_serializable(v) for v in value)
+
+        # BaseModel (datamodel) instances are handled by ModelHandler
+        if isinstance(value, BaseModel):
+            return True
+
+        # Pydantic models are handled by PydanticHandler
+        if PydanticBaseModel and isinstance(value, PydanticBaseModel):
+            return True
+
+        # datetime types are serializable
+        if isinstance(value, (datetime,)):
+            return True
+
+        # Any other type (class instances, functions, etc.) is NOT reliably serializable
+        # These should be stored in-memory only
+        return False
+
+    def _get_value(self, key: str) -> Any:
+        """Unified getter that checks both _objects and _data."""
+        if key in self._objects:
+            return self._objects[key]
+        if key in self._data:
+            return self._data[key]
+        raise KeyError(key)
+
+    def _set_value(self, key: str, value: Any) -> None:
+        """Unified setter that routes to _objects or _data based on serializability."""
+        if self._is_serializable(value):
+            # Remove from _objects if it was there before
+            self._objects.pop(key, None)
+            self._data[key] = value
+            self._changed = True
+        else:
+            # Store in _objects (in-memory only, not persisted)
+            # Remove from _data if it was there before
+            self._data.pop(key, None)
+            self._objects[key] = value
+            # Note: _objects changes don't set _changed since they're not persisted
+
+    def _del_value(self, key: str) -> None:
+        """Unified delete that removes from both _objects and _data."""
+        deleted = False
+        if key in self._objects:
+            del self._objects[key]
+            deleted = True
+        if key in self._data:
+            del self._data[key]
+            self._changed = True
+            deleted = True
+        if not deleted:
+            raise KeyError(key)
+
+    def _has_value(self, key: str) -> bool:
+        """Check if key exists in either _objects or _data."""
+        return key in self._objects or key in self._data
+
+    # --- Properties ---
 
     @property
     def new(self) -> bool:
@@ -107,7 +226,7 @@ class SessionData(MutableMapping[str, Any]):
 
     @property
     def empty(self) -> bool:
-        return not bool(self._data)
+        return not bool(self._data) and not bool(self._objects)
 
     @property
     def max_age(self) -> Optional[int]:
@@ -129,36 +248,61 @@ class SessionData(MutableMapping[str, Any]):
         self._changed = True
 
     def session_data(self) -> dict:
+        """Return only serializable data (for persistence)."""
         return self._data
 
+    def session_objects(self) -> dict:
+        """Return in-memory objects (not persisted)."""
+        return self._objects
+
     def invalidate(self) -> None:
+        """Clear all session data and in-memory objects."""
         self._changed = True
         self._data = {}
+        self._objects = {}
+
+    # --- Magic Methods ---
 
-    # Magic Methods
     def __len__(self) -> int:
-        return len(self._data)
+        return len(self._data) + len(self._objects)
 
     def __iter__(self) -> Iterator[str]:
-        return iter(self._data)
+        # Iterate over both _data and _objects keys
+        seen = set()
+        for key in self._data:
+            seen.add(key)
+            yield key
+        for key in self._objects:
+            if key not in seen:
+                yield key
 
     def __contains__(self, key: object) -> bool:
-        return key in self._data
+        return self._has_value(str(key))
 
     def __getitem__(self, key: str) -> Any:
-        return self._data[key]
+        return self._get_value(key)
 
     def __setitem__(self, key: str, value: Any) -> None:
-        self._data[key] = value
-        self._changed = True
-        # TODO: also, saved into redis automatically
+        self._set_value(key, value)
 
     def __delitem__(self, key: str) -> None:
-        del self._data[key]
-        self._changed = True
+        self._del_value(key)
 
     def __getattr__(self, key: str) -> Any:
-        return self._data[key]
+        # Avoid infinite recursion for internal attributes
+        if key.startswith('_'):
+            raise AttributeError(key)
+        try:
+            return self._get_value(key)
+        except KeyError:
+            raise AttributeError(key) from None
+
+    def __setattr__(self, key: str, value: Any) -> None:
+        # Handle internal attributes normally
+        if key in self._internal_attrs or key.startswith('_'):
+            object.__setattr__(self, key, value)
+        else:
+            self._set_value(key, value)
 
     def encode(self, obj: Any) -> str:
         """encode

navigator_session/version.py

@@ -6,8 +6,9 @@ __description__ = (
    'Navigator Session allows us to store user-specific data '
    'into session object.'
 )
-__version__ = '0.7.0'
+__version__ = '0.8.1'
 __copyright__ = 'Copyright (c) 2023 Jesus Lara'
 __author__ = 'Jesus Lara'
 __author_email__ = 'jesuslarag@gmail.com'
 __license__ = 'Apache-2.0'
+__url__ = 'https://github.com/phenobarbital/navigator-session'

{navigator_session-0.7.0.dist-info → navigator_session-0.8.1.dist-info}/METADATA

@@ -1,9 +1,9 @@
 Metadata-Version: 2.4
 Name: navigator-session
-Version: 0.7.0
+Version: 0.8.1
 Summary: Navigator Session allows us to store user-specific data into session object.
 Author-email: Jesus Lara Gimenez <jesuslarag@gmail.com>
-License: Apache 2.0
+License-Expression: Apache-2.0
 Project-URL: Homepage, https://github.com/phenobarbital/navigator-session
 Project-URL: Source, https://github.com/phenobarbital/navigator-session
 Project-URL: Funding, https://paypal.me/phenobarbital
@@ -22,7 +22,6 @@ Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Framework :: AsyncIO
 Classifier: Framework :: aiohttp
-Classifier: License :: OSI Approved :: Apache Software License
 Requires-Python: >=3.9.13
 Description-Content-Type: text/markdown
 License-File: LICENSE

{navigator_session-0.7.0.dist-info → navigator_session-0.8.1.dist-info}/RECORD

@@ -1,15 +1,15 @@
 navigator_session/__init__.py,sha256=U1MtM30ccs5N6c_lzUYFRS5NURz6kheDC8jZmRL_2yc,3056
 navigator_session/conf.py,sha256=Pe8qsukmt5cXXPc3hwFphSWF5xCIpZfeFQ8JhICEnow,1695
-navigator_session/data.py,sha256=z4OULrvzA7Y8x25O7AQBXJ5dywJKxjgkiWGFj6MhKBA,5867
+navigator_session/data.py,sha256=z6W4aCWgcEkSvDynYn4ZeRnjp7gGA0LPWjCe7EyLz-w,11430
 navigator_session/middleware.py,sha256=_bQKfD81BxNZTGuyGTc4yh7y1Rb95I-y2hM1ihE4wCk,1944
 navigator_session/session.py,sha256=CG-TjsmQqjuk6N7GCYNgQTCkrXptgq-swHDiemgHmKI,2398
-navigator_session/version.py,sha256=qR04DpwcmCw55yZJy4MZ_FiZczGhsbOdrn-kRUm91pU,430
+navigator_session/version.py,sha256=DIb5BlRf9IBvfNYoZbYmO-bU4pxDnrZIiij_g8hzUZE,492
 navigator_session/storages/__init__.py,sha256=kTcHfqps5LmnDpFAktxevPuSIwRbnrcMmB7Uygq4axQ,34
 navigator_session/storages/abstract.py,sha256=wTv0yWMVXTwrzA_bjexcwI7c6_W3tzosXlMOIZIQrBM,6503
 navigator_session/storages/cookie.py,sha256=VILzVCatKlDhMoQDoE2y0u6s7lp4wbdep5Oc0NfIJcg,2474
 navigator_session/storages/redis.py,sha256=mqSRyb0YOgV8gvNiAuPhYCLA0fCOgZsQlqOUWE85Gss,11528
-navigator_session-0.7.0.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
-navigator_session-0.7.0.dist-info/METADATA,sha256=khRLMQxXBDBxF5EgC0bfXMJpz4ZPfxlnMh6ocvoxEpA,2412
-navigator_session-0.7.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-navigator_session-0.7.0.dist-info/top_level.txt,sha256=ZpOEy3wLKGsxG2rc0nHqcqJCV3HIOG_XCfE6mtsYYYY,18
-navigator_session-0.7.0.dist-info/RECORD,,
+navigator_session-0.8.1.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+navigator_session-0.8.1.dist-info/METADATA,sha256=48VS8qLDfWasNb0m8qxSZi4pl6Gu035Sbu7sKtpMU6g,2360
+navigator_session-0.8.1.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+navigator_session-0.8.1.dist-info/top_level.txt,sha256=ZpOEy3wLKGsxG2rc0nHqcqJCV3HIOG_XCfE6mtsYYYY,18
+navigator_session-0.8.1.dist-info/RECORD,,

{navigator_session-0.7.0.dist-info → navigator_session-0.8.1.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (80.9.0)
+Generator: setuptools (80.10.2)
 Root-Is-Purelib: true
 Tag: py3-none-any