omnata-plugin-runtime 0.8.3a204__tar.gz → 0.9.0__tar.gz

{omnata_plugin_runtime-0.8.3a204 → omnata_plugin_runtime-0.9.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: omnata-plugin-runtime
-Version: 0.8.3a204
+Version: 0.9.0
 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.8.3a204 → omnata_plugin_runtime-0.9.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "omnata-plugin-runtime"
-version = "0.8.3-a204"
+version = "0.9.0"
 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.8.3a204 → omnata_plugin_runtime-0.9.0}/src/omnata_plugin_runtime/api.py

@@ -120,6 +120,7 @@ class OutboundSyncRequestPayload(BaseModel):
     results_table_name: str  # used to stage results back to the engine, resides in the main Omnata app database
     logging_level: str
     connection_method: str
+    target_type: Optional[str] = None
     connectivity_option: ConnectivityOption = Field(default=ConnectivityOption.DIRECT)
     connection_parameters: Dict[str, StoredConfigurationValue]
     oauth_secret_name: Optional[str] = None
@@ -166,6 +167,41 @@ SyncRequestPayload = Annotated[
     Field(discriminator="sync_direction"),
 ]
 
+class OutboundConfigurationFormPayload(BaseModel):
+    """
+    Encapsulates the payload that is sent to the plugin when it is invoked to provide a configuration form for an outbound sync.
+    """
+    connectivity_option: ConnectivityOption = Field(default=ConnectivityOption.DIRECT)
+    connection_method: str
+    connection_parameters: Dict[str, StoredConfigurationValue]
+    oauth_secret_name: Optional[str] = None
+    other_secrets_name: Optional[str] = None
+    sync_direction: Literal["outbound"] = "outbound"
+    target_type: Optional[str] = None
+    sync_strategy: OutboundSyncStrategy
+    function_name: str = "outbound_configuration_form"
+    sync_parameters: Dict[str, StoredConfigurationValue]
+    current_form_parameters: Optional[Dict[str, StoredConfigurationValue]]
+
+class InboundConfigurationFormPayload(BaseModel):
+    """
+    Encapsulates the payload that is sent to the plugin when it is invoked to provide a configuration form for an inbound sync.
+    """
+    connectivity_option: ConnectivityOption = Field(default=ConnectivityOption.DIRECT)
+    connection_method: str
+    connection_parameters: Dict[str, StoredConfigurationValue]
+    oauth_secret_name: Optional[str] = None
+    other_secrets_name: Optional[str] = None
+    sync_direction: Literal["inbound"] = "inbound"
+    function_name: str = "inbound_configuration_form"
+    sync_parameters: Dict[str, StoredConfigurationValue]
+    current_form_parameters: Optional[Dict[str, StoredConfigurationValue]]
+
+ConfigurationFormPayload = Annotated[
+    Union[OutboundConfigurationFormPayload, InboundConfigurationFormPayload],
+    Field(discriminator="sync_direction"),
+]
+
 
 def handle_proc_result(query_result: List[Row]) -> Dict:
     """

{omnata_plugin_runtime-0.8.3a204 → omnata_plugin_runtime-0.9.0}/src/omnata_plugin_runtime/configuration.py

@@ -220,6 +220,46 @@ STANDARD_OUTBOUND_SYNC_ACTIONS: Dict[str, OutboundSyncAction] = {
     "Recreate": RecreateSyncAction,
 }
 
+class OutboundTargetParameter(BaseModel):
+    """
+    Accomodates testing outbound syncs in production by nominating a form field who's value stays in the branch.
+    The reason this information is set statically here instead of as a flag on the FormField, is so that the sync engine 
+    can have this information readily available without calling the plugin.
+    """
+    field_name: str = Field(title="""The name of the form field that toggles the location, e.g. 'channel','customer_list'.
+This must match a field which will be returned by the outbound_configuration_form for this target type.""")
+    is_branching_toggle: bool = Field(title="""Whether or not this field is a target toggle for branching.
+If true, the value of this field will be used to determine the location of the sync in production.
+For example, a messaging plugin could have a "channel" field to route messages to an alternate location.
+Or, a marketing platform could have an alternate customer list name which is connected to test campaigns that don't actually send.
+
+This should only be used in situations where all other sync parameters and field mappings can remain consistent between branches.""")
+    label: str = Field(title="""Used in the UI when describing the location., e.g. 'Channel','Customer List'. 
+It should completely describe the behaviour when used in a sentence like this: 
+'Changes will be tested against a different <label> when running in a branch.'""")
+
+class OutboundTargetType(BaseModel):
+    """
+    Some products have APIs that can be grouped together in ways that support different strategies and may or may not support toggling.
+    The label should answer the question: "What would you like to sync to?"
+    Examples:
+    - A CRM system may have "Standard objects", "Custom objects" or "Events"
+    - A messaging platform may have "Channels", "Users" or "Messages"
+    - A marketing platform may have "Customer lists", "Campaigns" or "Automations"
+    - An Ad platform may have "Campaigns", "Ad groups" or "Ads"
+    The target type cannot be changed after the sync is created.
+    """
+    label: str
+    supported_strategies: List[str] = Field(
+        title="The names of the sync strategies supported by this target. Each one must match the name of a sync strategy declared in supported_outbound_strategies."
+    )
+    target_parameter: Optional[OutboundTargetParameter] = Field(
+        default=None,
+        title="""The sync configuration parameter that designates the target object, if applicable. For example, 'object_name' or 'channel_name'. 
+This will be used for two purposes:
+1. To show a more readable indication of what this sync is doing in the UI, e.g. Standard object: Account
+2. Designates this field as serving as a br toggle for testing in production.""")
+
 
 class OutboundSyncStrategy(SubscriptableBaseModel, ABC):
     """OutboundSyncStrategy is a base class for all outbound sync strategies.

{omnata_plugin_runtime-0.8.3a204 → omnata_plugin_runtime-0.9.0}/src/omnata_plugin_runtime/omnata_plugin.py

@@ -74,7 +74,8 @@ from .configuration import (
     SubscriptableBaseModel,
     SyncConfigurationParameters,
     get_secrets,
-    ConnectivityOption
+    ConnectivityOption,
+    OutboundTargetType,
 )
 from .forms import (
     ConnectionMethod,
@@ -112,45 +113,16 @@ class PluginManifest(SubscriptableBaseModel):
     docs_url: str
     supports_inbound: bool
     supported_outbound_strategies: List[OutboundSyncStrategy] = Field(
-        ...,
-        deprecated=True,
-        title="A list of sync strategies that the plugin can support. This has been replaced by OutboundTargetTypes."
+        title="A list of sync strategies that the plugin can support. If outbound_target_types are specified, theses strategies are allocated there. Otherwise, they apply globally"
     )
     supported_connectivity_options: List[ConnectivityOption] = Field(
         default_factory=lambda: [ConnectivityOption.DIRECT]
     )
-    outbound_target_types: List[OutboundTargetType] = Field(
-        ...,
-        title="A list of target types that the plugin can support. This replaces the deprecated 'supported_outbound_strategies'."
+    outbound_target_types: Optional[List[OutboundTargetType]] = Field(
+        default=None,
+        title="An optional list of target types that the plugin can support."
     )
 
-class OutboundTargetType(BaseModel):
-    """
-    Some products have APIs that can be grouped together in ways that support different strategies and may or may not support toggling.
-    The label should answer the question: "What would you like to sync to?"
-    Examples:
-    - A CRM system may have "Standard objects", "Custom objects" or "Events"
-    - A messaging platform may have "Channels", "Users" or "Messages"
-    - A marketing platform may have "Customer lists", "Campaigns" or "Automations"
-    - An Ad platform may have "Campaigns", "Ad groups" or "Ads"
-    The target type cannot be changed after the sync is created.
-    """
-    label: str
-    supported_strategies: List[OutboundSyncStrategy]
-    target_toggle_field: Optional[OutboundTargetToggleField] = None
-
-class OutboundTargetToggleField(BaseModel):
-    """
-    Accomodates testing outbound syncs in production by nominating a form field who's value stays in the branch.
-    For example, a messaging plugin could have a "channel" field to route messages to an alternate location.
-    Or, a marketing platform could have an alternate customer list name which is connected to test campaigns that don't actually send.
-    The field_name must match a field which will be returned by the outbound_configuration_form for this target type.
-    The reason this is set separately here instead of as a flag on the FormField, is so that the sync engine can know
-    whether or not location toggling is supported for a target type without calling the plugin.
-    """
-    field_name: str = Field(..., title="The name of the form field that toggles the location")
-    label: str = Field(..., title="Used in the UI when describing the location. It should completely describe the behaviour when used in a sentence like this: 'Changes will be tested against a different <label> when running in a branch.'")
-
 class SnowflakeFunctionParameter(BaseModel):
     """
     Represents a parameter for a Snowflake UDF or UDTF

{omnata_plugin_runtime-0.8.3a204 → omnata_plugin_runtime-0.9.0}/src/omnata_plugin_runtime/plugin_entrypoints.py

@@ -6,13 +6,13 @@ import os
 import sys
 import time
 import threading
-from typing import Dict, List, Optional
+from typing import Dict, List, Optional, cast
 
 from pydantic import BaseModel,TypeAdapter  # pylint: disable=no-name-in-module
 from pydantic_core import to_jsonable_python
 from snowflake.snowpark import Session
 
-from .api import PluginMessageStreamProgressUpdate, SyncRequestPayload, handle_proc_result
+from .api import PluginMessageStreamProgressUpdate, SyncRequestPayload, ConfigurationFormPayload
 from .configuration import (
     ConnectionConfigurationParameters,
     InboundSyncConfigurationParameters,
@@ -83,7 +83,7 @@ class PluginEntrypoint:
         
 
     def sync(self, sync_request: Dict):
-        request = TypeAdapter(SyncRequestPayload).validate_python(sync_request)
+        request:SyncRequestPayload = TypeAdapter(SyncRequestPayload).validate_python(sync_request)
         logger.add_extra('omnata.operation', 'sync')
         logger.add_extra('omnata.sync.id', request.sync_id)
         logger.add_extra('omnata.sync.direction', request.sync_direction)
@@ -160,6 +160,7 @@ class PluginEntrypoint:
                 connection_secrets=connection_secrets,
                 sync_parameters=request.sync_parameters,
                 current_form_parameters={},
+                target_type=request.target_type,
                 sync_strategy=request.sync_strategy,
                 field_mappings=request.field_mappings,
             )
@@ -289,67 +290,43 @@ class PluginEntrypoint:
         logger.info("Finished applying records")
         return return_dict
 
-    def configuration_form(
-        self,
-        connectivity_option:str,
-        connection_method: str,
-        connection_parameters: Dict,
-        oauth_secret_name: Optional[str],
-        other_secrets_name: Optional[str],
-        sync_direction: str,
-        sync_strategy: Dict,
-        function_name: str,
-        sync_parameters: Dict,
-        current_form_parameters: Optional[Dict],
-    ):
-        if function_name is None:
-            function_name = f"{sync_direction}_configuration_form"
+    def configuration_form(self, configuration_form_request: Dict):
+        request:ConfigurationFormPayload = TypeAdapter(ConfigurationFormPayload).validate_python(configuration_form_request)
         logger.add_extra('omnata.operation', 'configuration_form')
-        logger.add_extra('omnata.connection.connectivity_option', connectivity_option)
-        logger.add_extra('omnata.connection.connection_method', connection_method)
-        logger.add_extra('omnata.configuration_form.function_name', function_name)
-        logger.add_extra('omnata.sync.direction', sync_direction)
+        logger.add_extra('omnata.connection.connectivity_option', request.connectivity_option)
+        logger.add_extra('omnata.connection.connection_method', request.connection_method)
+        logger.add_extra('omnata.configuration_form.function_name', request.function_name)
+        logger.add_extra('omnata.sync.direction', request.sync_direction)
 
         logger.info("Entered configuration_form method")
-        sync_strategy = normalise_nulls(sync_strategy)
-        oauth_secret_name = normalise_nulls(oauth_secret_name)
-        other_secrets_name = normalise_nulls(other_secrets_name)
-        connection_secrets = get_secrets(oauth_secret_name, other_secrets_name)
-        connectivity_option = TypeAdapter(ConnectivityOption).validate_python(connectivity_option)
-        connection_parameters = TypeAdapter(
-            Dict[str, StoredConfigurationValue]).validate_python(connection_parameters)
-        sync_parameters = TypeAdapter(
-            Dict[str, StoredConfigurationValue]).validate_python(sync_parameters)
-        form_parameters = None
-        if current_form_parameters is not None:
-            form_parameters = TypeAdapter(Dict[str, StoredConfigurationValue]).validate_python(current_form_parameters)
-        if sync_direction == "outbound":
-            sync_strat = OutboundSyncStrategy.model_validate(sync_strategy) if sync_strategy is not None else None
+        connection_secrets = get_secrets(request.oauth_secret_name, request.other_secrets_name)
+        if request.sync_direction == "outbound":
             parameters = OutboundSyncConfigurationParameters(
-                connection_parameters=connection_parameters,
+                connection_parameters=request.connection_parameters,
                 connection_secrets=connection_secrets,
-                sync_strategy=sync_strat,
-                sync_parameters=sync_parameters,
-                connection_method=connection_method,
-                connectivity_option=connectivity_option,
-                current_form_parameters=form_parameters,
+                sync_strategy=request.sync_strategy,
+                sync_parameters=request.sync_parameters,
+                connection_method=request.connection_method,
+                connectivity_option=request.connectivity_option,
+                current_form_parameters=request.current_form_parameters,
+                target_type=request.target_type
             )
-        elif sync_direction == "inbound":
+        elif request.sync_direction == "inbound":
             parameters = InboundSyncConfigurationParameters(
-                connection_parameters=connection_parameters,
+                connection_parameters=request.connection_parameters,
                 connection_secrets=connection_secrets,
-                sync_parameters=sync_parameters,
-                connection_method=connection_method,
-                connectivity_option=connectivity_option,
-                current_form_parameters=form_parameters,
+                sync_parameters=request.sync_parameters,
+                connection_method=request.connection_method,
+                connectivity_option=request.connectivity_option,
+                current_form_parameters=request.current_form_parameters,
             )
         else:
-            raise ValueError(f"Unknown direction {sync_direction}")
-        if oauth_secret_name is not None:
-                parameters.access_token_secret_name = oauth_secret_name
+            raise ValueError(f"Unknown direction {request.sync_direction}")
+        if request.oauth_secret_name is not None:
+                parameters.access_token_secret_name = request.oauth_secret_name
         the_function = getattr(
             self._plugin_instance,
-            function_name
+            request.function_name
         )
         with tracer.start_as_current_span("invoke_plugin"):
             script_result = the_function(parameters)
@@ -357,6 +334,7 @@ class PluginEntrypoint:
             script_result = script_result.model_dump()
         elif isinstance(script_result, List):
             if len(script_result) > 0 and isinstance(script_result[0], BaseModel):
+                script_result = cast(List[BaseModel], script_result)
                 script_result = [r.model_dump() for r in script_result]
         return script_result