altasigma 0.0.4.post2__tar.gz

altasigma-0.0.4.post2/LICENSE

@@ -0,0 +1,2 @@
+Copyright (c) 2025 AltaSigma GmbH
+All rights reserved.

altasigma-0.0.4.post2/MANIFEST.in

@@ -0,0 +1,2 @@
+include README_pypi.md
+exclude README.md

altasigma-0.0.4.post2/PKG-INFO

@@ -0,0 +1,51 @@
+Metadata-Version: 2.4
+Name: altasigma
+Version: 0.0.4.post2
+Summary: Python helpers for data science and ML workflows on the AltaSigma AI platform
+Home-page: https://www.altasigma.com
+Author: AltaSigma GmbH
+Author-email: pypi@altasigma.com
+License: Proprietary
+Classifier: License :: Other/Proprietary License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: requests<3,>=2
+Requires-Dist: pandas>=1
+Requires-Dist: ipython>=8
+Requires-Dist: boto3<2,>=1.18.49
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: license
+Dynamic: license-file
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
+
+# AltaSigma Python Package
+
+A Python library for working with the AltaSigma AI platform.
+This package provides convenient tools for data scientists and developers to manage data,
+credentials, and ML workflows on AltaSigma infrastructure.
+
+## What is AltaSigma?
+
+AltaSigma is an AI platform that provides managed infrastructure for data science and machine learning workloads.
+Check https://www.altasigma.com/ to learn more.
+
+## What does this package do?
+
+This helper library simplifies common tasks when working on AltaSigma:
+
+- **Data Access**: Read and write data from AltaSigma data sources
+- **Credential Management**: Handle authentication tokens and credentials securely
+- **Job Supervision**: Manage training, evaluation, and prediction workflows
+- **Configuration**: Environment-aware settings for different job types
+- **Progress Tracking**: Report progress for long-running operations

altasigma-0.0.4.post2/README_pypi.md

@@ -0,0 +1,20 @@
+# AltaSigma Python Package
+
+A Python library for working with the AltaSigma AI platform.
+This package provides convenient tools for data scientists and developers to manage data,
+credentials, and ML workflows on AltaSigma infrastructure.
+
+## What is AltaSigma?
+
+AltaSigma is an AI platform that provides managed infrastructure for data science and machine learning workloads.
+Check https://www.altasigma.com/ to learn more.
+
+## What does this package do?
+
+This helper library simplifies common tasks when working on AltaSigma:
+
+- **Data Access**: Read and write data from AltaSigma data sources
+- **Credential Management**: Handle authentication tokens and credentials securely
+- **Job Supervision**: Manage training, evaluation, and prediction workflows
+- **Configuration**: Environment-aware settings for different job types
+- **Progress Tracking**: Report progress for long-running operations

altasigma-0.0.4.post2/altasigma/__init__.py

@@ -0,0 +1,35 @@
+"""AltaSigma package for data management and processing.
+
+This package provides tools for credential management, data source operations,
+configuration management, and job supervision.
+
+The public API components are explicitly imported and exposed at the package level.
+Users should import components directly from the `altasigma` package rather than
+from individual submodules.
+
+Examples:
+    Recommended import style:
+    
+    >>> from altasigma import CredentialUtils, AltaSigma, S3DataSource
+    
+    Avoid importing from submodules directly:
+    
+    >>> # Not recommended
+    >>> from altasigma.credentials.credential_utils import CredentialUtils
+
+Note:
+    Only components explicitly imported in this file are considered part of the
+    public API. Other components within submodules should be treated as internal
+    implementation details that may change without notice.
+
+    The only exception to that is altasigma.spark_session.spark_session_util, which contains
+    imports from pyspark. Not importing it here makes pyspark an optional dependency.
+"""
+from altasigma.credentials.credential_utils import CredentialUtils
+from altasigma.initialize import AltaSigma, initialize
+from altasigma.io.data_management import S3DataSource, Bucket, CassandraDataSource, BiographyInfo, BiographyInfoEntry, TextEntry, S3PathEntry, S3Data, CassandraTableEntry, CassandraData, get_datasource
+from altasigma.config.config import RunEnv, JobType
+from altasigma.jobsupervisor.reports import dataframe_to_table_report_data
+# Spark is an optional dependency. If we add an import here it is no longer optional
+# from altasigma.spark_session.spark_session_util import get_spark_session
+from altasigma.progress_reporter.progress_reporter import ProgressReporter

altasigma-0.0.4.post2/altasigma/config/__init__.py

@@ -0,0 +1,6 @@
+"""
+Python module for configuration management in AltaSigma Modules.
+
+This module defines job types, environment settings, and configuration classes
+for various components of the system.
+"""

altasigma-0.0.4.post2/altasigma/config/config.py

@@ -0,0 +1,306 @@
+"""
+Python module for configuration management in AltaSigma Modules.
+
+This module defines job types, environment settings, and configuration classes
+for various components of the system.
+"""
+import logging
+import os
+import sys
+import threading
+from datetime import datetime
+from dataclasses import dataclass
+from enum import Enum
+
+
+from ..credentials.credential_utils import _credential_utils
+from ..credentials.token_refresher import TokenRefresher
+
+logger = logging.getLogger(__name__)
+
+
+class JobType(Enum):
+    """Enumeration of job types for Modules/Augurs.
+
+    Attributes:
+        Learning (str): Job type for learning jobs.
+        Evaluation (str): Job type for evaluation jobs.
+        Prediction (str): Job type for prediction jobs.
+        RealtimeScoring (str): Job type for real-time prediction jobs.
+    """
+    Learning = "learning"
+    Evaluation = "evaluation"
+    Prediction = "prediction"
+    RealtimeScoring = "realtime-scoring"
+
+    @classmethod
+    def from_name(cls, name):
+        """Converts a string name to its corresponding JobType enum.
+
+        Args:
+            name (str): The string name of the job type.
+
+        Returns:
+            JobType: The corresponding JobType enum.
+
+        Raises:
+            ValueError: If the provided name does not match any JobType.
+        """
+        for enum in JobType.__members__.values():
+            if enum.value == name:
+                return enum
+        raise ValueError(f"{name} is not a valid JobType name.")
+
+    def to_name(self):
+        """Gets the string representation of the job type.
+
+        Returns:
+            str: The string name of the job type.
+        """
+        return self.value
+
+    def is_batch_job(self):
+        """Determines if the job type is a batch job.
+
+        Returns:
+            bool: True if the job type is Learning, Evaluation, or Prediction, False otherwise.
+        """
+        return self in [JobType.Learning, JobType.Evaluation, JobType.Prediction]
+
+    def is_passed_model_in_env_in_prod(self):
+        """Determines if the job type is passed a model in the production environment.
+
+        Returns:
+            bool: True if the job type is RealtimeScoring, False otherwise.
+        """
+        return self in [JobType.RealtimeScoring]
+
+    def is_passed_model_in_env_in_dev(self):
+        """Determines if the job type is passed a model in the development environment.
+
+        Returns:
+            bool: True if the job type is Evaluation, Prediction, or RealtimeScoring, False otherwise.
+        """
+        return self in [JobType.Evaluation, JobType.Prediction, JobType.RealtimeScoring]
+
+
+class RunEnv(Enum):
+    """Enumeration of running environments.
+
+    Attributes:
+        Dev (str): Development environment.
+        Prod (str): Production environment.
+    """
+    Dev = "dev"
+    Prod = "prod"
+
+    @classmethod
+    def from_name(cls, name):
+        """Converts a string name to its corresponding RunEnv enum.
+
+        Args:
+            name (str): The string name of the run environment.
+
+        Returns:
+            RunEnv: The corresponding RunEnv enum.
+
+        Raises:
+            ValueError: If the provided name does not match any RunEnv.
+        """
+        for enum in RunEnv.__members__.values():
+            if enum.value == name:
+                return enum
+        raise ValueError(f"{name} is not a valid RunEnv name.")
+
+    def to_name(self):
+        """Gets the string representation of the run environment.
+
+        Returns:
+            str: The string name of the run environment.
+        """
+        return self.value
+
+
+@dataclass()
+class JobConfig:
+    """Configuration for a job.
+
+    Attributes:
+        augur_code (str): Identifier for the augur.
+        job_type (JobType): Type of the job.
+        job_code (str | None): Identifier for the job, None if not a batch job.
+        model_code (str, optional): Identifier for the model. None at the start if JobType.Learning.
+            Defaults to None.
+        settings_code (str, optional): Identifier for settings. Only set for realtime_prediction. 
+            Defaults to None.
+        realtime_server_host (str, optional): Host for the realtime server. Defaults to None.
+        realtime_server_port (str, optional): Port for the realtime server. Defaults to None.
+    """
+    augur_code: str
+    job_type: JobType
+    # None if not a batch job
+    job_code: str | None
+    # None at the start if JobType.Learning, because that creates a model_code, which will be received from the JobSupervisor
+    model_code: str = None
+    # Only set for realtime_prediction since that needs a stable identifier
+    settings_code: str = None
+    realtime_server_host: str = None
+    realtime_server_port: str = None
+
+
+@dataclass(frozen=True)
+class DashboardConfig:
+    """Configuration for the dashboard API.
+
+    Attributes:
+        api_host (str): Hostname for the dashboard API.
+        api_port (int): Port number for the dashboard API.
+    """
+    api_host: str
+    api_port: int
+
+
+@dataclass(frozen=True)
+class DataManConfig:
+    """Configuration for the data management API.
+
+    Attributes:
+        api_host (str): Hostname for the data management API.
+        api_port (int): Port number for the data management API.
+    """
+    api_host: str
+    api_port: int
+
+
+def generate_dev_job_code(job_type: JobType) -> str:
+    """Generates a job code for development environment.
+
+    Creates a job code based on current timestamp and job type.
+
+    Args:
+        job_type (JobType): Type of the job.
+
+    Returns:
+        str: A generated job code string.
+    """
+    return f'{datetime.now().strftime("%Y%m%dT%H%M%SZ")}_{job_type.to_name().upper()}'
+
+
+@dataclass
+class ModuleConfig:
+    """Main configuration class for the module.
+
+    This class holds all configuration parameters for the module,
+    including job, dashboard, and data management configurations.
+
+    Attributes:
+        run_env (RunEnv): Running environment, either "dev" or "prod".
+        job (JobConfig): Job configuration.
+        dashboard (DashboardConfig | None): Dashboard API configuration.
+        data_man (DataManConfig | None): Data management API configuration.
+        package_log_level (int): Logging level for the package.
+        root_log_level (int): Root logging level.
+    """
+    # "dev" | "prod"
+    run_env: RunEnv
+
+    job: JobConfig
+    dashboard: DashboardConfig | None
+    data_man: DataManConfig | None
+
+    package_log_level: int
+    root_log_level: int
+
+    def __init__(self):
+        """Initializes a ModuleConfig instance.
+
+        Loads configuration from environment variables and sets up the necessary
+        configurations for job processing, dashboard, and data management.
+        """
+        # General config parameters
+        realtime_server_host = os.environ.get("JOB_ARG_REALTIME_SERVER_HOST", "0.0.0.0")
+        realtime_server_port = os.environ.get("JOB_ARG_REALTIME_SERVER_PORT", 5000)
+
+        # Always given
+        self.run_env = RunEnv.from_name(os.environ["JOB_ENV"])
+        job_type = JobType.from_name(os.environ["JOB_ARG_JOB_TYPE"])
+
+        # Always either set, can be generated or not required
+        augur_code = None
+        if self.run_env == RunEnv.Prod:
+            augur_code = os.environ["JOB_ARG_AUGUR_CODE"]
+        job_code = None
+        if job_type.is_batch_job():
+            if self.run_env == RunEnv.Prod:
+                job_code = os.environ["JOB_ARG_JOB_CODE"]
+            elif self.run_env == RunEnv.Dev:
+                job_code = generate_dev_job_code(job_type)
+
+        model_code = None
+        if (self.run_env == RunEnv.Prod and job_type.is_passed_model_in_env_in_prod()) or (
+                self.run_env == RunEnv.Dev and job_type.is_passed_model_in_env_in_dev()):
+            model_code = os.environ["JOB_ARG_MODEL_CODE"]
+
+        settings_code = None
+        if self.run_env == RunEnv.Prod and job_type == JobType.RealtimeScoring:
+            settings_code = os.environ["JOB_ARG_SETTINGS_CODE"]
+
+        self.job = JobConfig(
+            augur_code=augur_code,
+            job_type=job_type,
+            job_code=job_code,
+            model_code=model_code,
+            settings_code=settings_code,
+            realtime_server_host=realtime_server_host,
+            realtime_server_port=realtime_server_port
+        )
+        if self.run_env == RunEnv.Prod:
+            self.dashboard = DashboardConfig(os.environ["DASHBOARD_API_HOST"], os.environ["DASHBOARD_API_PORT"])
+        self.data_man = _data_man_config()
+
+        # In Code Capsule run jobs this is actually added by the orchestration, but it's also just hardcoded there.
+        # Seems pointless to add it to the augur jobs too, just to satisfy the way the CredentialUtils is written
+        os.environ["CLIENT_ID"] = "altasigma-frontend"
+        if self.run_env == RunEnv.Dev:
+            # In the workbench we need to override some things to make it fit with the CredentialsUtils, which otherwise would assume the Code Capsule + Device Auth Flow
+            # Write the refresh token into the tmp file, because we neither do the device flow, nor have the mounted secret with a refresh token
+            refresh_token = os.environ.get("AS_TOKEN")
+            _credential_utils()._write_tokens_to_file("", refresh_token)
+
+            # Fix client secret for non-device auth flow
+            try:
+                del os.environ['CLIENT_SECRET']
+            except Exception as e:
+                logger.warning(f"Unexpected error deleting environment variable CLIENT_SECRET: {e}")
+
+        TokenRefresher().schedule_refresh()
+
+
+module_config = None
+data_man_config = None
+
+def _module_config():
+    """Gets or creates the module configuration.
+
+    Returns:
+        ModuleConfig: The module configuration instance.
+    """
+    global module_config
+    if module_config is not None:
+        return module_config
+    else:
+        module_config = ModuleConfig()
+        return module_config
+
+def _data_man_config():
+    """Gets or creates the data management configuration.
+
+    Returns:
+        DataManConfig: The data management configuration instance.
+    """
+    global data_man_config
+    if data_man_config is not None:
+        return data_man_config
+    else:
+        data_man_config = DataManConfig(os.environ["DATA_MAN_API_HOST"], os.environ["DATA_MAN_API_PORT"])
+        return data_man_config

altasigma-0.0.4.post2/altasigma/config/http_session.py

@@ -0,0 +1,67 @@
+"""
+HTTP Session Configuration Module
+
+This module provides a centralized HTTP session with configurable SSL verification
+for all HTTP requests throughout the AltaSigma package.
+"""
+
+import os
+import requests
+
+# Global session instance
+http_session = None
+
+def _http_session():
+    """Gets or creates the configured HTTP session.
+
+    Creates a requests session with SSL verification settings based on
+    the DISABLE_SSL_VERIFICATION environment variable. When DISABLE_SSL_VERIFICATION=true,
+    SSL certificate verification is disabled.
+
+    Note: The requests library automatically uses REQUESTS_CA_BUNDLE environment
+    variable for custom CA certificates when verification is enabled.
+
+    Returns:
+        requests.Session: A configured requests session.
+    """
+    global http_session
+    if http_session is not None:
+        return http_session
+    else:
+        http_session = requests.Session()
+
+        # Get SSL configuration
+        ssl_config = _get_ssl_config()
+
+        if not ssl_config['verify']:
+            # Disable SSL verification
+            http_session.verify = False
+            # Disable SSL warnings when verification is disabled
+            import urllib3
+            urllib3.disable_warnings(urllib3.exceptions.InsecureRequestWarning)
+        # else: requests automatically uses REQUESTS_CA_BUNDLE if set
+
+        return http_session
+
+
+def _get_ssl_config():
+    """Get SSL configuration settings for use across different HTTP clients.
+
+    Returns a dictionary with SSL configuration that can be used by
+    boto3, requests, and other HTTP clients.
+
+    Consumers should check the 'verify' boolean first. If verification is not
+    disabled and 'ca_bundle' is provided, use the ca_bundle path.
+
+    Returns:
+        dict: SSL configuration with keys:
+            - 'verify': Boolean indicating whether to verify SSL certificates
+            - 'ca_bundle': Path to CA certificate bundle if set via REQUESTS_CA_BUNDLE, or None
+    """
+    disable_ssl_verification = os.environ.get('DISABLE_SSL_VERIFICATION', 'false').lower() == 'true'
+    ca_bundle = os.environ.get('REQUESTS_CA_BUNDLE')
+
+    return {
+        'verify': not disable_ssl_verification,
+        'ca_bundle': ca_bundle
+    }

altasigma-0.0.4.post2/altasigma/credentials/__init__.py

@@ -0,0 +1,8 @@
+"""
+Credential utilities for managing authentication and secure data source access. For example in the Workbench and in Code Capsules.
+
+This module provides tools for obtaining, refreshing, and managing authentication 
+credentials required to access various data sources within the AltaSigma ecosystem.
+It supports both interactive authentication flows for notebooks and automated 
+authentication for production environments.
+"""