exasol-transformers-extension 0.10.0__tar.gz

exasol_transformers_extension-0.10.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2022 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_transformers_extension-0.10.0/PKG-INFO

@@ -0,0 +1,48 @@
+Metadata-Version: 2.1
+Name: exasol-transformers-extension
+Version: 0.10.0
+Summary: An Exasol extension to use state-of-the-art pretrained machine learning models via the transformers api.
+Home-page: https://github.com/exasol/transformers-extension
+Keywords: exasol
+Author: Umit Buyuksahin
+Author-email: umit.buyuksahin@exasol.com
+Requires-Python: >=3.8.0,<4.0.0
+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: Jinja2 (>=3.0.3,<4.0.0)
+Requires-Dist: click (>=8.0.4,<9.0.0)
+Requires-Dist: exasol-bucketfs (>=0.9.0,<1.0.0)
+Requires-Dist: importlib-resources (>=5.4.0,<6.0.0)
+Requires-Dist: pandas (>=1.4.2,<2.0.0)
+Requires-Dist: pyexasol (>=0.25.0,<0.26.0)
+Requires-Dist: sacremoses (>=0.0.53)
+Requires-Dist: tenacity (>=8.2.2,<9.0.0)
+Requires-Dist: torch (>=2.0.1,<3.0.0)
+Requires-Dist: transformers[torch] (>=4.36.2,<5.0.0)
+Project-URL: Repository, https://github.com/exasol/transformers-extension
+Description-Content-Type: text/markdown
+
+# Exasol Transformers Extension
+
+An Exasol extension to use state-of-the-art pretrained machine learning models 
+via the [transformers api](https://github.com/huggingface/transformers).
+
+
+## Table of Contents
+
+### Information for Users
+
+* [User Guide](doc/user_guide/user_guide.md)
+* [Developer Guide](doc/developer_guide/developer_guide.md)
+* [Changelog](doc/changes/changelog.md)
+* [License](LICENSE)
+
+### Information for Contributors
+
+* [Design](doc/design.md)
+* [Dependencies](doc/dependencies.md)
+
+

exasol_transformers_extension-0.10.0/README.md

@@ -0,0 +1,20 @@
+# Exasol Transformers Extension
+
+An Exasol extension to use state-of-the-art pretrained machine learning models 
+via the [transformers api](https://github.com/huggingface/transformers).
+
+
+## Table of Contents
+
+### Information for Users
+
+* [User Guide](doc/user_guide/user_guide.md)
+* [Developer Guide](doc/developer_guide/developer_guide.md)
+* [Changelog](doc/changes/changelog.md)
+* [License](LICENSE)
+
+### Information for Contributors
+
+* [Design](doc/design.md)
+* [Dependencies](doc/dependencies.md)
+

exasol_transformers_extension-0.10.0/exasol_transformers_extension/__init__.py

@@ -0,0 +1 @@
+__version__ = '0.1.0'

exasol_transformers_extension-0.10.0/exasol_transformers_extension/deploy.py

@@ -0,0 +1,29 @@
+import logging
+import click
+from exasol_transformers_extension.deployment.scripts_deployer_cli import \
+    scripts_deployer_main
+from exasol_transformers_extension.deployment.language_container_deployer_cli \
+    import language_container_deployer_main, slc_parameter_formatters, CustomizableParameters
+from exasol_transformers_extension.deployment.te_language_container_deployer import TeLanguageContainerDeployer
+
+
+@click.group()
+def main():
+    pass
+
+
+slc_parameter_formatters.set_formatter(CustomizableParameters.container_url,
+                                       TeLanguageContainerDeployer.SLC_URL_FORMATTER)
+slc_parameter_formatters.set_formatter(CustomizableParameters.container_name,
+                                       TeLanguageContainerDeployer.SLC_NAME)
+
+main.add_command(scripts_deployer_main)
+main.add_command(language_container_deployer_main)
+
+
+if __name__ == '__main__':
+    logging.basicConfig(
+        format='%(asctime)s - %(module)s  - %(message)s',
+        level=logging.DEBUG)
+
+    main()

exasol_transformers_extension-0.10.0/exasol_transformers_extension/deployment/constants.py

@@ -0,0 +1,29 @@
+import pathlib
+from importlib_resources import files
+
+BASE_DIR = "exasol_transformers_extension"
+TEMPLATES_DIR = pathlib.Path("resources", "templates")
+UDF_CALLERS_DIR = files(f"{BASE_DIR}.udfs.callers")
+
+UDF_CALL_TEMPLATES = {
+    "model_downloader_udf_call.py":
+        "model_downloader_udf.jinja.sql",
+    "sequence_classification_single_text_udf_call.py":
+        "sequence_classification_single_text_udf.jinja.sql",
+    "sequence_classification_text_pair_udf_call.py":
+        "sequence_classification_text_pair_udf.jinja.sql",
+    "question_answering_udf_call.py":
+        "question_answering_udf.jinja.sql",
+    "filling_mask_udf_call.py":
+        "filling_mask_udf.jinja.sql",
+    "text_generation_udf_call.py":
+        "text_generation_udf.jinja.sql",
+    "token_classification_udf_call.py":
+        "token_classification_udf.jinja.sql",
+    "translation_udf_call.py":
+        "translation_udf.jinja.sql",
+    "zero_shot_text_classification_udf.py":
+        "zero_shot_text_classification_udf.jinja.sql"
+}
+
+ORDERED_COLUMNS = ['model_name', 'bucketfs_conn', 'token_conn', 'sub_dir']

exasol_transformers_extension-0.10.0/exasol_transformers_extension/deployment/deployment_utils.py

@@ -0,0 +1,37 @@
+
+import logging
+import requests
+import tempfile
+import ssl
+from pathlib import Path
+from contextlib import contextmanager
+from jinja2 import Environment, PackageLoader, select_autoescape
+from exasol_transformers_extension.deployment import constants
+
+
+logger = logging.getLogger(__name__)
+
+
+DB_PASSWORD_ENVIRONMENT_VARIABLE = f"TE_DB_PASSWORD"
+BUCKETFS_PASSWORD_ENVIRONMENT_VARIABLE = f"TE_BUCKETFS_PASSWORD"
+
+
+def load_and_render_statement(template_name, **kwargs) -> str:
+    env = Environment(
+        loader=PackageLoader(constants.BASE_DIR, constants.TEMPLATES_DIR),
+        autoescape=select_autoescape())
+    template = env.get_template(template_name)
+    statement = template.render(**kwargs)
+    return statement
+
+
+def get_websocket_ssl_options(use_ssl_cert_validation: bool, ssl_cert_path: str):
+    websocket_sslopt = {
+        "cert_reqs": ssl.CERT_REQUIRED,
+    }
+    if not use_ssl_cert_validation:
+        websocket_sslopt["cert_reqs"] = ssl.CERT_NONE
+
+    if ssl_cert_path is not None:
+        websocket_sslopt["ca_certs"] = ssl_cert_path
+    return websocket_sslopt

exasol_transformers_extension-0.10.0/exasol_transformers_extension/deployment/language_container.py

@@ -0,0 +1,105 @@
+import shutil
+import subprocess
+from pathlib import Path
+from typing import Dict, Optional
+
+from exasol_integration_test_docker_environment.lib.docker.images.image_info import ImageInfo
+from exasol_script_languages_container_tool.lib import api
+from exasol_script_languages_container_tool.lib.tasks.export.export_containers import ExportContainerResult
+
+
+def find_file_or_folder_backwards(name: str) -> Path:
+    current_path = Path(__file__).parent
+    result_path = None
+    while current_path != current_path.root:
+        result_path = Path(current_path, name)
+        if result_path.exists():
+            break
+        current_path = current_path.parent
+    if result_path is not None and result_path.exists():
+        return result_path
+    else:
+        raise RuntimeError(f"Could not find {name} when searching backwards from {Path(__file__).parent}")
+
+
+CONTAINER_NAME = "exasol_transformers_extension_container"
+
+
+def find_flavor_path() -> Path:
+    language_container_path = find_file_or_folder_backwards("language_container")
+    flavor_path = language_container_path / CONTAINER_NAME
+    return flavor_path
+
+
+def build_language_container(flavor_path: Path) -> Dict[str, ImageInfo]:
+    image_infos = api.build(flavor_path=(str(flavor_path),), goal=("release",))
+    return image_infos
+
+
+def export(flavor_path: Path,
+           export_path: Optional[Path] = None) -> ExportContainerResult:
+    if export_path is not None:
+        export_path = str(export_path)
+    export_result = api.export(flavor_path=(str(flavor_path),), export_path=export_path)
+    return export_result
+
+
+def upload(
+        flavor_path: Path,
+        bucketfs_name: str,
+        bucket_name: str,
+        database_host: str,
+        bucketfs_port: int,
+        user: str,
+        password: str,
+        path_in_bucket: str,
+        release_name: str
+):
+    api.upload(
+        flavor_path=(str(flavor_path),),
+        bucketfs_name=bucketfs_name,
+        bucket_name=bucket_name,
+        bucketfs_port=bucketfs_port,
+        database_host=database_host,
+        bucketfs_username=user,
+        bucketfs_password=password,
+        path_in_bucket=path_in_bucket,
+        release_name=release_name
+    )
+
+
+def prepare_flavor(flavor_path: Path):
+    flavor_base_path = flavor_path / "flavor_base"
+    add_requirements_to_flavor(flavor_base_path)
+    add_wheel_to_flavor(flavor_base_path)
+
+
+def find_project_directory():
+    project_directory = find_file_or_folder_backwards("pyproject.toml").parent
+    return project_directory
+
+
+def add_wheel_to_flavor(flavor_base_path):
+    project_directory = find_project_directory()
+    subprocess.call(["poetry", "build"], cwd=project_directory)
+    dist_path = project_directory / "dist"
+    wheels = list(dist_path.glob("*.whl"))
+    if len(wheels) != 1:
+        raise RuntimeError(f"Did not find exactly one wheel file in dist directory {dist_path}. "
+                           f"Found the following wheels: {wheels}")
+    wheel = wheels[0]
+    wheel_target = flavor_base_path / "release" / "dist"
+    wheel_target.mkdir(parents=True, exist_ok=True)
+    shutil.copyfile(wheel, wheel_target / wheel.name)
+
+
+def add_requirements_to_flavor(flavor_base_path: Path):
+    project_directory = find_project_directory()
+    requirements_bytes = subprocess.check_output(["poetry", "export", "--without-hashes", "--without-urls"],
+                                                 cwd=project_directory)
+    requirements = requirements_bytes.decode("UTF-8")
+    requirements_without_cuda = "\n".join(line
+                                          for line in requirements.splitlines()
+                                          if not line.startswith("nvidia"))
+    requirements_file = flavor_base_path / "dependencies" / "requirements.txt"
+    requirements_file.write_text(requirements_without_cuda)

exasol_transformers_extension-0.10.0/exasol_transformers_extension/deployment/language_container_deployer.py

@@ -0,0 +1,277 @@
+#########################################################
+# To be migrated to the script-languages-container-tool #
+#########################################################
+from enum import Enum
+from textwrap import dedent
+from typing import List, Optional
+from pathlib import Path, PurePosixPath
+import logging
+import tempfile
+import requests
+import ssl
+import pyexasol
+from exasol_bucketfs_utils_python.bucketfs_location import BucketFSLocation
+from exasol_transformers_extension.utils.bucketfs_operations import create_bucketfs_location
+
+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):
+    f"""
+    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]
+
+
+class LanguageContainerDeployer:
+
+    def __init__(self,
+                 pyexasol_connection: pyexasol.ExaConnection,
+                 language_alias: str,
+                 bucketfs_location: BucketFSLocation) -> None:
+
+        self._bucketfs_location = bucketfs_location
+        self._language_alias = language_alias
+        self._pyexasol_conn = pyexasol_connection
+        logger.debug(f"Init {LanguageContainerDeployer.__name__}")
+
+    def download_and_run(self, url: str,
+                         bucket_file_path: str,
+                         alter_system: bool = True,
+                         allow_override: bool = False) -> 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.
+        """
+
+        with tempfile.NamedTemporaryFile() as tmp_file:
+            response = requests.get(url, stream=True)
+            response.raise_for_status()
+            tmp_file.write(response.content)
+
+            self.run(Path(tmp_file.name), bucket_file_path, alter_system, allow_override)
+
+    def run(self, container_file: Optional[Path] = None,
+            bucket_file_path: Optional[str] = None,
+            alter_system: bool = True,
+            allow_override: bool = False) -> 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. This step may have to be skipped if the user does not have
+          System Privileges in the database. In that case two alternative activation SQL commands
+          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.
+        """
+
+        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)
+
+        if alter_system:
+            self.activate_container(bucket_file_path, LanguageActivationLevel.System, allow_override)
+        else:
+            message = dedent(f"""
+            In SQL, you can activate the SLC of the Transformers Extension
+            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:
+            self._bucketfs_location.upload_fileobj_to_bucketfs(
+                fileobj=f, bucket_file_path=bucket_file_path)
+        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 = self._bucketfs_location.generate_bucket_udf_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 = self._bucketfs_location.generate_bucket_udf_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, bucketfs_name: str, bucketfs_host: str, bucketfs_port: int,
+               bucketfs_use_https: bool, bucketfs_user: str,
+               bucketfs_password: str, bucket: str, path_in_bucket: str,
+               dsn: str, db_user: str, db_password: str, language_alias: 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":
+
+        websocket_sslopt = get_websocket_sslopt(use_ssl_cert_validation, ssl_trusted_ca,
+                                                ssl_client_certificate, ssl_private_key)
+
+        pyexasol_conn = pyexasol.connect(
+            dsn=dsn,
+            user=db_user,
+            password=db_password,
+            encryption=True,
+            websocket_sslopt=websocket_sslopt
+        )
+
+        bucketfs_location = create_bucketfs_location(
+            bucketfs_name, bucketfs_host, bucketfs_port, bucketfs_use_https,
+            bucketfs_user, bucketfs_password, bucket, path_in_bucket)
+
+        return cls(pyexasol_conn, language_alias, bucketfs_location)