vvk-jsl-inference 1.0__tar.gz

vvk_jsl_inference-1.0/LICENSE

@@ -0,0 +1,28 @@
+Copyright 2015-2025 © John Snow Labs Inc.
+
+This Software ("Software" or "Product") including code, design, documentation, configuration, models, tests, and related assets is owned by John Snow Labs Inc. All rights reserved.
+
+John Snow Labs Inc. ("we") is the only owner of the copyright for this Software.
+
+Unless otherwise specified in a separate Software License Agreement, Services Agreement, or End User License Agreement that you have executed directly with John Snow Labs Inc.:
+
+* You are NOT granted any license or right to use the Software in any way.
+* You are NOT granted any license or right to retain a copy of this Software.
+* You are NOT granted any license or right to change, modify, adapt, or translate the Software.
+* You are NOT granted any license or right to sell, assign, rent, exchange, lend, lease, sublease, or redistribute the Software.
+* You are NOT granted any license or rights to bundle, repackage, or include the Software with any software in any way.
+* The Software is Confidential and Proprietary. You are NOT allowed to distribute copies of the Software to others by any means whatsoever.
+* The Software does NOT come with any warranty, express or implied.
+* It is NOT legal to create derivative works based on the Software.
+* It is NOT legal to claim any title in the Software or any of its derivatives.
+* It is NOT legal to reverse engineer, disassemble or decompile the Software.
+* It is NOT legal to make or retain a copy of the Software.
+* We have no liability whatsoever for use of the Software.
+* You may not make any public statements about this Software or John Snow Labs without explicit written permission from John Snow Labs.
+* You must retain a copy of this notice without changes along with every copy of the Software, even if you have a license for it.
+
+Unless required by applicable law or agreed to in writing, John Snow Labs provides the Software on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied, including, without limitation, any warranties or conditions of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A PARTICULAR PURPOSE. You are solely responsible for determining the appropriateness of using or redistributing the Software and assume any risks associated with Your exercise of permissions under this license.
+
+In no event and under no legal theory, whether in tort (including negligence), contract, or otherwise, unless required by applicable law (such as deliberate and grossly negligent acts) or agreed to in writing, shall John Snow Labs be liable to You for damages, including any direct, indirect, special, incidental, or consequential damages of any character arising as a result of this license or out of the use or inability to use the Software (including but not limited to damages for loss of goodwill, work stoppage, computer failure or malfunction, or any and all other commercial damages or losses), even if advised of the possibility of such damages.
+
+Unless required by applicable law or agreed to in writing, Software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

vvk_jsl_inference-1.0/PKG-INFO

