exasol-python-extension-common 0.2.0__tar.gz

exasol_python_extension_common-0.2.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 Exasol
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

exasol_python_extension_common-0.2.0/PKG-INFO

@@ -0,0 +1,39 @@
+Metadata-Version: 2.1
+Name: exasol-python-extension-common
+Version: 0.2.0
+Summary: A collection of common utilities for Exasol extensions.
+License: MIT
+Author: Mikhail Beck
+Author-email: mikhail.beck@exasol.com
+Requires-Python: >=3.8.0,<4.0
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Requires-Dist: click (>=8.1.7,<9.0.0)
+Requires-Dist: exasol-bucketfs (>=0.10.0)
+Requires-Dist: exasol-saas-api (>=0.7.0,<1.0.0)
+Requires-Dist: pyexasol (>=0.25.0,<0.26.0)
+Requires-Dist: requests (<2.32.0)
+Requires-Dist: tenacity (>=8.3.0,<9.0.0)
+Description-Content-Type: text/markdown
+
+# Exasol Python Extension Common
+
+A package with common functionality, shared by Exasol Python Extensions, e.g.
+* [transformers-extension](https://github.com/exasol/transformers-extension)
+* [sagemaker-extension](https://github.com/exasol/sagemaker-extension)
+
+## Features
+
+A deployer for script language containers (SLC) to be used by UDF-based extensions of Exasol database requiring a special SLC.
+
+## More documentation
+
+* User Guide
+* [Developer Guide](doc/developer-guide.md)
+* [User Defined Functions (UDF)](https://docs.exasol.com/db/latest/database_concepts/udf_scripts.htm)
+* [Script Language Containers (SLC)](https://github.com/exasol/script-languages-release/)
+

exasol_python_extension_common-0.2.0/README.md

@@ -0,0 +1,16 @@
+# Exasol Python Extension Common
+
+A package with common functionality, shared by Exasol Python Extensions, e.g.
+* [transformers-extension](https://github.com/exasol/transformers-extension)
+* [sagemaker-extension](https://github.com/exasol/sagemaker-extension)
+
+## Features
+
+A deployer for script language containers (SLC) to be used by UDF-based extensions of Exasol database requiring a special SLC.
+
+## More documentation
+
+* User Guide
+* [Developer Guide](doc/developer-guide.md)
+* [User Defined Functions (UDF)](https://docs.exasol.com/db/latest/database_concepts/udf_scripts.htm)
+* [Script Language Containers (SLC)](https://github.com/exasol/script-languages-release/)

exasol_python_extension_common-0.2.0/exasol/python_extension_common/deployment/language_container_deployer.py

@@ -0,0 +1,349 @@
+from enum import Enum
+from textwrap import dedent
+from typing import List, Optional, Dict
+from pathlib import Path, PurePosixPath
+import logging
+import tempfile
+import ssl
+import requests     # type: ignore
+import pyexasol     # type: ignore
+import exasol.bucketfs as bfs   # type: ignore
+from exasol.saas.client.api_access import (get_connection_params, get_database_id)      # type: ignore
+
+from exasol.python_extension_common.deployment.language_container_validator import (
+    wait_language_container, temp_schema
+)
+
+
+logger = logging.getLogger(__name__)
+
+
+def get_websocket_sslopt(use_ssl_cert_validation: bool = True,
+                         ssl_trusted_ca: Optional[str] = None,
+                         ssl_client_certificate: Optional[str] = None,
+                         ssl_private_key: Optional[str] = None) -> dict:
+    """
+    Returns a dictionary in the winsocket-client format
+    (see https://websocket-client.readthedocs.io/en/latest/faq.html#what-else-can-i-do-with-sslopts)
+    """
+
+    # Is server certificate validation required?
+    sslopt: Dict[str, object] = {"cert_reqs": ssl.CERT_REQUIRED if use_ssl_cert_validation else ssl.CERT_NONE}
+
+    # Is a bundle with trusted CAs provided?
+    if ssl_trusted_ca:
+        trusted_ca_path = Path(ssl_trusted_ca)
+        if trusted_ca_path.is_dir():
+            sslopt["ca_cert_path"] = ssl_trusted_ca
+        elif trusted_ca_path.is_file():
+            sslopt["ca_certs"] = ssl_trusted_ca
+        else:
+            raise ValueError(f"Trusted CA location {ssl_trusted_ca} doesn't exist.")
+
+    # Is client's own certificate provided?
+    if ssl_client_certificate:
+        if not Path(ssl_client_certificate).is_file():
+            raise ValueError(f"Certificate file {ssl_client_certificate} doesn't exist.")
+        sslopt["certfile"] = ssl_client_certificate
+        if ssl_private_key:
+            if not Path(ssl_private_key).is_file():
+                raise ValueError(f"Private key file {ssl_private_key} doesn't exist.")
+            sslopt["keyfile"] = ssl_private_key
+
+    return sslopt
+
+
+class LanguageActivationLevel(Enum):
+    """
+    Language activation level, i.e.
+    ALTER <LanguageActivationLevel> SET SCRIPT_LANGUAGES=...
+    """
+    Session = 'SESSION'
+    System = 'SYSTEM'
+
+
+def get_language_settings(pyexasol_conn: pyexasol.ExaConnection, alter_type: LanguageActivationLevel) -> str:
+    """
+    Reads the current language settings at the specified level.
+
+    pyexasol_conn    - Opened database connection.
+    alter_type       - Activation level - SYSTEM or SESSION.
+    """
+    result = pyexasol_conn.execute(
+        f"""SELECT "{alter_type.value}_VALUE" FROM SYS.EXA_PARAMETERS WHERE
+        PARAMETER_NAME='SCRIPT_LANGUAGES'""").fetchall()
+    return result[0][0]
+
+
+def get_udf_path(bucket_base_path: bfs.path.PathLike, bucket_file: str) -> PurePosixPath:
+    """
+    Returns the path of the specified file in a bucket, as it's seen from a UDF
+
+    bucket_base_path    - Base directory in the bucket
+    bucket_file         - File path in the bucket, relative to the base directory.
+    """
+
+    file_path = bucket_base_path / bucket_file
+    return PurePosixPath(file_path.as_udf_path())
+
+
+class LanguageContainerDeployer:
+
+    def __init__(self,
+                 pyexasol_connection: pyexasol.ExaConnection,
+                 language_alias: str,
+                 bucketfs_path: bfs.path.PathLike) -> None:
+
+        self._bucketfs_path = bucketfs_path
+        self._language_alias = language_alias
+        self._pyexasol_conn = pyexasol_connection
+        logger.debug("Init %s", LanguageContainerDeployer.__name__)
+
+    def download_and_run(self, url: str,
+                         bucket_file_path: str,
+                         alter_system: bool = True,
+                         allow_override: bool = False,
+                         wait_for_completion: bool = True) -> None:
+        """
+        Downloads the language container from the provided url to a temporary file and then deploys it.
+        See docstring on the `run` method for details on what is involved in the deployment.
+
+        url              - Address where the container will be downloaded from.
+        bucket_file_path - Path within the designated bucket where the container should be uploaded.
+        alter_system     - If True will try to activate the container at the System level.
+        allow_override   - If True the activation of a language container with the same alias will be
+                           overriden, otherwise a RuntimeException will be thrown.
+        wait_for_completion - If True will wait until the language container becomes operational.
+        """
+
+        with tempfile.NamedTemporaryFile() as tmp_file:
+            response = requests.get(url, stream=True, timeout=300)
+            response.raise_for_status()
+            tmp_file.write(response.content)
+
+            self.run(Path(tmp_file.name), bucket_file_path, alter_system, allow_override,
+                     wait_for_completion)
+
+    def run(self, container_file: Optional[Path] = None,
+            bucket_file_path: Optional[str] = None,
+            alter_system: bool = True,
+            allow_override: bool = False,
+            wait_for_completion: bool = True) -> None:
+        """
+        Deploys the language container. This includes two steps, both of which are optional:
+        - Uploading the container into the database. This step can be skipped if the container
+          has already been uploaded.
+        - Activating the container. In case the container does not get activated at the System
+        level, two alternative activation SQL commands (one for the System and one for the Session
+        levels) will be printed on the console.
+
+        container_file   - Path of the container tar.gz file in a local file system.
+                           If not provided the container is assumed to be uploaded already.
+        bucket_file_path - Path within the designated bucket where the container should be uploaded.
+                           If not specified the name of the container file will be used instead.
+        alter_system     - If True will try to activate the container at the System level.
+        allow_override   - If True the activation of a language container with the same alias will be
+                           overriden, otherwise a RuntimeException will be thrown.
+        wait_for_completion - If True will wait until the language container becomes operational.
+        """
+
+        if not bucket_file_path:
+            if not container_file:
+                raise ValueError('Either a container file or a bucket file path must be specified.')
+            bucket_file_path = container_file.name
+
+        if container_file:
+            self.upload_container(container_file, bucket_file_path)
+
+        # Activate the language container.
+        if alter_system:
+            self.activate_container(bucket_file_path, LanguageActivationLevel.System,
+                                    allow_override)
+        self.activate_container(bucket_file_path, LanguageActivationLevel.Session,
+                                allow_override)
+
+        # Maybe wait until the container becomes operational.
+        if container_file and wait_for_completion:
+            with temp_schema(self._pyexasol_conn) as schema:
+                wait_language_container(self._pyexasol_conn, self._language_alias, schema)
+
+        if not alter_system:
+            message = dedent(f"""
+            In SQL, you can activate the SLC
+            by using the following statements:
+
+            To activate the SLC only for the current session:
+            {self.generate_activation_command(bucket_file_path, LanguageActivationLevel.Session, True)}
+
+            To activate the SLC on the system:
+            {self.generate_activation_command(bucket_file_path, LanguageActivationLevel.System, True)}
+            """)
+            print(message)
+
+    def upload_container(self, container_file: Path,
+                         bucket_file_path: Optional[str] = None) -> None:
+        """
+        Upload the language container to the BucketFS.
+
+        container_file   - Path of the container tar.gz file in a local file system.
+        bucket_file_path - Path within the designated bucket where the container should be uploaded.
+        """
+        if not container_file.is_file():
+            raise RuntimeError(f"Container file {container_file} "
+                               f"is not a file.")
+        with open(container_file, "br") as f:
+            file_path = self._bucketfs_path / bucket_file_path
+            file_path.write(f)
+        logging.debug("Container is uploaded to bucketfs")
+
+    def activate_container(self, bucket_file_path: str,
+                           alter_type: LanguageActivationLevel = LanguageActivationLevel.Session,
+                           allow_override: bool = False) -> None:
+        """
+        Activates the language container at the required level.
+
+        bucket_file_path - Path within the designated bucket where the container is uploaded.
+        alter_type       - Language activation level, defaults to the SESSION.
+        allow_override   - If True the activation of a language container with the same alias will be overriden,
+                           otherwise a RuntimeException will be thrown.
+        """
+        alter_command = self.generate_activation_command(bucket_file_path, alter_type, allow_override)
+        self._pyexasol_conn.execute(alter_command)
+        logging.debug(alter_command)
+
+    def generate_activation_command(self, bucket_file_path: str,
+                                    alter_type: LanguageActivationLevel,
+                                    allow_override: bool = False) -> str:
+        """
+        Generates an SQL command to activate the SLC container at the required level. The command will
+        preserve existing activations of other containers identified by different language aliases.
+        Activation of a container with the same alias, if exists, will be overwritten.
+
+        bucket_file_path - Path within the designated bucket where the container is uploaded.
+        alter_type       - Activation level - SYSTEM or SESSION.
+        allow_override   - If True the activation of a language container with the same alias will be overriden,
+                           otherwise a RuntimeException will be thrown.
+        """
+        path_in_udf = get_udf_path(self._bucketfs_path, bucket_file_path)
+        new_settings = \
+            self._update_previous_language_settings(alter_type, allow_override, path_in_udf)
+        alter_command = \
+            f"ALTER {alter_type.value} SET SCRIPT_LANGUAGES='{new_settings}';"
+        return alter_command
+
+    def _update_previous_language_settings(self, alter_type: LanguageActivationLevel,
+                                           allow_override: bool,
+                                           path_in_udf: PurePosixPath) -> str:
+        prev_lang_settings = get_language_settings(self._pyexasol_conn, alter_type)
+        prev_lang_aliases = prev_lang_settings.split(" ")
+        self._check_if_requested_language_alias_already_exists(
+            allow_override, prev_lang_aliases)
+        new_definitions_str = self._generate_new_language_settings(
+            path_in_udf, prev_lang_aliases)
+        return new_definitions_str
+
+    def get_language_definition(self, bucket_file_path: str):
+        """
+        Generate a language definition (ALIAS=URL) for the specified bucket file path.
+
+        bucket_file_path - Path within the designated bucket where the container is uploaded.
+        """
+        path_in_udf = get_udf_path(self._bucketfs_path, bucket_file_path)
+        result = self._generate_new_language_settings(path_in_udf=path_in_udf, prev_lang_aliases=[])
+        return result
+
+    def _generate_new_language_settings(self, path_in_udf: PurePosixPath,
+                                        prev_lang_aliases: List[str]) -> str:
+        other_definitions = [
+            alias_definition for alias_definition in prev_lang_aliases
+            if not alias_definition.startswith(self._language_alias + "=")]
+        path_in_udf_without_buckets = PurePosixPath(*path_in_udf.parts[2:])
+        new_language_alias_definition = \
+            f"{self._language_alias}=localzmq+protobuf:///" \
+            f"{path_in_udf_without_buckets}?lang=python#" \
+            f"{path_in_udf}/exaudf/exaudfclient_py3"
+        new_definitions = other_definitions + [new_language_alias_definition]
+        new_definitions_str = " ".join(new_definitions)
+        return new_definitions_str
+
+    def _check_if_requested_language_alias_already_exists(
+            self, allow_override: bool,
+            prev_lang_aliases: List[str]) -> None:
+        definition_for_requested_alias = [
+            alias_definition for alias_definition in prev_lang_aliases
+            if alias_definition.startswith(self._language_alias + "=")]
+        if not len(definition_for_requested_alias) == 0:
+            warning_message = f"The requested language alias {self._language_alias} is already in use."
+            if allow_override:
+                logging.warning(warning_message)
+            else:
+                raise RuntimeError(warning_message)
+
+    @classmethod
+    def create(cls,
+               language_alias: str, dsn: Optional[str] = None,
+               db_user: Optional[str] = None, db_password: Optional[str] = None,
+               bucketfs_host: Optional[str] = None, bucketfs_port: Optional[int] = None,
+               bucketfs_name: Optional[str] = None, bucket: Optional[str] = None,
+               bucketfs_user: Optional[str] = None, bucketfs_password: Optional[str] = None,
+               bucketfs_use_https: bool = True,
+               saas_url: Optional[str] = None,
+               saas_account_id: Optional[str] = None, saas_database_id: Optional[str] = None,
+               saas_database_name: Optional[str] = None, saas_token: Optional[str] = None,
+               path_in_bucket: str = '',
+               use_ssl_cert_validation: bool = True, ssl_trusted_ca: Optional[str] = None,
+               ssl_client_certificate: Optional[str] = None,
+               ssl_private_key: Optional[str] = None) -> "LanguageContainerDeployer":
+
+        # Infer where the database is - on-prem or SaaS.
+        if all((dsn, db_user, db_password, bucketfs_host, bucketfs_port,
+                bucketfs_name, bucket, bucketfs_user, bucketfs_password)):
+            connection_params = {'dsn': dsn, 'user': db_user, 'password': db_password}
+            bfs_url = (f"{'https' if bucketfs_use_https else 'http'}://"
+                       f"{bucketfs_host}:{bucketfs_port}")
+            verify = ssl_trusted_ca or use_ssl_cert_validation
+            bucketfs_path = bfs.path.build_path(backend=bfs.path.StorageBackend.onprem,
+                                                url=bfs_url,
+                                                username=bucketfs_user,
+                                                password=bucketfs_password,
+                                                service_name=bucketfs_name,
+                                                bucket_name=bucket,
+                                                verify=verify,
+                                                path=path_in_bucket)
+
+        elif all((saas_url, saas_account_id, saas_token,
+                  any((saas_database_id, saas_database_name)))):
+            connection_params = get_connection_params(host=saas_url,
+                                                      account_id=saas_account_id,
+                                                      database_id=saas_database_id,
+                                                      database_name=saas_database_name,
+                                                      pat=saas_token)
+            saas_database_id = (saas_database_id or
+                                get_database_id(
+                                    host=saas_url,
+                                    account_id=saas_account_id,
+                                    pat=saas_token,
+                                    database_name=saas_database_name
+                                ))
+            bucketfs_path = bfs.path.build_path(backend=bfs.path.StorageBackend.saas,
+                                                url=saas_url,
+                                                account_id=saas_account_id,
+                                                database_id=saas_database_id,
+                                                pat=saas_token,
+                                                path=path_in_bucket)
+        else:
+            raise ValueError('Incomplete parameter list. '
+                             'Please either provide the parameters [dns, db_user, '
+                             'db_password, bucketfs_host, bucketfs_port, bucketfs_name, '
+                             'bucket, bucketfs_user, bucketfs_password] for an On-Prem '
+                             'database or [saas_url, saas_account_id, saas_database_id, '
+                             'saas_token] for a SaaS database.')
+
+        websocket_sslopt = get_websocket_sslopt(use_ssl_cert_validation, ssl_trusted_ca,
+                                                ssl_client_certificate, ssl_private_key)
+
+        pyexasol_conn = pyexasol.connect(**connection_params,
+                                         encryption=True,
+                                         websocket_sslopt=websocket_sslopt)
+
+        return cls(pyexasol_conn, language_alias, bucketfs_path)

exasol_python_extension_common-0.2.0/exasol/python_extension_common/deployment/language_container_deployer_cli.py

@@ -0,0 +1,220 @@
+from typing import Optional, Any
+import os
+import re
+from enum import Enum
+from pathlib import Path
+import click
+from exasol.python_extension_common.deployment.language_container_deployer import LanguageContainerDeployer
+
+
+class CustomizableParameters(Enum):
+    """
+    Parameters of the cli that can be programmatically customised by a developer
+    of a specialised version of the cli.
+    The names in the enum list should match the parameter names in language_container_deployer_main.
+    """
+    container_url = 1
+    container_name = 2
+
+
+class _ParameterFormatters:
+    """
+    Class facilitating customization of the cli.
+
+    The idea is that some of the cli parameters can be programmatically customized based
+    on values of other parameters and externally supplied formatters. For example a specialized
+    version of the cli may want to provide its own url. Furthermore, this url will depend on
+    the user supplied parameter called "version". The solution is to set a formatter for the
+    url, for instance "http://my_stuff/{version}/my_data". If the user specifies non-empty version
+    parameter the url will be fully formed.
+
+    A formatter may include more than one parameter. In the previous example the url could,
+    for instance, also include a username: "http://my_stuff/{version}/{user}/my_data".
+
+    Note that customized parameters can only be updated in a callback function. There is no
+    way to inject them directly into the cli. Also, the current implementation doesn't perform
+    the update if the value of the parameter dressed with the callback is None.
+
+    IMPORTANT! Please make sure that the formatters are set up before the call to the cli function,
+    e.g. language_container_deployer_main, is executed.
+    """
+    def __init__(self):
+        self._formatters = {}
+
+    def __call__(self, ctx: click.Context, param: click.Parameter, value: Optional[Any]) -> Optional[Any]:
+
+        def update_parameter(parameter_name: str, formatter: str) -> None:
+            param_formatter = ctx.params.get(parameter_name, formatter)
+            if param_formatter:
+                # Enclose in double curly brackets all other parameters in the formatting string,
+                # to avoid the missing parameters' error. Below is an example of a formatter string
+                # before and after applying the regex, assuming the current parameter is 'version'.
+                # 'something-with-{version}/tailored-for-{user}' => 'something-with-{version}/tailored-for-{{user}}'
+                # We were looking for all occurrences of a pattern '{some_name}', where some_name is not version.
+                pattern = r'\{(?!' + (param.name or '') + r'\})\w+\}'
+                param_formatter = re.sub(pattern, lambda m: f'{{{m.group(0)}}}', param_formatter)
+                kwargs = {param.name: value}
+                ctx.params[parameter_name] = param_formatter.format(**kwargs)
+
+        if value is not None:
+            for prm_name, prm_formatter in self._formatters.items():
+                update_parameter(prm_name, prm_formatter)
+
+        return value
+
+    def set_formatter(self, custom_parameter: CustomizableParameters, formatter: str) -> None:
+        """ Sets a formatter for a customizable parameter. """
+        self._formatters[custom_parameter.name] = formatter
+
+    def clear_formatters(self):
+        """ Deletes all formatters, mainly for testing purposes. """
+        self._formatters.clear()
+
+
+# Global cli customization object.
+# Specialized versions of this cli should use this object to set custom parameter formatters.
+slc_parameter_formatters = _ParameterFormatters()
+
+
+# This text will be displayed instead of the actual value, if found in an environment
+# variable, in a prompt.
+SECRET_DISPLAY = '***'
+
+
+class SecretParams(Enum):
+    """
+    This enum serves as a definition of confidential parameters which values should not be
+    displayed in the console, unless the user types them in the command line.
+
+    The enum name is also the name of the environment variable where the correspondent
+    secret value can be stored.
+
+    The enum value is also the name of the cli parameter.
+    """
+    DB_PASSWORD = 'db-pass'
+    BUCKETFS_PASSWORD = 'bucketfs-password'
+    SAAS_ACCOUNT_ID = 'saas-account-id'
+    SAAS_DATABASE_ID = 'saas-database-id'
+    SAAS_TOKEN = 'saas-token'
+
+
+def secret_callback(ctx: click.Context, param: click.Option, value: Any):
+    """
+    Here we try to get the secret parameter value from an environment variable.
+    The reason for doing this in the callback instead of using a callable default is
+    that we don't want the default to be displayed in the prompt. There seems to
+    be no way of altering this behaviour.
+    """
+    if value == SECRET_DISPLAY:
+        secret_param = SecretParams(param.opts[0][2:])
+        return os.environ.get(secret_param.name)
+    return value
+
+
+@click.command(name="language-container")
+@click.option('--bucketfs-name', type=str)
+@click.option('--bucketfs-host', type=str)
+@click.option('--bucketfs-port', type=int)
+@click.option('--bucketfs-use-https', type=bool, default=False)
+@click.option('--bucketfs-user', type=str)
+@click.option(f'--{SecretParams.BUCKETFS_PASSWORD.value}', type=str,
+              prompt='BucketFS password', prompt_required=False,
+              hide_input=True, default=SECRET_DISPLAY, callback=secret_callback)
+@click.option('--bucket', type=str)
+@click.option('--saas-url', type=str,
+              default='https://cloud.exasol.com')
+@click.option(f'--{SecretParams.SAAS_ACCOUNT_ID.value}', type=str,
+              prompt='SaaS account id', prompt_required=False,
+              hide_input=True, default=SECRET_DISPLAY, callback=secret_callback)
+@click.option(f'--{SecretParams.SAAS_DATABASE_ID.value}', type=str,
+              prompt='SaaS database id', prompt_required=False,
+              hide_input=True, default=SECRET_DISPLAY, callback=secret_callback)
+@click.option('--saas-database-name', type=str)
+@click.option(f'--{SecretParams.SAAS_TOKEN.value}', type=str,
+              prompt='SaaS token', prompt_required=False,
+              hide_input=True, default=SECRET_DISPLAY, callback=secret_callback)
+@click.option('--path-in-bucket', type=str)
+@click.option('--container-file',
+              type=click.Path(exists=True, file_okay=True))
+@click.option('--version', type=str, expose_value=False,
+              callback=slc_parameter_formatters)
+@click.option('--dsn', type=str)
+@click.option('--db-user', type=str)
+@click.option(f'--{SecretParams.DB_PASSWORD.value}', type=str,
+              prompt='DB password', prompt_required=False,
+              hide_input=True, default=SECRET_DISPLAY, callback=secret_callback)
+@click.option('--language-alias', type=str, default="PYTHON3_EXT")
+@click.option('--ssl-cert-path', type=str, default="")
+@click.option('--ssl-client-cert-path', type=str, default="")
+@click.option('--ssl-client-private-key', type=str, default="")
+@click.option('--use-ssl-cert-validation/--no-use-ssl-cert-validation', type=bool, default=True)
+@click.option('--upload-container/--no-upload_container', type=bool, default=True)
+@click.option('--alter-system/--no-alter-system', type=bool, default=True)
+@click.option('--allow-override/--disallow-override', type=bool, default=False)
+@click.option('--wait_for_completion/--no-wait_for_completion', type=bool, default=True)
+def language_container_deployer_main(
+        bucketfs_name: str,
+        bucketfs_host: str,
+        bucketfs_port: int,
+        bucketfs_use_https: bool,
+        bucketfs_user: str,
+        bucketfs_password: str,
+        bucket: str,
+        saas_url: str,
+        saas_account_id: str,
+        saas_database_id: str,
+        saas_database_name: str,
+        saas_token: str,
+        path_in_bucket: str,
+        container_file: str,
+        dsn: str,
+        db_user: str,
+        db_pass: str,
+        language_alias: str,
+        ssl_cert_path: str,
+        ssl_client_cert_path: str,
+        ssl_client_private_key: str,
+        use_ssl_cert_validation: bool,
+        upload_container: bool,
+        alter_system: bool,
+        allow_override: bool,
+        wait_for_completion: bool,
+        container_url: Optional[str] = None,
+        container_name: Optional[str] = None):
+
+    deployer = LanguageContainerDeployer.create(
+        bucketfs_name=bucketfs_name,
+        bucketfs_host=bucketfs_host,
+        bucketfs_port=bucketfs_port,
+        bucketfs_use_https=bucketfs_use_https,
+        bucketfs_user=bucketfs_user,
+        bucketfs_password=bucketfs_password,
+        bucket=bucket,
+        saas_url=saas_url,
+        saas_account_id=saas_account_id,
+        saas_database_id=saas_database_id,
+        saas_database_name=saas_database_name,
+        saas_token=saas_token,
+        path_in_bucket=path_in_bucket,
+        dsn=dsn,
+        db_user=db_user,
+        db_password=db_pass,
+        language_alias=language_alias,
+        ssl_trusted_ca=ssl_cert_path,
+        ssl_client_certificate=ssl_client_cert_path,
+        ssl_private_key=ssl_client_private_key,
+        use_ssl_cert_validation=use_ssl_cert_validation)
+
+    if not upload_container:
+        deployer.run(alter_system=alter_system, allow_override=allow_override,
+                     wait_for_completion=wait_for_completion)
+    elif container_file:
+        deployer.run(container_file=Path(container_file), alter_system=alter_system,
+                     allow_override=allow_override, wait_for_completion=wait_for_completion)
+    elif container_url and container_name:
+        deployer.download_and_run(container_url, container_name, alter_system=alter_system,
+                                  allow_override=allow_override, wait_for_completion=wait_for_completion)
+    else:
+        # The error message should mention the parameters which the callback is specified for being missed.
+        raise ValueError("To upload a language container you should specify either its "
+                         "release version or a path of the already downloaded container file.")

exasol_python_extension_common-0.2.0/exasol/python_extension_common/deployment/language_container_validator.py

@@ -0,0 +1,140 @@
+from __future__ import annotations
+from typing import Generator
+from datetime import timedelta
+import random
+import string
+from contextlib import contextmanager
+from textwrap import dedent
+
+from tenacity import retry
+from tenacity.wait import wait_fixed
+from tenacity.stop import stop_after_delay, stop_after_attempt
+
+import pyexasol     # type: ignore
+
+_DUMMY_UDF_NAME = 'DUMMY_UDF'
+
+
+def _get_test_udf_name(schema: str | None) -> str:
+
+    if schema:
+        return f'"{schema}"."{_DUMMY_UDF_NAME}"'
+    return f'"{_DUMMY_UDF_NAME}"'
+
+
+def _create_dummy_udf(conn: pyexasol.ExaConnection, language_alias: str,
+                      schema: str | None) -> None:
+
+    udf_name = _get_test_udf_name(schema)
+    sql = dedent(f"""
+    CREATE OR REPLACE {language_alias} SCALAR SCRIPT {udf_name}()
+    RETURNS DECIMAL(1, 0) AS
+
+    def run(ctx):
+        return 0
+    /
+    """)
+    conn.execute(sql)
+
+
+def _call_dummy_udf(conn: pyexasol.ExaConnection, schema: str | None) -> None:
+
+    udf_name = _get_test_udf_name(schema)
+    sql = dedent(f"""
+    SELECT {udf_name}()
+    GROUP BY IPROC();
+    """)
+    result = conn.execute(sql).fetchall()
+    assert result == [(0,)]
+
+
+def _delete_dummy_udf(conn: pyexasol.ExaConnection, schema: str | None) -> None:
+
+    udf_name = _get_test_udf_name(schema)
+    sql = dedent(f"""
+    DROP SCRIPT IF EXISTS {udf_name};
+    """)
+    conn.execute(sql)
+
+
+@retry(reraise=True, stop=stop_after_attempt(3))
+def _create_random_schema(conn: pyexasol.ExaConnection, schema_name_length: int) -> str:
+
+    schema = ''.join(random.choice(string.ascii_letters)
+                     for _ in range(schema_name_length))
+    sql = f'CREATE SCHEMA "{schema}";'
+    conn.execute(query=sql)
+    return schema
+
+
+def _delete_schema(conn: pyexasol.ExaConnection, schema: str) -> None:
+
+    sql = f'DROP SCHEMA IF EXISTS "{schema}" CASCADE;'
+    conn.execute(query=sql)
+
+
+def validate_language_container(conn: pyexasol.ExaConnection,
+                                language_alias: str,
+                                schema: str | None = None
+                                ) -> None:
+    """
+    Runs a test to check if a language container has been installed and is now
+    operational. Will raise an exception if this is not the case.
+
+    conn            - pyexasol connection. The language container must be activated either
+                    at the SYSTEM level or at the SESSION associated with this connection.
+    language_alias  - Language alias of the language container.
+    schema          - The schema to run the tests in. If not specified the current schema
+                    is assumed.
+    """
+    try:
+        _create_dummy_udf(conn, language_alias, schema)
+        _call_dummy_udf(conn, schema)
+    finally:
+        _delete_dummy_udf(conn, schema)
+
+
+def wait_language_container(conn: pyexasol.ExaConnection,
+                            language_alias: str,
+                            schema: str | None = None,
+                            timeout: timedelta = timedelta(minutes=5),
+                            interval: timedelta = timedelta(seconds=5),
+                            ) -> None:
+    """
+    Keeps calling validate_language_container until it succeeds or the timeout expires.
+
+    conn            - pyexasol connection. The language container must be activated either
+                    at the SYSTEM level or at the SESSION associated with this connection.
+    language_alias  - Language alias of the language container.
+    schema          - The schema to run the tests in. If not specified the current schema
+                    is assumed.
+    timeout         - Will give up after this timeout expires. The last exception thrown
+                    by the validate_language_container will be re-raised.
+    interval        - The calls to validate_language_container are spaced by this time
+                    interval.
+    """
+    @retry(reraise=True, wait=wait_fixed(interval), stop=stop_after_delay(timeout))
+    def repeat_validate_language_container():
+        validate_language_container(conn, language_alias, schema)
+
+    repeat_validate_language_container()
+
+
+@contextmanager
+def temp_schema(conn: pyexasol.ExaConnection,
+                schema_name_length: int = 20
+                ) -> Generator[str, None, None]:
+    """
+    A context manager for running an operation in a newly created temporary schema.
+    The schema will be deleted after the operation is competed. Note, that all objects
+    created in this schema will be deleted with it. Returns the name of the created schema.
+
+    conn                - pyexasol connection.
+    schema_name_length  - Number of characters in the temporary schema name.
+    """
+    schema = ''
+    try:
+        schema = _create_random_schema(conn, schema_name_length)
+        yield schema
+    finally:
+        _delete_schema(conn, schema)

exasol_python_extension_common-0.2.0/pyproject.toml

@@ -0,0 +1,69 @@
+[tool.poetry]
+name = "exasol-python-extension-common"
+version = "0.2.0"
+description = "A collection of common utilities for Exasol extensions."
+packages = [ {include = "exasol"}, ]
+authors = ["Mikhail Beck <mikhail.beck@exasol.com>"]
+license = "MIT"
+readme = "README.md"
+
+[tool.poetry.dependencies]
+python = ">=3.8.0,<4.0"
+pyexasol = "^0.25.0"
+exasol-bucketfs = ">=0.10.0"
+click = "^8.1.7"
+exasol-saas-api = ">=0.7.0,<1.0.0"
+requests = "<2.32.0"
+tenacity = "^8.3.0"
+
+[tool.poetry.group.dev.dependencies]
+pytest = "^7.2.0"
+exasol-toolbox = ">=0.12.0"
+exasol-script-languages-container-tool = "^0.18.2"
+pytest-exasol-saas = ">=0.2.1,<1.0.0"
+
+[build-system]
+requires = ["poetry-core>=1.0.0"]
+build-backend = "poetry.core.masonry.api"
+
+[tool.coverage.run]
+relative_files = true
+source = [
+    "exasol",
+]
+
+[tool.coverage.report]
+fail_under = 15
+
+[tool.black]
+line-length = 100
+verbose = false
+include = "\\.pyi?$"
+
+
+[tool.isort]
+profile = "black"
+force_grid_wrap = 2
+
+
+[tool.pylint.master]
+errors-only = true
+output-format = "colorized,json:.lint.json,text:.lint.txt"
+
+[tool.pylint.format]
+max-line-length = 100
+max-module-lines = 800
+
+
+[[tool.mypy.overrides]]
+module = [
+    "exasol.toolbox.nox.tasks",
+    "test.*",
+]
+ignore_errors = true
+ignore_missing_imports = true
+
+[tool.pytest.ini_options]
+markers = [
+    "saas: integration test that creates a db in SaaS.",
+]

exasol_python_extension_common-0.2.0/setup.py

@@ -0,0 +1,37 @@
+# -*- coding: utf-8 -*-
+from setuptools import setup
+
+packages = \
+['exasol',
+ 'exasol.python_extension_common',
+ 'exasol.python_extension_common.deployment']
+
+package_data = \
+{'': ['*']}
+
+install_requires = \
+['click>=8.1.7,<9.0.0',
+ 'exasol-bucketfs>=0.10.0',
+ 'exasol-saas-api>=0.7.0,<1.0.0',
+ 'pyexasol>=0.25.0,<0.26.0',
+ 'requests<2.32.0',
+ 'tenacity>=8.3.0,<9.0.0']
+
+setup_kwargs = {
+    'name': 'exasol-python-extension-common',
+    'version': '0.2.0',
+    'description': 'A collection of common utilities for Exasol extensions.',
+    'long_description': '# Exasol Python Extension Common\n\nA package with common functionality, shared by Exasol Python Extensions, e.g.\n* [transformers-extension](https://github.com/exasol/transformers-extension)\n* [sagemaker-extension](https://github.com/exasol/sagemaker-extension)\n\n## Features\n\nA deployer for script language containers (SLC) to be used by UDF-based extensions of Exasol database requiring a special SLC.\n\n## More documentation\n\n* User Guide\n* [Developer Guide](doc/developer-guide.md)\n* [User Defined Functions (UDF)](https://docs.exasol.com/db/latest/database_concepts/udf_scripts.htm)\n* [Script Language Containers (SLC)](https://github.com/exasol/script-languages-release/)\n',
+    'author': 'Mikhail Beck',
+    'author_email': 'mikhail.beck@exasol.com',
+    'maintainer': 'None',
+    'maintainer_email': 'None',
+    'url': 'None',
+    'packages': packages,
+    'package_data': package_data,
+    'install_requires': install_requires,
+    'python_requires': '>=3.8.0,<4.0',
+}
+
+
+setup(**setup_kwargs)