python-sdk-remote 0.0.172__tar.gz → 0.0.174__tar.gz

{python_sdk_remote-0.0.172 → python_sdk_remote-0.0.174}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: python-sdk-remote
-Version: 0.0.172
+Version: 0.0.174
 Summary: PyPI Package for Circles Python SDK Local Python
 Home-page: https://github.com/circles-zone/python-sdk-remote-python-package
 Author: Circles
@@ -12,6 +12,7 @@ Requires-Dist: requests
 Requires-Dist: python-dotenv
 Requires-Dist: url-remote
 Requires-Dist: pyjwt
+Requires-Dist: our-object-local
 Dynamic: author
 Dynamic: author-email
 Dynamic: classifier

{python_sdk_remote-0.0.172 → python_sdk_remote-0.0.174}/python_sdk_remote/src/__init__.py

@@ -67,7 +67,10 @@ from .our_objects_local import OurObjectsLocal
 
 # Existing classes
 from .mini_logger import MiniLogger
-from .our_object import OurObject
+# OurObject moved to our-object-local. Imported from there rather than from the
+# deprecated .our_object re-export, so that `import python_sdk_remote` does not
+# emit a deprecation warning for itself on every single import.
+from our_object_local.our_object import OurObject
 from .version import PACKAGE_VERSION
 
 # Constants

{python_sdk_remote-0.0.172 → python_sdk_remote-0.0.174}/python_sdk_remote/src/item.py

@@ -1,6 +1,8 @@
 from abc import abstractmethod
 
-from .our_object import OurObject
+# Straight from the owning package, not through our_object.py: that module is the
+# deprecated path and warns, and this package must not warn about itself.
+from our_object_local.our_object import OurObject
 
 ENTITY_NAME = "item"
 

python_sdk_remote-0.0.174/python_sdk_remote/src/our_object.py

@@ -0,0 +1,56 @@
+"""Backward-compatibility re-export of `OurObject`, which now lives in `our-object-local`.
+
+The class moved to the `our-object-local` package so that anything wanting the
+base business object no longer has to take the whole SDK, and so that
+`our-object-field-local` can sit above `fields-local` without a cycle:
+
+    our-object-field-local -> fields-local -> python-sdk-remote -> our-object-local
+
+`our-object-local` declares no circlez dependencies at all, which is what keeps
+that chain acyclic.
+
+This module is temporary. It exists only so that
+`from python_sdk_remote.our_object import OurObject` - what every consumer
+writes today - keeps working while they migrate: `Contact` (contact-local),
+`Event` (event-local), `FieldLocal` (fields-local), `CalendarLocal`
+(calendar-local), `Item` (in this package), and both `GenericCRUD.foreach()`
+and `HelperMysqlObject` in database-mysql-local.
+
+New code should import from the owning package instead:
+
+    from our_object_local.our_object import OurObject
+
+Reading `OurObject` from here calls `deprecation_warning_function`, so every
+remaining caller shows up in the logs - and therefore in the metrics - with its
+own file name. That is what tells us when this module can be deleted. The
+warning is raised from a module-level `__getattr__` (PEP 562) rather than at
+import time on purpose: at import time the only frame above us is
+`<frozen importlib._bootstrap>`, which names no caller and measures nothing.
+
+Nothing inside this package reads `OurObject` through this module - `item.py`
+and `__init__.py` import it straight from `our_object_local` - so every warning
+counted here comes from a real consumer.
+
+Not to be confused with `OurObjectsLocal` (plural) in `our_objects_local.py`,
+which is an unrelated `GenericCRUD` collection layer that stays in this package.
+"""
+from typing import TYPE_CHECKING, Any
+
+from .utilities import deprecation_warning_function
+
+if TYPE_CHECKING:  # so type checkers still resolve OurObject to the real class
+    from our_object_local.our_object import OurObject
+
+OLD_OUR_OBJECT_IMPORT_PATH = 'python_sdk_remote.our_object.OurObject'
+NEW_OUR_OBJECT_IMPORT_PATH = 'our_object_local.our_object.OurObject'
+
+__all__ = ['OurObject']
+
+
+def __getattr__(name: str) -> Any:
+    if name == 'OurObject':
+        deprecation_warning_function(old_name=OLD_OUR_OBJECT_IMPORT_PATH,
+                                     new_name=NEW_OUR_OBJECT_IMPORT_PATH)
+        from our_object_local.our_object import OurObject as our_object_class
+        return our_object_class
+    raise AttributeError(f"module {__name__!r} has no attribute {name!r}")

