omnata-plugin-runtime 0.11.6a323__tar.gz → 0.12.0__tar.gz

omnata_plugin_runtime-0.12.0/PKG-INFO

@@ -0,0 +1,56 @@
+Metadata-Version: 2.4
+Name: omnata-plugin-runtime
+Version: 0.12.0
+Summary: Classes and common runtime components for building and running Omnata Plugins
+License-File: LICENSE
+Author: James Weakley
+Author-email: james.weakley@omnata.com
+Requires-Python: >=3.10,<=3.13
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Requires-Dist: annotated-types (<=0.6.0)
+Requires-Dist: certifi (<=2025.11.12)
+Requires-Dist: cffi (<=2.0.0)
+Requires-Dist: charset-normalizer (<=3.4.4)
+Requires-Dist: cryptography (<=46.0.3)
+Requires-Dist: filelock (<=3.20.0)
+Requires-Dist: idna (<=3.11)
+Requires-Dist: jinja2 (>=3.1.2,<=3.1.6)
+Requires-Dist: markupsafe (<=3.0.2)
+Requires-Dist: numpy (<=2.3.5)
+Requires-Dist: opentelemetry-api (<=1.38.0)
+Requires-Dist: packaging (<=25.0)
+Requires-Dist: pandas (<=2.3.3)
+Requires-Dist: platformdirs (<=4.5.0)
+Requires-Dist: protobuf (<=6.33.0)
+Requires-Dist: pyarrow (<=21.0.0)
+Requires-Dist: pycparser (<=2.23)
+Requires-Dist: pydantic (>=2,<=2.12.4)
+Requires-Dist: pydantic-core (<=2.41.5)
+Requires-Dist: pyjwt (<=2.10.1)
+Requires-Dist: pyopenssl (<=225.3.0)
+Requires-Dist: pytz (<=2025.2)
+Requires-Dist: pyyaml (<=6.0.3)
+Requires-Dist: requests (>=2,<=2.32.5)
+Requires-Dist: setuptools (<=80.9.0)
+Requires-Dist: snowflake-connector-python (>=3,<4)
+Requires-Dist: snowflake-snowpark-python (>=1.20.0,<=1.43.0)
+Requires-Dist: snowflake-telemetry-python (<=0.5.0)
+Requires-Dist: tenacity (>=8,<9)
+Requires-Dist: tomlkit (<=0.13.3)
+Requires-Dist: urllib3 (<=2.5.0)
+Requires-Dist: wheel (<=0.45.1)
+Requires-Dist: wrapt (<=2.0.1)
+Description-Content-Type: text/markdown
+
+# omnata-plugin-runtime
+This package is a runtime dependency for [Omnata Plugins](https://docs.omnata.com/omnata-product-documentation/omnata-sync-for-snowflake/plugins).
+
+It contains data classes, interfaces and application logic used to perform plugin operations.
+
+For instructions on creating plugins, visit our [docs site](https://docs.omnata.com/omnata-product-documentation/omnata-sync-for-snowflake/plugins/creating-plugins).
+
+

omnata_plugin_runtime-0.12.0/pyproject.toml

@@ -0,0 +1,57 @@
+[tool.poetry]
+name = "omnata-plugin-runtime"
+version = "0.12.0"
+description = "Classes and common runtime components for building and running Omnata Plugins"
+authors = ["James Weakley <james.weakley@omnata.com>"]
+readme = "README.md"
+packages = [{include = "omnata_plugin_runtime", from = "src"}]
+
+[tool.poetry.dependencies]
+python = ">=3.10, <=3.13"
+snowflake-snowpark-python = ">=1.20.0,<=1.43.0" # latest version available on Snowflake Anaconda, but allow pinning to 1.20.0 for to_pandas_batches workaround
+snowflake-connector-python = "^3, <=4.1.0" # latest version available on Snowflake Anaconda
+cryptography = "<=46.0.3"
+annotated-types	= "<=0.6.0"
+pycparser = "<=2.23"
+filelock = "<=3.20.0"
+pydantic-core = "<=2.41.5"
+# had to relax some of these thanks to snowcli pinning newer versions
+certifi	= "<=2025.11.12" # latest version available on Snowflake Anaconda
+charset-normalizer = "<=3.4.4" # latest version available on Snowflake Anaconda
+idna = "<=3.11" # latest version available on Snowflake Anaconda
+jinja2 = ">=3.1.2,<=3.1.6" # 3.1.6 was latest version available on Snowflake Anaconda
+markupsafe = "<=3.0.2" # latest version available on Snowflake Anaconda
+numpy = "<=2.3.5" # latest version available on Snowflake Anaconda
+packaging = "<=25.0" # latest version available on Snowflake Anaconda
+pandas = "<=2.3.3" # latest version available on Snowflake Anaconda
+platformdirs = "<=4.5.0" # latest version available on Snowflake Anaconda
+pydantic = "^2, <=2.12.4" # latest version available on Snowflake Anaconda
+pyjwt = "<=2.10.1" # latest version available on Snowflake Anaconda
+pyopenssl = "<=225.3.0" # latest version available on Snowflake Anaconda
+pytz = "<=2025.2" # latest version available on Snowflake Anaconda
+requests = "^2, <=2.32.5" # latest version available on Snowflake Anaconda
+setuptools = "<=80.9.0" # latest version available on Snowflake Anaconda
+tomlkit = "<=0.13.3" # latest version available on Snowflake Anaconda
+tenacity = "^8, <=9.1.2" # latest version available on Snowflake Anaconda
+urllib3 = "<=2.5.0" # latest version available on Snowflake Anaconda
+wheel = "<=0.45.1" # latest version available on Snowflake Anaconda
+pyyaml = "<=6.0.3" # latest version available on Snowflake Anaconda
+cffi = "<=2.0.0" # latest version available on Snowflake Anaconda
+pyarrow = "<=21.0.0" # latest version available on Snowflake Anaconda
+wrapt = "<=2.0.1" # latest version available on Snowflake Anaconda
+opentelemetry-api = "<=1.38.0" # latest version available on Snowflake Anaconda
+snowflake-telemetry-python = "<=0.5.0" # latest version available on Snowflake Anaconda
+protobuf = "<=6.33.0" # latest version available on Snowflake Anaconda
+
+[tool.poetry.dev-dependencies]
+pytest = "^6.2.4"
+deepdiff = "^6"
+requests-mock = ">=1.9.3"
+
+[tool.pytest.ini_options]
+addopts = ["--import-mode=importlib"]
+testpaths = ["tests"]
+
+[build-system]
+requires = ["poetry-core"]
+build-backend = "poetry.core.masonry.api"

{omnata_plugin_runtime-0.11.6a323 → omnata_plugin_runtime-0.12.0}/src/omnata_plugin_runtime/omnata_plugin.py

@@ -15,7 +15,7 @@ if tuple(sys.version_info[:2]) >= (3, 9):
 else:
     # Python 3.8 and below
     from typing_extensions import Annotated
-
+from dataclasses import dataclass
 import zipfile
 import datetime
 import http
@@ -49,6 +49,11 @@ from snowflake.snowpark.functions import col
 from tenacity import Retrying, stop_after_attempt, wait_fixed, retry_if_exception_message
 
 from .logging import OmnataPluginLogHandler, logger, tracer, meter
+stream_duration_gauge = meter.create_gauge(
+    name="omnata.sync_run.stream_duration",
+    description="The duration of stream processing",
+    unit="s",
+)
 from opentelemetry import context
 import math
 import numpy as np
@@ -265,6 +270,29 @@ def jinja_filter(func):
     func.is_jinja_filter = True
     return func
 
+@dataclass
+class StateResult:
+    """
+    Represents the current cursor state of a stream. This simple wrapper just helps us identify what type of
+    object is in the apply_results list.
+    """
+    new_state: Any
+
+@dataclass
+class RecordsToUploadResult:
+    """
+    Represents the records to upload for a stream. This simple wrapper just helps us identify what type of
+    object is in the apply_results list.
+    """
+    records: pandas.DataFrame
+
+@dataclass
+class CriteriaDeleteResult:
+    """
+    Represents the result of processing criteria deletes for a stream. This simple wrapper just helps us identify what type of
+    object is in the apply_results list.
+    """
+    criteria_deletes: pandas.DataFrame
 
 class SyncRequest(ABC):
     """
@@ -1057,7 +1085,6 @@ class InboundSyncRequest(SyncRequest):
         }
         
         # These are similar to the results, but represent requests to delete records by some criteria
-        self._apply_results_criteria_deletes: Dict[str, List[pandas.DataFrame]] = {}
         self._temp_tables = {}
         self._temp_table_lock = threading.Lock()
         self._results_exist: Dict[
@@ -1096,7 +1123,9 @@ class InboundSyncRequest(SyncRequest):
         self._criteria_deletes_table_name = results_table.get_fully_qualified_criteria_deletes_table_name()
         self.state_register_table_name = results_table.get_fully_qualified_state_register_table_name()
         # this is keyed on stream name, each containing a list of dataframes and state updates mixed
-        self._apply_results: Dict[str, List[pandas.DataFrame | Dict]] = {}
+        self._apply_results: Dict[str, List[RecordsToUploadResult | StateResult | CriteriaDeleteResult]] = {}
+        # track the start times of each stream, so we can calculate durations. The int is a epoch (time.time()) value
+        self._stream_start_times: Dict[str, int] = {}
 
     def apply_results_queue(self):
         """
@@ -1105,7 +1134,8 @@ class InboundSyncRequest(SyncRequest):
         logger.debug("InboundSyncRequest apply_results_queue")
         if self._apply_results is not None:
             with self._apply_results_lock:
-                results:List[pandas.DataFrame] = []
+                records_to_upload:List[pandas.DataFrame] = []
+                criteria_deletes_to_upload:List[pandas.DataFrame] = []
                 stream_states_for_upload:Dict[str, Dict[str, Any]] = {}
                 for stream_name, stream_results in self._apply_results.items():
                     # the stream results contains an ordered sequence of dataframes and state updates (append only)
@@ -1113,9 +1143,9 @@ class InboundSyncRequest(SyncRequest):
                     # so first, we iterate backwards to find the last state update
                     last_state_index = -1
                     for i in range(len(stream_results) - 1, -1, -1):
-                        if isinstance(stream_results[i], dict):
+                        if isinstance(stream_results[i], StateResult):
                             last_state_index = i
-                            stream_states_for_upload[stream_name] = stream_results[i]
+                            stream_states_for_upload[stream_name] = stream_results[i].new_state
                             break
                     # if there are no state updates, we can't do anything with this stream
                     if last_state_index == -1:
@@ -1124,56 +1154,54 @@ class InboundSyncRequest(SyncRequest):
                         )
                         continue
                     assert isinstance(stream_states_for_upload[stream_name], dict), "Latest state must be a dictionary"
-                    # now we can take the dataframes up to the last state update
-                    dfs = stream_results[:last_state_index]
-                    non_empty_dfs = [
-                        x for x in dfs if x is not None and isinstance(x, pandas.DataFrame) and len(x) > 0
+                    # now we can take the record dataframes up to the last state update
+                    results_subset = stream_results[:last_state_index]
+                    non_empty_record_dfs:List[pandas.DataFrame] = [
+                        x.records for x in results_subset 
+                        if x is not None and isinstance(x, RecordsToUploadResult) and len(x.records) > 0
                     ]
                     # get the total length of all the dataframes
-                    total_length = sum([len(x) for x in non_empty_dfs])
+                    total_length = sum([len(x) for x in non_empty_record_dfs])
                     # add the count of this batch to the total for this stream
                     self._stream_record_counts[
                         stream_name
                     ] = self._stream_record_counts[stream_name] + total_length
-                    results.extend(non_empty_dfs)
+                    records_to_upload.extend(non_empty_record_dfs)
+                    # also handle any criteria deletes
+                    criteria_deletes_to_upload.extend([
+                        x.criteria_deletes for x in results_subset
+                        if x is not None and isinstance(x, CriteriaDeleteResult) and len(x.criteria_deletes) > 0
+                    ])
                     # now remove everything up to the last state update
                     # we do this so that we don't apply the same state update multiple times
+                    # keep everything after the last state update
                     self._apply_results[stream_name] = stream_results[
                         last_state_index + 1 :
-                    ]  # keep everything after the last state update
-                if len(results) > 0:
-                    logger.debug(
-                        f"Applying {len(results)} batches of queued results"
-                    )
-                    # upload all cached apply results
-                    all_dfs = pandas.concat(results)
-                    query_id = self._apply_results_dataframe(list(stream_states_for_upload.keys()), all_dfs)
-                    # now that the results have been updated, we need to insert records into the state register table
-                    # we do this by inserting the latest state for each stream
+                    ]
+                
+                if len(records_to_upload) > 0 or len(criteria_deletes_to_upload) > 0:
+                    if len(records_to_upload) > 0:
+                        logger.debug(
+                            f"Applying {len(records_to_upload)} batches of queued results"
+                        )
+                        # upload all cached apply results
+                        records_to_upload_combined = pandas.concat(records_to_upload)
+                        self._apply_results_dataframe(list(stream_states_for_upload.keys()), records_to_upload_combined)
+                        # now that the results have been updated, we need to insert records into the state register table
+                        # we do this by inserting the latest state for each stream
+                    if len(criteria_deletes_to_upload) > 0:
+                        logger.debug(
+                            f"Applying {len(criteria_deletes_to_upload)} batches of queued criteria deletes"
+                        )
+                        # upload all cached apply results
+                        all_criteria_deletes = pandas.concat(criteria_deletes_to_upload)
+                        self._apply_criteria_deletes_dataframe(all_criteria_deletes)
+                    
+                    query_id = self._get_query_id_for_now()
                     self._directly_insert_to_state_register(
                         stream_states_for_upload, query_id=query_id
                     )
         
-        # also take care of uploading delete requests
-        # technically these should be managed along with the state, however there aren't any scenarios where checkpointing is done
-        # and deletes have an impact. This is because we only checkpoint in scenarios where the target table is empty first
-        if hasattr(self,'_apply_results_criteria_deletes') and self._apply_results_criteria_deletes is not None:
-            with self._apply_results_lock:
-                results:List[pandas.DataFrame] = []
-                for stream_name, stream_results in self._apply_results_criteria_deletes.items():
-                    results.extend([
-                        x for x in stream_results if x is not None and len(x) > 0
-                    ])
-                if len(results) > 0:
-                    logger.debug(
-                        f"Applying {len(results)} batches of queued criteria deletes"
-                    )
-                    # upload all cached apply results
-                    all_dfs = pandas.concat(results)
-                    self._apply_criteria_deletes_dataframe(all_dfs)
-                    # clear the delete requests
-                    self._apply_results_criteria_deletes = {}
-        
 
         # update the inbound stream record counts, so we can see progress
         # we do this last, because marking a stream as completed will cause the sync engine to process it
@@ -1281,29 +1309,40 @@ class InboundSyncRequest(SyncRequest):
         if stream_name is None or len(stream_name) == 0:
             raise ValueError("Stream name cannot be empty")
         with self._apply_results_lock:
-            existing_results: List[pandas.DataFrame] = []
+            existing_results: List[RecordsToUploadResult | StateResult | CriteriaDeleteResult] = []
             if stream_name in self._apply_results:
                 existing_results = self._apply_results[stream_name]
-            existing_results.append(self._preprocess_results_list(stream_name, results, is_delete))
+            existing_results.append(RecordsToUploadResult(
+                records=self._preprocess_results_list(stream_name, results, is_delete)
+            ))
             if new_state is not None:
-                existing_results.append(new_state)  # append the new state at the end
+                existing_results.append(
+                    StateResult(new_state=new_state)
+                )  # append the new state at the end
             self._apply_results[stream_name] = existing_results
-        # if the total size of all the dataframes exceeds 200MB, apply the results immediately
-        # we'll use df.memory_usage(index=True) for this
         if self.development_mode is False:
             # note: we want to do it for all values in self._apply_results, not just the new one
-            # so first we need to get the list of lists from the dictionary values and flatten it
-            # then we can sum the memory usage of each dataframe
-            # if the total exceeds 200MB, we apply the results immediately
-            all_df_lists:List[List[pandas.DataFrame]] = list(self._apply_results.values())
-            # flatten
-            all_dfs:List[pandas.DataFrame] = [x for sublist in all_df_lists for x in sublist if isinstance(x, pandas.DataFrame)]
-            combined_length = sum([len(x) for x in all_dfs])
-            # first, don't bother if the count is less than 10000, since it's unlikely to be even close
-            if combined_length > 10000:
-                if sum([x.memory_usage(index=True).sum() for x in all_dfs]) > 200000000:
-                    logger.debug(f"Applying results queue immediately due to combined dataframe size")
-                    self.apply_results_queue()
+            self._apply_results_if_size_exceeded()
+    
+    def _apply_results_if_size_exceeded(self,):
+        # so first we need to get the list of lists from the dictionary values and flatten it
+        # then we can sum the memory usage of each dataframe
+        # if the total exceeds 200MB, we apply the results immediately
+        all_df_lists:List[List[RecordsToUploadResult | StateResult | CriteriaDeleteResult]] = list(self._apply_results.values())
+        # flatten
+        all_dfs:List[pandas.DataFrame] = []
+        for sublist in all_df_lists:
+            for x in sublist:
+                if isinstance(x, RecordsToUploadResult):
+                    all_dfs.append(x.records)
+                if isinstance(x, CriteriaDeleteResult):
+                    all_dfs.append(x.criteria_deletes)
+        combined_length = sum([len(x) for x in all_dfs])
+        # first, don't bother if the count is less than 10000, since it's unlikely to be even close
+        if combined_length > 10000:
+            if sum([x.memory_usage(index=True).sum() for x in all_dfs]) > 200000000:
+                logger.debug(f"Applying results queue immediately due to combined dataframe size")
+                self.apply_results_queue()
     
     def delete_by_criteria(self, stream_name: str, criteria: Dict[str, Any]):
         """
@@ -1329,27 +1368,22 @@ class InboundSyncRequest(SyncRequest):
             logger.debug(
                 f"Enqueuing {len(criteria)} delete criteria for stream {stream_name} for upload"
             )
-            existing_results: List[pandas.DataFrame] = []
-            if stream_name in self._apply_results_criteria_deletes:
-                existing_results = self._apply_results_criteria_deletes[stream_name]
-            existing_results.append(pandas.DataFrame([{"STREAM_NAME":stream_name,"DELETE_CRITERIA": criteria}]))
-            self._apply_results_criteria_deletes[stream_name] = existing_results
-        # if the total size of all the dataframes exceeds 200MB, apply the results immediately
-        # we'll use df.memory_usage(index=True) for this
+            existing_results: List[RecordsToUploadResult | StateResult | CriteriaDeleteResult] = []
+            if stream_name in self._apply_results:
+                existing_results = self._apply_results[stream_name]
+            existing_results.append(
+                CriteriaDeleteResult(
+                    criteria_deletes=pandas.DataFrame([{"STREAM_NAME":stream_name,"DELETE_CRITERIA": criteria}])))
+            self._apply_results[stream_name] = existing_results
         if self.development_mode is False:
-            # note: we want to do it for all values in self._apply_results_criteria_deletes, not just the new one
-            # so first we need to get the list of lists from the dictionary values and flatten it
-            # then we can sum the memory usage of each dataframe
-            # if the total exceeds 200MB, we apply the results immediately
-            all_df_lists:List[List[pandas.DataFrame]] = list(self._apply_results_criteria_deletes.values())
-            # flatten
-            all_dfs:List[pandas.DataFrame] = [x for sublist in all_df_lists for x in sublist]
-            combined_length = sum([len(x) for x in all_dfs])
-            # first, don't both if the count is less than 10000, since it's unlikely to be even close
-            if combined_length > 10000:
-                if sum([x.memory_usage(index=True).sum() for x in all_dfs if isinstance(x, pandas.DataFrame)]) > 200000000:
-                    logger.debug(f"Applying criteria deletes queue immediately due to combined dataframe size")
-                    self.apply_results_queue() 
+            self._apply_results_if_size_exceeded()
+    
+    def mark_stream_started(self, stream_name: str):
+        """
+        Marks a stream as started, this is called automatically per stream when using @managed_inbound_processing.
+        """
+        logger.debug(f"Marking stream {stream_name} as started locally")
+        self._stream_start_times[stream_name] = time.time()
 
     def mark_stream_complete(self, stream_name: str):
         """
@@ -1357,6 +1391,20 @@ class InboundSyncRequest(SyncRequest):
         If @managed_inbound_processing is not used, call this whenever a stream has finished recieving records.
         """
         logger.debug(f"Marking stream {stream_name} as completed locally")
+        if stream_name in self._stream_start_times:
+            start_time = self._stream_start_times[stream_name]
+            duration = time.time() - start_time
+            stream_duration_gauge.set(
+                amount=duration,
+                attributes={
+                    "stream_name": stream_name,
+                    "sync_run_id": str(self._run_id),
+                    "sync_id": str(self._sync_id),
+                    "branch_name": str(self._branch_name) if self._branch_name is not None else 'main',
+                    "sync_direction": "inbound",
+                    "plugin_id": self.plugin_instance.get_manifest().plugin_id,
+                },
+            )
         with self._apply_results_lock:
             self._completed_streams.append(stream_name)
             # dedup just in case it's called twice
@@ -1463,7 +1511,7 @@ class InboundSyncRequest(SyncRequest):
             logger.debug(f"Failure to convert inbound data: {str(exception)}")
         return data
 
-    def _preprocess_results_list(self, stream_name: str, results: List[Dict],is_delete:Union[bool,List[bool]]):
+    def _preprocess_results_list(self, stream_name: str, results: List[Dict],is_delete:Union[bool,List[bool]]) -> pandas.DataFrame:
         """
         Creates a dataframe from the enqueued list, ready to upload.
         The result is a dataframe contain all (and only):
@@ -1608,7 +1656,7 @@ class InboundSyncRequest(SyncRequest):
         hash_object = hashlib.sha256(key_string.encode())
         return hash_object.hexdigest()
 
-    def _apply_results_dataframe(self, stream_names: List[str], results_df: pandas.DataFrame) -> Optional[str]:
+    def _apply_results_dataframe(self, stream_names: List[str], results_df: pandas.DataFrame):
         """
         Applies results for an inbound sync. The results are staged into a temporary
         table in Snowflake, so that we can make an atomic commit at the end.
@@ -1635,7 +1683,6 @@ class InboundSyncRequest(SyncRequest):
                                 raise ValueError(
                                     f"Failed to write results to table {self._full_results_table_name}"
                                 )
-                            query_id = self._get_query_id_for_now()
                             logger.debug(
                                 f"Wrote {nrows} rows and {nchunks} chunks to table {self._full_results_table_name}"
                             )
@@ -1648,7 +1695,6 @@ class InboundSyncRequest(SyncRequest):
                             #                                )
                             for stream_name in stream_names:
                                 self._results_exist[stream_name] = True
-                            return query_id
         else:
             logger.debug("Results dataframe is empty, not applying")
 
@@ -2333,12 +2379,8 @@ def __managed_inbound_processing_worker(
             sync_request: InboundSyncRequest = cast(
                 InboundSyncRequest, plugin_class_obj._sync_request
             )  # pylint: disable=protected-access
-            stream_duration_counter = meter.create_histogram(
-                name="omnata.sync_run.stream_duration",
-                description="The duration of stream processing",
-                unit="s",
-            )
-            start_time = time.time()
+            if stream.stream_name not in sync_request._stream_start_times:
+                sync_request.mark_stream_started(stream.stream_name)
             # restore the first argument, was originally the dataframe/generator but now it's the appropriately sized dataframe
             try:
                 with tracer.start_as_current_span("managed_inbound_processing") as managed_inbound_processing_span:
@@ -2370,19 +2412,6 @@ def __managed_inbound_processing_worker(
                     omnata_plugin_logger.error(f"{type(e).__name__} syncing stream {stream.stream_name}", 
                                 exc_info=True, 
                                 extra={'stream_name':stream.stream_name})
-            finally:
-                duration = time.time() - start_time
-                stream_duration_counter.record(
-                    duration,
-                    attributes={
-                        "stream_name": stream.stream_name,
-                        "sync_run_id": str(sync_request._run_id),
-                        "sync_id": str(sync_request._sync_id),
-                        "branch_name": str(sync_request._branch_name) if sync_request._branch_name is not None else 'main',
-                        "sync_direction": "inbound",
-                        "plugin_id": plugin_class_obj.get_manifest().plugin_id,
-                    },
-                )
         except queue.Empty:
             logger.debug("streams queue is empty")
             return

omnata_plugin_runtime-0.11.6a323/PKG-INFO

@@ -1,55 +0,0 @@
-Metadata-Version: 2.4
-Name: omnata-plugin-runtime
-Version: 0.11.6a323
-Summary: Classes and common runtime components for building and running Omnata Plugins
-License-File: LICENSE
-Author: James Weakley
-Author-email: james.weakley@omnata.com
-Requires-Python: >=3.9,<=3.11
-Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.9
-Classifier: Programming Language :: Python :: 3.10
-Classifier: Programming Language :: Python :: 3.11
-Requires-Dist: annotated-types (<=0.6.0)
-Requires-Dist: certifi (<=2024.8.30)
-Requires-Dist: cffi (<=1.16.0)
-Requires-Dist: charset-normalizer (<=3.3.2)
-Requires-Dist: cryptography (<=43.0.0)
-Requires-Dist: filelock (<=3.13.1)
-Requires-Dist: idna (<=3.7)
-Requires-Dist: jinja2 (>=3.1.2,<=3.1.4)
-Requires-Dist: markupsafe (<=2.1.3)
-Requires-Dist: numpy (<=2.1.3)
-Requires-Dist: opentelemetry-api (<=1.23.0)
-Requires-Dist: packaging (<=24.1)
-Requires-Dist: pandas (<=2.2.3)
-Requires-Dist: platformdirs (<=3.10.0)
-Requires-Dist: protobuf (<=4.25.3)
-Requires-Dist: pyarrow (<=16.1.0)
-Requires-Dist: pycparser (<=2.21)
-Requires-Dist: pydantic (>=2,<=2.8.2)
-Requires-Dist: pydantic-core (<=2.21.0)
-Requires-Dist: pyjwt (<=2.8.0)
-Requires-Dist: pyopenssl (<=24.2.1)
-Requires-Dist: pytz (<=2024.1)
-Requires-Dist: pyyaml (<=6.0.1)
-Requires-Dist: requests (>=2,<=2.32.3)
-Requires-Dist: setuptools (<=72.1.0)
-Requires-Dist: snowflake-connector-python (>=3,<=3.12.0)
-Requires-Dist: snowflake-snowpark-python (>=1.20.0,<=1.24.0)
-Requires-Dist: snowflake-telemetry-python (<=0.5.0)
-Requires-Dist: tenacity (>=8,<=8.2.3)
-Requires-Dist: tomlkit (<=0.11.1)
-Requires-Dist: urllib3 (<=2.2.2)
-Requires-Dist: wheel (<=0.43.0)
-Requires-Dist: wrapt (<=1.14.1)
-Description-Content-Type: text/markdown
-
-# omnata-plugin-runtime
-This package is a runtime dependency for [Omnata Plugins](https://docs.omnata.com/omnata-product-documentation/omnata-sync-for-snowflake/plugins).
-
-It contains data classes, interfaces and application logic used to perform plugin operations.
-
-For instructions on creating plugins, visit our [docs site](https://docs.omnata.com/omnata-product-documentation/omnata-sync-for-snowflake/plugins/creating-plugins).
-
-

omnata_plugin_runtime-0.11.6a323/pyproject.toml

@@ -1,57 +0,0 @@
-[tool.poetry]
-name = "omnata-plugin-runtime"
-version = "0.11.6-a323"
-description = "Classes and common runtime components for building and running Omnata Plugins"
-authors = ["James Weakley <james.weakley@omnata.com>"]
-readme = "README.md"
-packages = [{include = "omnata_plugin_runtime", from = "src"}]
-
-[tool.poetry.dependencies]
-python = ">=3.9, <=3.11"
-snowflake-snowpark-python = ">=1.20.0,<=1.24.0" # latest version available on Snowflake Anaconda, but allow pinning to 1.20.0 for to_pandas_batches workaround
-snowflake-connector-python = "^3, <=3.12.0" # latest version available on Snowflake Anaconda
-cryptography = "<=43.0.0"
-annotated-types	= "<=0.6.0"
-pycparser = "<=2.21"
-filelock = "<=3.13.1"
-pydantic-core = "<=2.21.0"
-# had to relax some of these thanks to snowcli pinning newer versions
-certifi	= "<=2024.8.30" # latest version available on Snowflake Anaconda
-charset-normalizer = "<=3.3.2" # latest version available on Snowflake Anaconda
-idna = "<=3.7" # latest version available on Snowflake Anaconda
-jinja2 = ">=3.1.2,<=3.1.4" # 3.1.4 was latest version available on Snowflake Anaconda
-markupsafe = "<=2.1.3" # latest version available on Snowflake Anaconda
-numpy = "<=2.1.3" # latest version available on Snowflake Anaconda
-packaging = "<=24.1" # latest version available on Snowflake Anaconda
-pandas = "<=2.2.3" # latest version available on Snowflake Anaconda
-platformdirs = "<=3.10.0" # latest version available on Snowflake Anaconda
-pydantic = "^2, <=2.8.2" # latest version available on Snowflake Anaconda
-pyjwt = "<=2.8.0" # latest version available on Snowflake Anaconda
-pyopenssl = "<=24.2.1" # latest version available on Snowflake Anaconda
-pytz = "<=2024.1" # latest version available on Snowflake Anaconda
-requests = "^2, <=2.32.3" # latest version available on Snowflake Anaconda
-setuptools = "<=72.1.0" # latest version available on Snowflake Anaconda
-tomlkit = "<=0.11.1" # latest version available on Snowflake Anaconda
-tenacity = "^8, <=8.2.3" # latest version available on Snowflake Anaconda
-urllib3 = "<=2.2.2" # latest version available on Snowflake Anaconda
-wheel = "<=0.43.0" # latest version available on Snowflake Anaconda
-pyyaml = "<=6.0.1" # latest version available on Snowflake Anaconda
-cffi = "<=1.16.0" # latest version available on Snowflake Anaconda
-pyarrow = "<=16.1.0" # latest version available on Snowflake Anaconda
-wrapt = "<=1.14.1" # latest version available on Snowflake Anaconda
-opentelemetry-api = "<=1.23.0" # latest version available on Snowflake Anaconda
-snowflake-telemetry-python = "<=0.5.0" # latest version available on Snowflake Anaconda
-protobuf = "<=4.25.3" # latest version available on Snowflake Anaconda
-
-[tool.poetry.dev-dependencies]
-pytest = "^6.2.4"
-deepdiff = "^6"
-requests-mock = ">=1.9.3"
-
-[tool.pytest.ini_options]
-addopts = ["--import-mode=importlib"]
-testpaths = ["tests"]
-
-[build-system]
-requires = ["poetry-core"]
-build-backend = "poetry.core.masonry.api"