@@ -0,0 +1,58 @@
+Metadata-Version: 2.4
+Name: vvk_jsl_inference
+Version: 1.0
+Maintainer-email: Vivek Shrestha <vivek@johnsnowlabs.com>
+License: Copyright 2015-2025 © John Snow Labs Inc.
+        
+        This Software ("Software" or "Product") including code, design, documentation, configuration, models, tests, and related assets is owned by John Snow Labs Inc. All rights reserved.
+        
+        John Snow Labs Inc. ("we") is the only owner of the copyright for this Software.
+        
+        Unless otherwise specified in a separate Software License Agreement, Services Agreement, or End User License Agreement that you have executed directly with John Snow Labs Inc.:
+        
+        * You are NOT granted any license or right to use the Software in any way.
+        * You are NOT granted any license or right to retain a copy of this Software.
+        * You are NOT granted any license or right to change, modify, adapt, or translate the Software.
+        * You are NOT granted any license or right to sell, assign, rent, exchange, lend, lease, sublease, or redistribute the Software.
+        * You are NOT granted any license or rights to bundle, repackage, or include the Software with any software in any way.
+        * The Software is Confidential and Proprietary. You are NOT allowed to distribute copies of the Software to others by any means whatsoever.
+        * The Software does NOT come with any warranty, express or implied.
+        * It is NOT legal to create derivative works based on the Software.
+        * It is NOT legal to claim any title in the Software or any of its derivatives.
+        * It is NOT legal to reverse engineer, disassemble or decompile the Software.
+        * It is NOT legal to make or retain a copy of the Software.
+        * We have no liability whatsoever for use of the Software.
+        * You may not make any public statements about this Software or John Snow Labs without explicit written permission from John Snow Labs.
+        * You must retain a copy of this notice without changes along with every copy of the Software, even if you have a license for it.
+        
+        Unless required by applicable law or agreed to in writing, John Snow Labs provides the Software on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied, including, without limitation, any warranties or conditions of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A PARTICULAR PURPOSE. You are solely responsible for determining the appropriateness of using or redistributing the Software and assume any risks associated with Your exercise of permissions under this license.
+        
+        In no event and under no legal theory, whether in tort (including negligence), contract, or otherwise, unless required by applicable law (such as deliberate and grossly negligent acts) or agreed to in writing, shall John Snow Labs be liable to You for damages, including any direct, indirect, special, incidental, or consequential damages of any character arising as a result of this license or out of the use or inability to use the Software (including but not limited to damages for loss of goodwill, work stoppage, computer failure or malfunction, or any and all other commercial damages or losses), even if advised of the possibility of such damages.
+        
+        Unless required by applicable law or agreed to in writing, Software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+        
+Requires-Python: >=3.8
+License-File: LICENSE
+Requires-Dist: click<9.0.0,>=8.1.8
+Requires-Dist: johnsnowlabs<7.0.0,>=6.2.0
+Requires-Dist: fastapi<1.0.0,>=0.115.6
+Requires-Dist: uvicorn<1.0.0,>=0.33.0
+Requires-Dist: uvloop<1.0.0,>=0.21.0
+Requires-Dist: httptools<1.0.0,>=0.6.4
+Requires-Dist: cloudpickle<4.0.0,>=3.0.0
+Requires-Dist: psutil<8.0.0,>=7.2.2
+Provides-Extra: dev
+Requires-Dist: pytest>=8.3.4; extra == "dev"
+Requires-Dist: pytest-mock>=3.14.0; extra == "dev"
+Requires-Dist: pytest-cov>=5.0.0; extra == "dev"
+Requires-Dist: httpx; extra == "dev"
+Requires-Dist: black; extra == "dev"
+Requires-Dist: ruff; extra == "dev"
+Requires-Dist: snowflake.core; extra == "dev"
+Requires-Dist: pytest-asyncio; extra == "dev"
+Provides-Extra: docs
+Requires-Dist: mkdocs>=1.6.1; extra == "docs"
+Requires-Dist: mkdocs-click>=0.8.1; extra == "docs"
+Requires-Dist: mkdocs-material>=9.7.6; extra == "docs"
+Requires-Dist: mkdocstrings[python]>=0.18; extra == "docs"
+Dynamic: license-file

vvk_jsl_inference-1.0/README.md