{python_sdk_remote-0.0.172 → python_sdk_remote-0.0.174}/python_sdk_remote.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: python-sdk-remote
-Version: 0.0.172
+Version: 0.0.174
 Summary: PyPI Package for Circles Python SDK Local Python
 Home-page: https://github.com/circles-zone/python-sdk-remote-python-package
 Author: Circles
@@ -12,6 +12,7 @@ Requires-Dist: requests
 Requires-Dist: python-dotenv
 Requires-Dist: url-remote
 Requires-Dist: pyjwt
+Requires-Dist: our-object-local
 Dynamic: author
 Dynamic: author-email
 Dynamic: classifier

{python_sdk_remote-0.0.172 → python_sdk_remote-0.0.174}/python_sdk_remote.egg-info/requires.txt

@@ -2,3 +2,4 @@ requests
 python-dotenv
 url-remote
 pyjwt
+our-object-local

{python_sdk_remote-0.0.172 → python_sdk_remote-0.0.174}/setup.py

@@ -7,7 +7,7 @@ package_dir = PACKAGE_NAME.replace("-", "_")
 # python -m build needs pyproject.toml or setup.py
 setuptools.setup(
     name=PACKAGE_NAME,
-    version='0.0.172',  # https://pypi.org/project/python-sdk-remote#history
+    version='0.0.174',  # https://pypi.org/project/python-sdk-remote#history
     author="Circles",
     author_email="info@circlez.ai",
     description="PyPI Package for Circles Python SDK Local Python",
@@ -28,5 +28,9 @@ setuptools.setup(
         "python-dotenv",
         "url-remote",
         "pyjwt",
+        # OurObject lives here now. item.py and __init__.py import it from this
+        # package directly; our_object.py is a temporary deprecated re-export kept
+        # for consumers still on `from python_sdk_remote.our_object import OurObject`.
+        "our-object-local",
     ]
 )

python_sdk_remote-0.0.172/python_sdk_remote/src/our_object.py

@@ -1,174 +0,0 @@
-import json
-from abc import ABC  # , abstractmethod
-from datetime import datetime
-from typing import Any, Optional
-
-from .mini_logger import MiniLogger as logger
-
-from .version import PACKAGE_VERSION
-
-
-"""
-Base class for all business objects in the system.
-
-This class provides common functionality for all entities including:
-- JSON serialization/deserialization
-- Equality comparison
-- String representation
-- Attribute access
-
-Usage: Extend this class for all business entities to ensure consistent behavior.
-"""
-class OurObject(ABC):
-
-    entity_name: Optional[str] = None
-    id: Optional[int] = None
-
-    # Needed by print_our_object_with_id()
-    name: Optional[str] = None
-    number: Optional[int] = None
-
-    fields = {
-        # Needed by print_our_object_with_id()
-        "name",
-        "number"
-    }
-
-    def __init__(self, entity_name: Optional[str] = None,
-                 id: Optional[int] = None, **kwargs: Any):
-        INIT_METHOD_NAME = '__init__'
-        logger.start(INIT_METHOD_NAME, object={'kwargs': kwargs})
-        self.set_entity_name(entity_name)
-        self.set_id(id)
-        self.kwargs = kwargs
-        logger.end(INIT_METHOD_NAME, object={'kwargs': kwargs})
-
-    def __convert_kwargs_to_fields(self, kwargs, fields):
-        """Convert kwargs to object fields based on allowed fields list."""
-        for field, value in kwargs.items():
-            if field in fields:
-                setattr(self, field, value)
-
-    def __convert_fields_to_kwargs(self, fields, kwargs):
-        """
-        Convert fields to kwargs format.
-        
-        Note: This method may be removed in future versions if unused.
-        """
-        for field in fields:
-            if field in kwargs:
-                setattr(self, field, kwargs[field])
-            else:
-                setattr(self, field, None)
-
-    def set_entity_name(self, entity_name: Optional[str]) -> None:
-        self.entity_name = entity_name
-
-    def get_id_column_name(self) -> str:
-        """Returns the name of the column that is used as the id of the object"""
-        # BEHAVIOUR NOTE: was `self.entity_name + "_id"`, which raised
-        # TypeError on the default entity_name of None. Same fix as in
-        # our-object-local, so the two copies stay identical.
-        id_column_name = str(self.entity_name) + "_id"
-        return id_column_name
-
-    def set_id(self, id: Optional[int]) -> None:
-        self.id = id
-
-    def get_id(self) -> Optional[int]:
-        return self.id
-
-    # Commented so we can use it in database foreach()
-    # @abstractmethod
-    def get_name(self) -> Optional[str]:
-        """Returns the name of the object"""
-        # raise NotImplementedError(
-        #     "Subclasses must implement the 'get_name' method.")
-        return None
-
-    def get(self, attr_name: str) -> Any:
-        """Returns the value of the attribute with the given name"""
-        GET_METHOD_NAME = 'get'
-        logger.start(GET_METHOD_NAME, object={'attr_name': attr_name})
-        # BEHAVIOUR NOTE: the getattr default of None was already there, but
-        # .get() was then called on it unconditionally, so any instance built
-        # without __init__ - from_json does exactly that - raised
-        # AttributeError. Same guard as in our-object-local.
-        arguments = getattr(self, 'kwargs', None)
-        value = arguments.get(attr_name, None) if arguments else None
-        logger.end(GET_METHOD_NAME, object={'attr_name': attr_name})
-        return value
-
-    def get_all_arguments(self):
-        """Returns all the arguments passed to the constructor as a dictionary"""
-        get_all_arguments_result = getattr(self, 'kwargs', None)
-        return get_all_arguments_result
-
-    def to_json(self) -> str:
-        """This is backwards compatible with the previous implementation"""
-        to_json_result = self.to_json_str()
-        return to_json_result
-
-    def to_json_dict(self) -> str:
-        """Returns a json string representation of this object"""
-        json_str = self.to_json_str()
-        json_dict = json.loads(json_str)
-
-        return json_dict
-
-    def to_json_str(self) -> str:
-        """Returns a json string representation of this object"""
-        to_json_str_result = json.dumps(self.__dict__, default=self._serialize)
-        return to_json_str_result
-
-    @staticmethod
-    def _serialize(obj):
-        """Custom serialization function for unsupported types. Used by json.dumps"""
-        if isinstance(obj, datetime):
-            return obj.isoformat()  # Converts datetime to ISO 8601 string
-        raise TypeError(f"Type {type(obj)} not serializable")
-
-    def from_json(self, json_string: str) -> 'OurObject':
-        """Returns an instance of the class from a json string"""
-        FROM_JSON_METHOD_NAME = 'from_json'
-        logger.start(FROM_JSON_METHOD_NAME,
-                     object={'json_string': json_string})
-        self.__dict__ = json.loads(json_string)
-        logger.end(FROM_JSON_METHOD_NAME,
-                   object={'json_dict': self.__dict__})
-        return self
-
-    def __eq__(self, other) -> bool:
-        """Checks if two objects are equal"""
-        if not isinstance(other, OurObject):
-            return False
-        eq_result = self.__dict__ == other.__dict__
-        return eq_result
-
-    def __ne__(self, other) -> bool:
-        """Checks if two objects are not equal"""
-        ne_result = not self.__eq__(other)
-        return ne_result
-
-    def __str__(self):
-        str_result = self.entity_name + ": " + str(self.__dict__)
-        return str_result
-
-    def __repr__(self):
-        """String representation for debugging."""
-        # Ensure both entity_name and __dict__ are not None for proper representation
-        entity_name = self.entity_name or "OurObject"
-        dict_str = str(self.__dict__) if self.__dict__ else "{}"
-        repr_result = f"{entity_name}: {dict_str}"
-        return repr_result
-
-    def to_dict(self):
-        return self.__dict__
-
-    def get_package_version(self) -> str:
-        """
-        Get package version.
-        
-        Note: Returns version of python-sdk-remote, not the derived class package.
-        """
-        return PACKAGE_VERSION