omnata-plugin-runtime 0.5.0a113__tar.gz → 0.5.2a116__tar.gz

{omnata_plugin_runtime-0.5.0a113 → omnata_plugin_runtime-0.5.2a116}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: omnata-plugin-runtime
-Version: 0.5.0a113
+Version: 0.5.2a116
 Summary: Classes and common runtime components for building and running Omnata Plugins
 Author: James Weakley
 Author-email: james.weakley@omnata.com

{omnata_plugin_runtime-0.5.0a113 → omnata_plugin_runtime-0.5.2a116}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "omnata-plugin-runtime"
-version = "0.5.0-a113"
+version = "0.5.2-a116"
 description = "Classes and common runtime components for building and running Omnata Plugins"
 authors = ["James Weakley <james.weakley@omnata.com>"]
 readme = "README.md"

{omnata_plugin_runtime-0.5.0a113 → omnata_plugin_runtime-0.5.2a116}/src/omnata_plugin_runtime/configuration.py

@@ -8,7 +8,7 @@ from typing import Any, List, Dict, Literal, Union, Optional
 from enum import Enum
 
 from abc import ABC
-from pydantic import BaseModel, Field, PrivateAttr, validator  # pylint: disable=no-name-in-module
+from pydantic import BaseModel, Field, PrivateAttr, SerializationInfo, model_serializer, validator  # pylint: disable=no-name-in-module
 
 if tuple(sys.version_info[:2]) >= (3, 9):
     # Python 3.9 and above
@@ -110,16 +110,18 @@ class OutboundSyncAction(SubscriptableBaseModel, ABC):
                     **STANDARD_OUTBOUND_SYNC_ACTIONS[data["action_name"]]().__dict__,
                 }
         super().__init__(**data)
-
-    def dict(self, *args, trim: bool = True, **kwargs) -> Dict[str, any]:
-        """
-        OutboundSyncStrategy objects can be serialized much smaller if the instance is of a Standard strategy that resides in the
-        Omnata plugin runtime. This method trims out the unneeded attributes in these scenarios.
-        This method also trims the actions for this strategy if it's a custom one.
-
-        """
-        excluded_fields = {} if not trim or self.custom_action else {"description"}
-        return super().dict(exclude=excluded_fields)
+    
+    @model_serializer(mode='wrap')
+    def ser_model(self,handler,info:SerializationInfo) -> Dict[str, Any]:
+        serialized:Dict[str,Any] = handler(self)
+        if not self.custom_action and (info.exclude_none is None or info.exclude_none == False):
+            return {k:v for k,v in serialized.items() if k not in [
+                "description"]}
+        return serialized
+    
+    def model_dump_no_trim(self) -> Dict[str, Any]:
+        # we use our own special include value to signal not to trim
+        return self.model_dump(exclude_none=True)
 
 
 class CreateSyncAction(OutboundSyncAction):
@@ -227,7 +229,7 @@ class OutboundSyncStrategy(SubscriptableBaseModel, ABC):
     action_on_record_unchanged: Optional[OutboundSyncAction] = None
     custom_strategy: bool = True
 
-    def __eq__(self, other):
+    def __eq__(self, other:OutboundSyncStrategy):
         if hasattr(other, 'custom_strategy') and hasattr(other, 'name'):
             return (
                 self.custom_strategy == other.custom_strategy
@@ -251,27 +253,23 @@ class OutboundSyncStrategy(SubscriptableBaseModel, ABC):
                 }
         super().__init__(**data)
 