@@ -0,0 +1,139 @@
+# endpoints
+
+
+## Development
+
+### Pre-requisites
+
+- Python 3.8 or higher
+- Docker
+- A valid JSL License
+
+### Setup
+ 
+```bash
+make install-dev
+```
+
+### CLI
+
+The `jsl_inference` CLI provides commands to deploy John Snow Labs healthcare NLP models to AWS SageMaker and Snowflake platforms.
+
+**Get started with the CLI:**
+
+```bash
+# View all available commands
+jsl_inference --help
+
+# View SageMaker-specific commands
+jsl_inference sagemaker --help
+
+# View Snowflake-specific commands  
+jsl_inference snowflake --help
+```
+
+**Example usage:**
+
+```bash
+# Deploy a clinical deidentification model to SageMaker
+jsl_inference sagemaker deploy clinical_deidentification_docwise_wip \
+  --endpoint-name my-clinical-model \
+  --instance-type ml.m5.large
+
+# Run a model locally for testing
+jsl_inference serve clinical_deidentification_docwise_wip --port 8080
+
+# Deploy to Snowflake with container services
+jsl_inference snowflake deploy clinical_deidentification_docwise_wip \
+  --service-name prediction_service \
+  --compute-pool-name my_compute_pool
+```
+
+
+
+## Docs
+
+Documentation is served using MkDocs. To view the documentation, run:
+
+```bash
+make docs
+```
+This will start a local development server and serve the documentation at `http://127.0.0.1:8000/`. The server will automatically reload when documentation files are modified.
+
+## Testing
+
+Tests are run via the Makefile which handles virtual environment setup and dependency installation automatically.
+
+To run the tests, use one of the following commands:
+
+```bash
+# Run tests (installs dependencies automatically)
+make test
+
+# Run tests with verbose output
+make test-verbose
+
+# Run tests with coverage report
+make test-coverage
+```
+
+Alternatively, if you prefer to manage dependencies manually:
+```bash
+pip install -e .[dev]
+pytest
+```
+
+## Publishing
+
+### Prerequisites
+Before publishing to PyPI, ensure you have:
+- `TWINE_PASSWORD` environment variable set with your PyPI API token
+- Appropriate permissions to publish the package
+
+### Version Management
+To update the package version, modify the `__version__` variable in `endpoints/__about__.py`:
+
+```python
+__version__ = "x.y.z"
+```
+
+### Publishing to PyPI
+Once the version is updated and prerequisites are met, publish the package:
+
+```bash
+make publish
+```
+
+This command will build the package and upload it to PyPI using twine.
+
+### Toolkit
+
+To get some information on the available models and its details, use this helper command
+
+<small>Please make sure to install dependencies before. See tools/requirements.txt </small>
+```bash
+ python tools/models_info.py
+```
+You can also refer the help for this toolkit
+
+```bash
+ python tools/models_info.py --help
+```
+
+### Run tests for models
+
+Execute tests for a single model classed in johnsnowlabs. Example 
+```shell
+pytest -q tests/johnsnowlabs/models/test_extract_entities.py
+```
+
+
+
+## Databricks Development (Needs to fixed)
+
+see `databricks_tests.py` 
+1. Start up a Databricks Cluster producer. Once Started you must **manually enable it to Unity Catalog**
+2. Submit publisher job
+3. Once completed, need to go to provider UI and publish the model to either private or public exchange
+4. Once published, **you must manually import the listing on consumer end form the UI and accept the Terms of usage**. Then model can be tested via consumer jobs
+

vvk_jsl_inference-1.0/endpoints/__about__.py

@@ -0,0 +1 @@
+__version__ = "1.0"

vvk_jsl_inference-1.0/endpoints/__init__.py

@@ -0,0 +1,33 @@
+"""JSL Inference Module"""
+
+from enum import Enum
+
+
+class ModelType(str, Enum):
+    LOCAL = "local"
+    PRETRAINED_HEALTHCARE = "pretrained_healthcare"
+    PRETRAINED_VISUAL = "pretrained_visual"
+    CHROMADB_RESOLVER = "chromadb_resolver"
+
+
+class Platform(str, Enum):
+    SAGEMAKER = "sagemaker"
+    SNOWFLAKE = "snowflake"
+    LOCAL = "local"
+
+    def get_python_requirements(self):
+        if self == Platform.SNOWFLAKE:
+            return ["snowflake.core"]
+        return []
+
+
+class JslInferenceException(Exception):
+    """Exception for JSL Inference errors"""
+
+    pass
+
+
+class JslLicenseException(Exception):
+    """Exception for JSL License errors"""
+
+    pass

vvk_jsl_inference-1.0/endpoints/cli/__init__.py

@@ -0,0 +1,9 @@
+from endpoints.logging import init_logging
+
+from .internals import run_local
+
+init_logging()
+
+from .cli import cli
+
+__all__ = ["cli", "run_local"]

vvk_jsl_inference-1.0/endpoints/cli/cli.py

@@ -0,0 +1,131 @@
+from typing import Optional
+
+import click
+
+from endpoints import Platform
+from endpoints.core.exceptions import ModelRegistryException
+from endpoints.sagemaker.cli import sagemaker
+
+from . import internals
+
+
+@click.group()
+def cli():
+    """
+    John Snow Labs Endpoints CLI - Deploy and manage JSL models across platforms.
+
+    This command-line interface provides tools for deploying John Snow Labs models
+    to various cloud platforms and running local inference servers. It supports
+    multiple deployment targets including SageMaker, Snowflake, and local development.
+
+    Use the subcommands to deploy to specific platforms or start a local server
+    for development and testing purposes.
+
+    Examples:
+
+        # Start a local inference server
+        endpoints serve my-model-name
+
+        # Deploy to SageMaker
+        endpoints sagemaker deploy my-model-name
+
+        # Deploy to Snowflake
+        endpoints snowflake deploy my-model-name
+    """
+    pass
+
+
+@cli.command()
+@click.argument("model_id")
+@click.option(
+    "--language", required=False, default="en", help="The language of the model"
+)
+@click.option("--port", required=False, default=8080)
+@click.option("--api-server-count", type=int, required=False, default=None)
+@click.option("--load-from-disk", is_flag=True, show_default=True, default=False)
+def serve(
+    model_id: str,
+    language: str,
+    port: int,
+    api_server_count: Optional[int],
+    load_from_disk: bool = False,
+):
+    """
+    Start a local JSL Inference Server for development and testing.
+
+    This command launches a local inference server that can be used for development,
+    testing, and prototyping with John Snow Labs models. The server provides REST
+    API endpoints for model inference and can be accessed via HTTP requests.
+
+    Args:
+        model_id: The identifier of the JSL model to serve. This should be a valid
+            model name from the John Snow Labs model repository.
+
+    Options:
+        --language: The language variant of the model (default: "en").
+        --port: The port number for the local server (default: 8080).
+        --api-server-count: Number of Uvicorn workers.
+        --load-from-disk: Download the model to MODEL_LOCATION (/opt/ml/model) and
+            load it from disk (default: False).
+
+    Examples:
+        # Start server with default settings
+        endpoints serve ner_dl_bert
+
+        # Start server on custom port with Spanish model
+        endpoints serve ner_dl_bert --language es --port 9000
+
+        # Start multilingual model
+        endpoints serve multilingual_ner --language xx
+    """
+    try:
+        internals.run_local(
+            model_id=model_id,
+            language=language,
+            platform=Platform.LOCAL,
+            port=port,
+            api_server_count=api_server_count,
+            load_from_disk=load_from_disk,
+        )
+    except ModelRegistryException as e:
+        click.echo(e)
+
+
+@cli.command()
+@click.option(
+    "--language", required=False, default=None, help="The language of the model"
+)
+@click.option("--type", required=False, default=None)
+def list_models(language: str, type: str):
+    """
+    List models registered in models registry.
+
+    Options:
+        --language: The language variant of the model (example: "en", "it", "es").
+        --type: Model type. One of the following: local, pretrained_healthcare, pretrained_visual, chromadb_resolver
+
+    Examples:
+        # List models registered in models registry
+        jsl_inference list-models
+        # Filter by type
+        jsl_inference list-models --type local
+        # Filter by language
+        jsl_inference list-models --language en
+    """
+    results = internals.list_models(language=language, type=type)
+    click.echo_via_pager("\n".join(results))
+
+
+cli.add_command(sagemaker)
+
+try:
+    from endpoints.snowflake.cli import snowflake
+
+    cli.add_command(snowflake)
+except ImportError:
+    pass
+
+if __name__ == "__main__":
+    from endpoints.cli import *
+
+    cli()

vvk_jsl_inference-1.0/endpoints/cli/internals.py

@@ -0,0 +1,80 @@
+from difflib import get_close_matches
+from typing import List, Optional
+
+from endpoints import Platform
+from endpoints.core.exceptions import ModelRegistryException
+
+
+def run_local(
+    model_id: str,
+    language: str,
+    platform: Platform,
+    port: int = 8080,
+    api_server_count: Optional[int] = None,
+    load_from_disk: bool = False,
+) -> None:
+    """Run a model locally using the endpoints server.
+
+    Args:
+        model_id: Identifier of the model to run.
+        language: Language key used to resolve the model.
+        platform: Platform configuration used for local serving.
+        port: Port number for the local server.
+        api_server_count: Number of API workers to start.
+
+    Returns:
+        None
+    """
+    from endpoints.core import ModelRegistry
+    from endpoints.server import serve, setup_env
+
+    try:
+        model = ModelRegistry.find(model_id, language)
+        setup_env(model=model, platform=platform, store_model=load_from_disk)
+
+        serve(model=model, platform=platform, port=port, workers=api_server_count)
+    except ModelRegistryException as e:
+        matches = get_close_matches(
+            model_id, ModelRegistry._key_to_models.keys(), n=3, cutoff=0.5
+        )
+        matched_model = [ModelRegistry.get_by_key(match) for match in matches]
+        similar_strings = "\n- ".join(
+            [
+                f"ModelId: {model.model_id} Language: {model.language}"
+                for model in matched_model
+            ]
+        )
+        raise ModelRegistryException(
+            f"Model {model_id} not found. Did you mean? \n- {similar_strings}"
+        )
+
+
+def list_models(type: str, language: str) -> List[str]:
+    """List registered models
+
+    Args:
+        type: Type of model.
+        language: Language of model.
+
+    Returns:
+        List mode model.key
+    """
+    from endpoints.core import ModelRegistry
+
+    if type:
+        from endpoints import ModelType
+
+        t_enum = ModelType(type)
+    else:
+        t_enum = None
+
+    models = ModelRegistry.filter(model_type=t_enum, language=language)
+    models = [
+        (
+            f"Model ID:{model.model_id}"
+            if model.language == "en"
+            else f"Model ID:{model.model_id}, Language: {model.language}"
+        )
+        for model in models
+    ]
+    return models

vvk_jsl_inference-1.0/endpoints/cli/options.py

@@ -0,0 +1,32 @@
+import click
+
+from endpoints.settings import DEFAULT_JOHNSNOWLABS_VERSION
+
+
+def common_options(f):
+    """
+    A decorator to add common CLI options for SageMaker commands, including:
+    - Model argument (required).
+    - John Snow Labs version.
+    - Flags to store license and model in the Docker image.
+    """
+    f = click.argument("model_id")(f)
+    f = click.option(
+        "--johnsnowlabs-version",
+        default=DEFAULT_JOHNSNOWLABS_VERSION,
+        help=f"Version of the John Snow Labs library (default: {DEFAULT_JOHNSNOWLABS_VERSION})",
+    )(f)
+    f = click.option(
+        "--language",
+        default="en",
+        help="Language of the model (default: en)",
+    )(f)
+    f = click.option(
+        "--no-license",
+        is_flag=True,
+        default=False,
+        show_default=True,
+        help="Do not include the license file in the Docker image. Default: False",
+    )(f)
+
+    return f

vvk_jsl_inference-1.0/endpoints/container/Dockerfile

@@ -0,0 +1,45 @@
+FROM ubuntu:22.04 AS jsl_build
+ENV PYSPARK_PYTHON=python3
+ENV PYSPARK_DRIVER_PYTHON=python3
+ENV DEBIAN_FRONTEND=noninteractive
+ENV TF_CPP_MIN_LOG_LEVEL='3'
+ENV JAVA_HOME=/usr/lib/jvm/java-17-openjdk-amd64/
+RUN echo "export JAVA_HOME=/usr/lib/jvm/java-17-openjdk-amd64/" >> ~/.bashrc
+ENV LC_ALL=C.UTF-8 LANG=C.UTF-8
+
+RUN apt-get update && apt-get install --no-install-recommends -y \
+        openjdk-17-jdk-headless \
+        python3 python3-pip python3-packaging\
+        curl && apt-get clean && rm -rf /var/lib/apt/lists/* /tmp/* /var/tmp/*
+
+COPY requirements.txt .
+RUN --mount=type=cache,target=/root/.cache/pip pip install -r requirements.txt
+RUN rm -rf /root/.cache
+
+
+FROM jsl_build AS dependencies
+ENV JSL_MODEL_REGISTRY_HOME=/root/.jsl_inference/model_registry/
+RUN mkdir -p /opt/ml/model
+
+{{COPY_ARTIFACTS_INSTRUCTION}}
+
+COPY --from=jsl_model_registry . $JSL_MODEL_REGISTRY_HOME
+
+RUN --mount=type=secret,id=license --mount=type=bind,rw,from=jsl_cache_pretrained,source=.,target=/root/cache_pretrained {{SETUP_ENVIRONMENT}}
+
+
+FROM jsl_build AS final_build
+{{ENVIRONMENT_VARIABLES}}
+
+WORKDIR /app
+ENV JSL_MODEL_REGISTRY_HOME=/root/.jsl_inference/model_registry/
+COPY LICENSE .
+ENV PYTHONPATH=/app
+COPY --from=jsl_model_registry . $JSL_MODEL_REGISTRY_HOME
+COPY --from=dependencies /usr/local/lib/python3.10/dist-packages/ /usr/local/lib/python3.10/dist-packages/
+COPY --from=dependencies /root/.johnsnowlabs/ /root/.johnsnowlabs
+COPY --from=dependencies /opt/ml/model/ /opt/ml/model/
+RUN pip install pyspark==3.5.0 --upgrade
+RUN rm /usr/local/lib/python3.10/dist-packages/pyspark/jars/libthrift-0.12.0.jar
+
+{{ENTRYPOINT}}

vvk_jsl_inference-1.0/endpoints/container/__init__.py

@@ -0,0 +1,66 @@
+"""Container module for serving inference models in Docker environments.
+
+This module provides functionality for containerizing and serving machine learning
+models using Docker. It includes utilities for building Docker images, generating
+Docker files, and setting up container environments for model inference.
+
+The module supports various deployment platforms and provides a standardized way
+to package and deploy models in containerized environments.
+"""
+
+from typing import Optional
+
+from endpoints.server import find_model_to_serve, serve
+from endpoints.settings import config
+
+from .setup import setup_container_env
+from .utils import (
+    build_docker_image,
+    format_docker_image_name,
+    format_image_tag,
+    generate_docker_files,
+    validate_docker_image_name,
+    validate_image_tag,
+)
+
+
+# Default entrypoint for the Docker containers
+def _init(command, model_id: Optional[str], language: Optional[str]):
+    """Initialize and execute commands for containerized model serving.
+
+    This function serves as the main entrypoint for Docker containers, handling
+    different commands for model operations. Currently supports serving models
+    for inference.
+
+    Args:
+        command: The command to execute ('serve' for model serving).
+        model_id (str): Unique identifier for the model to be loaded.
+        language (str): Programming language or model language specification.
+
+    Raises:
+        NotImplementedError: If the provided command is not implemented.
+
+    Example:
+        >>> _init('serve', 'bert-base-uncased', 'en')
+        # Starts serving the specified model
+    """
+    # For Sagemaker, serve and train are the possible commands
+    if command == "serve":
+        model = find_model_to_serve(model_id=model_id, language=language)
+        serve(
+            model=model,
+            platform=config.platform,
+        )
+    else:
+        raise NotImplementedError("Command not implemented")
+
+
+__all__ = [
+    "build_docker_image",
+    "generate_docker_files",
+    "setup_container_env",
+    "format_image_tag",
+    "format_docker_image_name",
+    "validate_docker_image_name",
+    "validate_image_tag",
+]

vvk_jsl_inference-1.0/endpoints/container/requests.py

@@ -0,0 +1,27 @@
+import dataclasses
+from uuid import uuid4
+
+from endpoints import Platform
+from endpoints.core import ModelInfo
+from endpoints.settings import DEFAULT_JOHNSNOWLABS_VERSION
+
+
+@dataclasses.dataclass
+class CommonParams:
+    model: ModelInfo
+    johnsnowlabs_version: str = DEFAULT_JOHNSNOWLABS_VERSION
+    no_license: bool = False
+    store_model: bool = False
+    language: str = "en"
+    platform: Platform = Platform.SAGEMAKER
+
+
+@dataclasses.dataclass(init=False)
+class GenerateDockerFilesRequest(CommonParams):
+    output_dir: str = f"/tmp/{uuid4()}"
+
+    def __init__(self, **kwargs):
+        names = set([f.name for f in dataclasses.fields(self)])
+        for k, v in kwargs.items():
+            if k in names and v is not None:
+                setattr(self, k, v)