omnata-plugin-runtime 0.5.9a160__tar.gz → 0.5.10__tar.gz

{omnata_plugin_runtime-0.5.9a160 → omnata_plugin_runtime-0.5.10}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: omnata-plugin-runtime
-Version: 0.5.9a160
+Version: 0.5.10
 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.9a160 → omnata_plugin_runtime-0.5.10}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "omnata-plugin-runtime"
-version = "0.5.9-a160"
+version = "0.5.10"
 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.9a160 → omnata_plugin_runtime-0.5.10}/src/omnata_plugin_runtime/omnata_plugin.py

@@ -112,6 +112,90 @@ class PluginManifest(SubscriptableBaseModel):
     supported_outbound_strategies: List[OutboundSyncStrategy]
 
 
+class SnowflakeFunctionParameter(BaseModel):
+    """
+    Represents a parameter for a Snowflake UDF or UDTF
+    """
+    name: str
+    description: str
+    data_type: str
+    default_value_clause: Optional[str] = None
+
+    def __str__(self):
+        if self.default_value_clause:
+            return f"{self.name} {self.data_type} default {self.default_value_clause}"
+        return f"{self.name} {self.data_type}"
+
+class SnowflakeUDTFResultColumn(BaseModel):
+    """
+    Represents a result column for a Snowflake UDTF
+    """
+    name: str
+    data_type: str
+    def __str__(self):
+        return f"{self.name} {self.data_type}"
+
+class UDTFDefinition(BaseModel):
+    """
+    The information needed by the plugin uploader to put a Python UDTF definition into the setup script.
+    Do not use this class directly in plugins, instead use the omnata_udtf decorator.
+    """
+    name: str = Field(..., title="The name of the UDTF")
+    language: Literal['python','java'] = Field(..., title="The language of the UDF")
+    runtime_version: str = Field(..., title="The runtime version of the UDF (language dependent)")
+    description: str = Field(..., title="A description of the UDTF")
+    params: List[SnowflakeFunctionParameter] = Field(..., title="The parameters of the UDTF")
+    result_columns: List[SnowflakeUDTFResultColumn] = Field(..., title="The result columns of the UDTF")
+    handler: str = Field(..., title="The handler class/function for the UDTF")
+    expose_to_consumer: bool = Field(..., title="Whether the UDTF should be exposed to consumers")
+    imports: Optional[List[str]] = Field(None, title="A list of imports required by the UDF")
+    packages: Optional[List[str]] = Field(None, title="A list of packages required by the UDTF")
+
+    def __str__(self):
+        param_str = ', '.join([str(param) for param in self.params])
+        table_result_columns = ', '.join([f"{col.name} {col.data_type}" for col in self.result_columns])
+        packages_str = ', '.join([f"'{p}'" for p in self.packages])
+        imports_str = ', '.join([f"'{i}'" for i in self.imports])
+        return f"""CREATE OR REPLACE FUNCTION UDFS.{self.name}({param_str})
+RETURNS TABLE({table_result_columns})
+LANGUAGE {self.language.upper()}
+RUNTIME_VERSION={self.runtime_version}
+COMMENT = $${self.description}$$
+PACKAGES = ({packages_str})
+IMPORTS = ({imports_str})
+HANDLER='{self.handler}';
+"""
+
+class UDFDefinition(BaseModel):
+    """
+    The information needed by the plugin uploader to put a Python UDF definition into the setup script.
+    Do not use this class directly in plugins, instead use the omnata_udf decorator.
+    """
+    name: str = Field(..., title="The name of the UDF")
+    language: Literal['python','java'] = Field(..., title="The language of the UDF")
+    runtime_version: str = Field(..., title="The runtime version of the UDF (language dependent)")
+    description: str = Field(..., title="A description of the UDF")
+    params: List[SnowflakeFunctionParameter] = Field(..., title="The parameters of the UDF")
+    result_data_type: str = Field(..., title="The data type returned by the UDF")
+    handler: str = Field(..., title="The handler class/function for the UDF")
+    expose_to_consumer: bool = Field(..., title="Whether the UDF should be exposed to consumers")
+    imports: Optional[List[str]] = Field(None, title="A list of imports required by the UDF")
+    packages: Optional[List[str]] = Field(None, title="A list of packages required by the UDF")
+
+    def __str__(self):
+        param_str = ', '.join([str(param) for param in self.params])
+        packages_str = ', '.join([f"'{p}'" for p in self.packages])
+        imports_str = ', '.join([f"'{i}'" for i in self.imports])
+        return f"""CREATE OR REPLACE FUNCTION UDFS.{self.name}({param_str})
+RETURNS {self.result_data_type}
+LANGUAGE {self.language.upper()}
+RUNTIME_VERSION={self.runtime_version}
+COMMENT = $${self.description}$$
+PACKAGES = ({packages_str})
+IMPORTS = ({imports_str})
+HANDLER='{self.handler}';
+"""
+
 class PluginInfo(BaseModel):
     """
     Manifest plus other derived information about a plugin which is determined during upload.
@@ -2234,90 +2318,6 @@ def get_nested_value(nested_dict:Dict, keys:List[str]):
     return reduce(lambda d, key: d.get(key) if isinstance(d, dict) else None, keys, nested_dict)
 
 
-class SnowflakeFunctionParameter(BaseModel):
-    """
-    Represents a parameter for a Snowflake UDF or UDTF
-    """
-    name: str
-    description: str
-    data_type: str
-    default_value_clause: Optional[str] = None
-
-    def __str__(self):
-        if self.default_value_clause:
-            return f"{self.name} {self.data_type} default {self.default_value_clause}"
-        return f"{self.name} {self.data_type}"
-
-class SnowflakeUDTFResultColumn(BaseModel):
-    """
-    Represents a result column for a Snowflake UDTF
-    """
-    name: str
-    data_type: str
-    def __str__(self):
-        return f"{self.name} {self.data_type}"
-
-class UDTFDefinition(BaseModel):
-    """
-    The information needed by the plugin uploader to put a Python UDTF definition into the setup script.
-    Do not use this class directly in plugins, instead use the omnata_udtf decorator.
-    """
-    name: str = Field(..., title="The name of the UDTF")
-    language: Literal['python','java'] = Field(..., title="The language of the UDF")
-    runtime_version: str = Field(..., title="The runtime version of the UDF (language dependent)")
-    description: str = Field(..., title="A description of the UDTF")
-    params: List[SnowflakeFunctionParameter] = Field(..., title="The parameters of the UDTF")
-    result_columns: List[SnowflakeUDTFResultColumn] = Field(..., title="The result columns of the UDTF")
-    handler: str = Field(..., title="The handler class/function for the UDTF")
-    expose_to_consumer: bool = Field(..., title="Whether the UDTF should be exposed to consumers")
-    imports: Optional[List[str]] = Field(None, title="A list of imports required by the UDF")
-    packages: Optional[List[str]] = Field(None, title="A list of packages required by the UDTF")
-
-    def __str__(self):
-        param_str = ', '.join([str(param) for param in self.params])
-        table_result_columns = ', '.join([f"{col.name} {col.data_type}" for col in self.result_columns])
-        packages_str = ', '.join([f"'{p}'" for p in self.packages])
-        imports_str = ', '.join([f"'{i}'" for i in self.imports])
-        return f"""CREATE OR REPLACE FUNCTION UDFS.{self.name}({param_str})
-RETURNS TABLE({table_result_columns})
-LANGUAGE {self.language.upper()}
-RUNTIME_VERSION={self.runtime_version}
-COMMENT = $${self.description}$$
-PACKAGES = ({packages_str})
-IMPORTS = ({imports_str})
-HANDLER='{self.handler}';
-"""
-
-class UDFDefinition(BaseModel):
-    """
-    The information needed by the plugin uploader to put a Python UDF definition into the setup script.
-    Do not use this class directly in plugins, instead use the omnata_udf decorator.
-    """
-    name: str = Field(..., title="The name of the UDF")
-    language: Literal['python','java'] = Field(..., title="The language of the UDF")
-    runtime_version: str = Field(..., title="The runtime version of the UDF (language dependent)")
-    description: str = Field(..., title="A description of the UDF")
-    params: List[SnowflakeFunctionParameter] = Field(..., title="The parameters of the UDF")
-    result_data_type: str = Field(..., title="The data type returned by the UDF")
-    handler: str = Field(..., title="The handler class/function for the UDF")
-    expose_to_consumer: bool = Field(..., title="Whether the UDF should be exposed to consumers")
-    imports: Optional[List[str]] = Field(None, title="A list of imports required by the UDF")
-    packages: Optional[List[str]] = Field(None, title="A list of packages required by the UDF")
-
-    def __str__(self):
-        param_str = ', '.join([str(param) for param in self.params])
-        packages_str = ', '.join([f"'{p}'" for p in self.packages])
-        imports_str = ', '.join([f"'{i}'" for i in self.imports])
-        return f"""CREATE OR REPLACE FUNCTION UDFS.{self.name}({param_str})
-RETURNS {self.result_data_type}
-LANGUAGE {self.language.upper()}
-RUNTIME_VERSION={self.runtime_version}
-COMMENT = $${self.description}$$
-PACKAGES = ({packages_str})
-IMPORTS = ({imports_str})
-HANDLER='{self.handler}';
-"""
-
 def omnata_udtf(
         name:str,
         description: str,
@@ -2432,8 +2432,9 @@ def find_udtf_classes(path:str = '.') -> List[UDTFDefinition]:
                 udtf_obj = cast(UDTFDefinition,obj)
                 if udtf_obj.language == 'java':
                     # because the decorator wasn't used, we need to check if we need to add the connection_parameters parameter
-                    if udtf_obj.expose_to_consumer and udtf_obj.params[0].name.upper() != 'CONNECTION_PARAMETERS':
-                        udtf_obj.params = [SnowflakeFunctionParameter(
+                    if udtf_obj.expose_to_consumer:
+                        if len(udtf_obj.params) == 0 or udtf_obj.params[0].name.upper() != 'CONNECTION_PARAMETERS':
+                            udtf_obj.params = [SnowflakeFunctionParameter(
                                                 name='CONNECTION_PARAMETERS',
                                                 data_type='OBJECT',
                                                 description='The connection object, obtained from calling PLUGIN.PLUGIN_CONNECTION.')] + udtf_obj.params
@@ -2547,8 +2548,9 @@ def find_udf_functions(path:str = '.') -> List[UDFDefinition]:
                 udf_obj = cast(UDFDefinition,obj)
                 if udf_obj.language == 'java':
                     # because the decorator wasn't used, we need to check if we need to add the connection_parameters parameter
-                    if udf_obj.expose_to_consumer and udf_obj.params[0].name.upper() != 'CONNECTION_PARAMETERS':
-                        udf_obj.params = [SnowflakeFunctionParameter(
+                    if udf_obj.expose_to_consumer:
+                        if len(udf_obj.params) == 0 or udf_obj.params[0].name.upper() != 'CONNECTION_PARAMETERS':
+                            udf_obj.params = [SnowflakeFunctionParameter(
                                                 name='CONNECTION_PARAMETERS',
                                                 data_type='OBJECT',
                                                 description='The connection object, obtained from calling PLUGIN.PLUGIN_CONNECTION.')] + udf_obj.params