-    def dict(self, *args, trim: bool = True, **kwargs) -> Dict[str, any]:
-        """
-        OutboundSyncStrategy objects can be serialized much smaller if the instance is of a Standard strategy that resides in the
-        Omnata plugin runtime. This method trims out the unneeded attributes in these scenarios.
-        This method also trims the actions for this strategy if it's a custom one.
-
-        """
-        excluded_fields = (
-            {}
-            if not trim or self.custom_strategy
-            else {
+    @model_serializer(mode='wrap')
+    def ser_model(self,handler,info:SerializationInfo) -> Dict[str, Any]:
+        serialized:Dict[str,Any] = handler(self)
+        if not self.custom_strategy and (info.exclude_none is None or info.exclude_none == False):
+            return {k:v for k,v in serialized.items() if k not in [
                 "description",
                 "icon_source",
                 "action_on_record_create",
                 "action_on_record_update",
                 "action_on_record_delete",
-                "action_on_record_unchanged",
-            }
-        )
-        return super().dict(exclude=excluded_fields)
-
+                "action_on_record_unchanged"]}
+        return serialized
+    
+    def model_dump_no_trim(self) -> Dict[str, Any]:
+        # we use our own special include value to signal not to trim
+        return self.model_dump(exclude_none=True)
+    
 
 class CreateSyncStrategy(OutboundSyncStrategy):
     """

{omnata_plugin_runtime-0.5.0a113 → omnata_plugin_runtime-0.5.2a116}/src/omnata_plugin_runtime/plugin_entrypoints.py

@@ -233,7 +233,7 @@ class PluginEntrypoint:
                     stream_errors=omnata_log_handler.stream_global_errors,
                     total_records_estimate=inbound_sync_request._total_records_estimate
                 )
-                return_dict["final_progress_update"] = final_progress_update.dict()
+                return_dict["final_progress_update"] = final_progress_update.model_dump()
                 if inbound_sync_request.deadline_reached:
                     # if we actually hit the deadline, this is flagged by the cancellation checking worker and the cancellation
                     # token is set. We throw it here as an error since that's currently how it flows back to the engine with a DELAYED state
@@ -305,10 +305,10 @@ class PluginEntrypoint:
         )
         script_result = the_function(parameters)
         if isinstance(script_result, BaseModel):
-            script_result = script_result.dict()
+            script_result = script_result.model_dump()
         elif isinstance(script_result, List):
             if len(script_result) > 0 and isinstance(script_result[0], BaseModel):
-                script_result = [r.dict() for r in script_result]
+                script_result = [r.model_dump() for r in script_result]
         return script_result
         
     def inbound_list_streams(
@@ -341,10 +341,10 @@ class PluginEntrypoint:
 
         script_result = self._plugin_instance.inbound_stream_list(parameters)
         if isinstance(script_result, BaseModel):
-            script_result = script_result.dict()
+            script_result = script_result.model_dump()
         elif isinstance(script_result, List):
             if len(script_result) > 0 and isinstance(script_result[0], BaseModel):
-                script_result = [r.dict() for r in script_result]
+                script_result = [r.model_dump() for r in script_result]
         return script_result
 
 
@@ -365,13 +365,13 @@ class PluginEntrypoint:
             script_result = the_function(stored_value)
             if not isinstance(script_result, FormOption):
                 raise ValueError(f"Expected a FormOption from function {function_name}, got {type(script_result)}")
-            results.append(script_result.dict())
+            results.append(script_result.model_dump())
         return results
 
     def connection_form(self):
         logger.info("Entered connection_form method")
         form: List[ConnectionMethod] = self._plugin_instance.connection_form()
-        return [f.dict() for f in form]
+        return [f.model_dump() for f in form]
 
     def create_billing_events(self, session, event_request: Dict):
         logger.info("Entered create_billing_events method")
@@ -408,7 +408,7 @@ class PluginEntrypoint:
                     logger.warn('Billing event creation failed due to running internally to Omnata')
                 else:
                     raise e
-        return [e.dict() for e in events]
+        return [e.model_dump() for e in events]
 
     def get_secrets(
         self, oauth_secret_name: Optional[str], other_secrets_name: Optional[str]
@@ -461,7 +461,7 @@ class PluginEntrypoint:
         script_result = the_function(parameters)
         if isinstance(script_result, List):
             if len(script_result) > 0 and isinstance(script_result[0], BaseModel):
-                script_result = [r.dict() for r in script_result]
+                script_result = [r.model_dump() for r in script_result]
         else:
             raise ValueError(f"Expected a List from function {function_name}, got {type(script_result)}")
         return script_result
@@ -531,7 +531,7 @@ class PluginEntrypoint:
                 f"alter network rule {network_rule_name} set value_list = ({rule_values_string})"
             ).collect()
 
-        return connect_response.dict()
+        return connect_response.model_dump()
 
     def api_limits(self,
                    method:str,
@@ -564,7 +564,7 @@ class PluginEntrypoint:
         # There's a bit of parsing here that could possibly be done outside of the handler function, but this shouldn't be too expensive
         sync_parameters: Dict[str, StoredConfigurationValue] = TypeAdapter(
             Dict[str, StoredConfigurationValue]).validate_python(sync_parameters)
-        field_mappings: StoredMappingValue = StoredMappingValue.model_validate(field_mappings)
+        field_mappings: StoredMappingValue = TypeAdapter(StoredMappingValue).validate_python(field_mappings)
         return self._plugin_instance.outbound_record_validator(
             sync_parameters, field_mappings, transformed_record, source_types
         )

{omnata_plugin_runtime-0.5.0a113 → omnata_plugin_runtime-0.5.2a116}/src/omnata_plugin_runtime/rate_limiting.py

@@ -178,10 +178,9 @@ class RateLimitState(SubscriptableBaseModel):
         [],
         description="A list of timestamps where previous requests have been made, used to calculate the next request time",
     )
-    
-    _request_timestamps_lock: threading.Lock = PrivateAttr(  # or use Any to annotate the type and use Field to initialize
-        default_factory=lambda: threading.Lock()
-    )
+    # can't set this as a class variable because it's not serializable
+    # TODO: probably shouldn't mix models with functionality like this
+    _request_timestamps_lock: Optional[threading.Lock] = None
 
     @field_serializer('wait_until',when_used='always')
     def serialize_wait_until(self, value:Optional[datetime.datetime]) -> Optional[int]:
@@ -253,6 +252,8 @@ class RateLimitState(SubscriptableBaseModel):
         You only need to use this if your HTTP requests are not automatically being
         registered, which happens if http.client.HTTPConnection is not being used.
         """
+        if self._request_timestamps_lock is None:
+            self._request_timestamps_lock = threading.Lock()
         with self._request_timestamps_lock:
             append_time = datetime.datetime.now(datetime.timezone.utc)
             if self.previous_request_timestamps is None: