fred-oss 0.1.0__tar.gz

fred_oss-0.1.0/MANIFEST.in

@@ -0,0 +1,2 @@
+include requirements.txt
+include src/main/fred/version

fred_oss-0.1.0/NOTICE.txt

@@ -0,0 +1,13 @@
+Copyright  (c) 2025 FAHERA.MX (CORE FAHERA ENTERPRISE HOLDINGS S DE RL DE CV)
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+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.
+See the License for the specific language governing permissions and
+limitations under the License.

fred_oss-0.1.0/PKG-INFO

@@ -0,0 +1,42 @@
+Metadata-Version: 2.4
+Name: fred-oss
+Version: 0.1.0
+Summary: FREDOSS
+Home-page: https://fred.fahera.mx
+Author: Fahera Research, Education, and Development
+Author-email: fred@fahera.mx
+Requires-Python: >=3.12
+Description-Content-Type: text/markdown
+License-File: NOTICE.txt
+Requires-Dist: fire==0.7.1
+Dynamic: author
+Dynamic: author-email
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: license-file
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
+
+# FREDOSS
+
+This is the open-source baseline python package called `fred` package by `fred.fahera.mx` (Fahera's Research, Education, and Development Team).
+
+## Installation
+
+```
+$ pip install fred-oss
+```
+
+By default, the `fred-oss` package will only install the `default` dependencies. You can control which
+dependency set to use via the 'dependency tags' via the following pattern:
+
+```
+$ pip install 'fred-oss[<tag-1>,<tag-2>,...]'
+```
+
+Where `<tag-i>` can be:
+* `default`
+* `all`
+* ...

fred_oss-0.1.0/README.md

@@ -0,0 +1,21 @@
+# FREDOSS
+
+This is the open-source baseline python package called `fred` package by `fred.fahera.mx` (Fahera's Research, Education, and Development Team).
+
+## Installation
+
+```
+$ pip install fred-oss
+```
+
+By default, the `fred-oss` package will only install the `default` dependencies. You can control which
+dependency set to use via the 'dependency tags' via the following pattern:
+
+```
+$ pip install 'fred-oss[<tag-1>,<tag-2>,...]'
+```
+
+Where `<tag-i>` can be:
+* `default`
+* `all`
+* ...

fred_oss-0.1.0/requirements.txt

@@ -0,0 +1,3 @@
+# CLI Tools
+fire==0.7.1
+# Databricks Runtime: 16.4 LTS (Python 3.12.3)

fred_oss-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

fred_oss-0.1.0/setup.py

@@ -0,0 +1,51 @@
+import os
+import json
+from typing import Dict, List
+from setuptools import setup, find_namespace_packages
+
+
+CODEBASE_PATH = os.environ.get(
+    "CODEBASE_PATH",
+    default=os.path.join("src", "main"),
+)
+
+with open("requirements.txt", "r") as file:
+    requirements = [line for line in file.read().splitlines() if line and not line.startswith("#")]
+
+version_filepath = os.path.join(CODEBASE_PATH, "fred", "version")
+with open(version_filepath, "r") as file:
+    version = file.read().strip()
+
+with open("README.md") as file:
+    readme = file.read()
+
+setup(
+    name="fred-oss",
+    version=version,
+    description="FREDOSS",
+    long_description=readme,
+    long_description_content_type='text/markdown',
+    url="https://fred.fahera.mx",
+    author="Fahera Research, Education, and Development",
+    author_email="fred@fahera.mx",
+    packages=find_namespace_packages(where=CODEBASE_PATH),
+    package_dir={
+        "": CODEBASE_PATH
+    },
+    package_data={
+        "": [
+            version_filepath,
+        ]
+    },
+    entry_points={
+        "console_scripts": [
+            "fred=fred.cli.main:CLI.cli_exec",
+        ]
+    },
+    install_requires=requirements,
+    include_package_data=True,
+    # Python version should be aligned to the latest databricks LTS runtime at the moment.
+    # For more info: https://docs.databricks.com/aws/en/release-notes/runtime/ 
+    # Reference: Databricks Runtime 16.4 LTS Using Python 3.12.3
+    python_requires=">=3.12",
+)

fred_oss-0.1.0/src/main/fred/cli/__main__.py

@@ -0,0 +1,5 @@
+from fred.cli.main import CLI
+
+
+if __name__ == "__main__":
+    CLI.cli_exec()

fred_oss-0.1.0/src/main/fred/cli/interface.py

@@ -0,0 +1,67 @@
+import time
+import datetime as dt
+from typing import Optional
+from dataclasses import dataclass, field
+
+from fred.settings import (
+    get_environ_variable,
+    logger_manager,
+)
+
+logger = logger_manager.get_logger(name=__name__)
+
+
+@dataclass(slots=True, frozen=True)
+class AbstractCLI:
+    start_counter: float = field(default_factory=time.perf_counter)
+    start_ts: str = field(default_factory=dt.datetime.utcnow().isoformat)
+
+    def now(self, local: bool = False) -> str:
+        return (dt.datetime.utcnow() if not local else dt.datetime.now()).isoformat()
+
+    def environ(self, name: str) -> Optional[str]:
+        return get_environ_variable(
+            name=name,
+            enforce=False,
+        )
+
+    def runtime(
+            self,
+            include_modules: bool = False,
+        ) -> dict:
+        from fred.utils.runtime import RuntimeInfo
+
+        return RuntimeInfo.auto().to_dict(exclude_modules=not include_modules)
+
+    def on_start(self):
+        logger.debug("CLI Method not implemented: on_start")
+
+    def on_finalize(self):
+        logger.debug("CLI method not implemented: on_finalize")
+
+    def __enter__(self) -> 'AbstractCLI':
+        self.on_start()
+        return self
+
+    def __exit__(self, *args):
+        self.on_finalize()
+        end_counter = time.perf_counter()
+        # TODO: Add warning logging if an error occurred
+        logger.debug(f"Command Timestamp Start: {self.start_ts}")
+        logger.debug(f"Command Timestamp Finalize: {self.now(local=False)}")
+        logger.info(f"Command Duration: {end_counter - self.start_counter}")
+
+    @classmethod
+    def default_config(cls, *args, **kwargs):
+        return cls(*args, **kwargs)
+
+    @classmethod
+    def cli_exec(cls, *args, **kwargs):
+        import fire
+
+        with cls.default_config(*args, **kwargs) as cli:
+            fire.Fire(cli)
+
+
+class IntegrationExtCLI:
+    pass

fred_oss-0.1.0/src/main/fred/cli/main.py

@@ -0,0 +1,26 @@
+from fred.version import version
+from fred.settings import logger_manager
+from fred.cli.interface import AbstractCLI
+
+
+logger = logger_manager.get_logger(name=__name__)
+
+
+class CLIExtensionGroups:
+    """CLI Extensions providing access to various integrations by following a lazy loading pattern."""
+
+    @property
+    def databricks(self):
+        from fred.integrations.databricks.cli_ext import DatabricksExt
+        return DatabricksExt()
+    
+    @property
+    def runpod(self):
+        from fred.integrations.runpod.cli_ext import RunPodExt
+        return RunPodExt()
+
+
+class CLI(AbstractCLI, CLIExtensionGroups):
+
+    def version(self) -> str:
+        return version.value

fred_oss-0.1.0/src/main/fred/integrations/databricks/__init__.py

@@ -0,0 +1,11 @@
+from fred.maturity import Maturity, MaturityLevel
+
+
+module_maturity = Maturity(
+    level=MaturityLevel.ALPHA,
+    reference=__name__,
+    message=(
+        "Databricks integration is in early development "
+        "and therefore currently with incomplete and unstable features."
+    )
+)

fred_oss-0.1.0/src/main/fred/integrations/databricks/cli_ext.py

@@ -0,0 +1,25 @@
+from typing import Optional
+
+from fred.cli.interface import IntegrationExtCLI
+from fred.settings import logger_manager
+
+
+logger = logger_manager.get_logger(name=__name__)
+
+
+class DatabricksExt(IntegrationExtCLI):
+    def sync_runtime(self, runtime: Optional[str] = None):
+        from fred.integrations.databricks.runtimes.sync import DatabricksRuntimeSyncHelper
+
+        sync_helper = DatabricksRuntimeSyncHelper.default()
+        match runtime:
+            case None:
+                logger.info("No runtime specified; skipping synchronization.")
+            case "all":
+                logger.info("Syncing all available Databricks runtimes.")
+                sync_helper.sync_all()
+            case runtime_name if isinstance(runtime_name, str):
+                logger.info(f"Syncing specified Databricks runtime: {runtime_name}")
+                sync_helper.sync(runtime=runtime_name)
+            case _:
+                raise ValueError(f"Invalid runtime value: {runtime}")

fred_oss-0.1.0/src/main/fred/integrations/databricks/runtime.py

@@ -0,0 +1,59 @@
+import os
+from enum import StrEnum, auto
+from dataclasses import dataclass
+
+
+@dataclass(frozen=True, slots=True)
+class DatabricksRuntime:
+    python_version: str
+    databricks_runtime: str
+    libraries: list[dict]
+
+    @classmethod
+    def from_catalog(cls, catalog: 'DatabricksRuntimeCatalog') -> 'DatabricksRuntime':
+        config = catalog.get_configuration()
+        return cls(
+            python_version=config.get("python_version", "3.12.3"),
+            databricks_runtime=config.get("databricks_runtime", "16.4 LTS"),
+            libraries=config.get("libraries", []),
+        )
+
+
+class DatabricksRuntimeCatalog(StrEnum):
+    LTS_16_4 = auto()
+
+    @property
+    def key(self) -> str:
+        runtime_type, runtime_num = self.name.split("_", 1)
+        return f"{runtime_num.replace('_', '.')} {runtime_type}"
+
+    @property
+    def url(self) -> str:
+        import posixpath
+        return posixpath.join(
+            "https://docs.databricks.com",
+            "aws/en/release-notes/runtime",
+            self.key.replace(" ", "").replace("_", "").lower(),
+        )
+
+    @classmethod
+    def from_string(cls, name: str) -> 'DatabricksRuntimeCatalog':
+        formatted_name = name.replace(" ", "").replace(".", "_").upper()
+        return cls[formatted_name]
+
+    def get_filepath(self) -> str:
+        filename = f"{self.key.replace(' ', '').replace('.', '_')}.json"
+        return os.path.join(
+            os.path.dirname(__file__),
+            "runtimes",
+            filename,
+        )
+    
+    def get_configuration(self) -> dict:
+        import json
+
+        with open(self.get_filepath(), "r") as file:
+            return json.load(file)
+        
+    def get_runtime(self) -> DatabricksRuntime:
+        return DatabricksRuntime.from_catalog(self)

fred_oss-0.1.0/src/main/fred/integrations/databricks/runtimes/scanner.py

@@ -0,0 +1,16 @@
+from dataclasses import dataclass
+
+
+@dataclass(frozen=True, slots=True)
+class DatabricksRuntimeScanner:
+    target_url: str
+
+    @classmethod
+    def default(cls) -> 'DatabricksRuntimeScanner':
+        return cls(
+            target_url="https://docs.databricks.com/aws/en/release-notes/runtime/"
+        )
+
+    def get_payload(self) -> list[dict]:
+        # TODO: Extract the runtime table as a json/dict payload
+        raise NotImplementedError

fred_oss-0.1.0/src/main/fred/integrations/databricks/runtimes/sync.py

@@ -0,0 +1,55 @@
+import os
+import json
+from dataclasses import dataclass
+from typing import Union
+
+from fred.integrations.databricks.runtime import DatabricksRuntimeCatalog
+from fred.settings import logger_manager
+
+
+logger = logger_manager.get_logger(name=__name__)
+
+RUNTIME_DATATYPE = Union[DatabricksRuntimeCatalog, str]
+
+
+@dataclass(frozen=True, slots=True)
+class DatabricksRuntimeSyncHelper:
+    output_path: str
+
+    @classmethod
+    def default(cls) -> 'DatabricksRuntimeSyncHelper':
+        return cls(
+            output_path=os.path.join(
+                os.path.dirname(__file__),
+                "runtimes",
+            )
+        )
+
+    def get_payload(self, runtime: DatabricksRuntimeCatalog) -> list[dict]:
+        import requests
+
+        # Get the runtime content from the official documentation
+        response = requests.get(runtime.url)
+        if not response.ok:
+            raise ValueError(f"Failed to fetch runtime information from {runtime.url}")
+        content = response.text
+
+        # Parse the content to extract relevant information
+        # TODO: Implement the actual parsing logic
+        raise NotImplementedError
+
+    def sync(self, runtime: RUNTIME_DATATYPE):
+        if isinstance(runtime, str):
+            runtime = DatabricksRuntimeCatalog.from_string(runtime)
+        logger.info(f"Syncing Databricks Runtime: {runtime.name}")
+        payload = self.get_payload(runtime=runtime)
+        output_filepath = os.path.join(
+            self.output_path,
+            f"{runtime.name.replace(' ', '')}.json",
+        )
+        with open(output_filepath, "w") as file:
+            json.dump(payload, file, indent=4)
+
+    def sync_all(self):
+        for runtime in DatabricksRuntimeCatalog:
+            self.sync(runtime=runtime)

fred_oss-0.1.0/src/main/fred/integrations/databricks/wrappers/dbutils.py

@@ -0,0 +1,145 @@
+from dataclasses import dataclass, field
+from functools import wraps
+from typing import Any, Callable, Optional
+
+from fred.settings import logger_manager
+
+logger = logger_manager.get_logger(name=__name__)
+
+
+# Note: We need to turn off frozen & slots here to allow dynamic attribute setting
+# by the wraps decorator
+@dataclass(frozen=False, slots=False)
+class DBUtilsRetrievalMethod:
+    position: int
+    function: Callable
+
+    @classmethod
+    def with_position(cls, value: int) -> Callable:
+        def decorator(function: Callable) -> 'DBUtilsRetrievalMethod':
+            instance = cls(position=value, function=function)
+            wraps(function)(instance)
+            return instance
+        return decorator
+
+    def __call__(self, *args, **kwargs) -> Callable:
+        return self.function(*args, **kwargs)
+
+
+@dataclass(frozen=False, slots=True)
+class DBUtilsFinder:
+    instance: Optional[Any] = None
+
+    
+    @staticmethod
+    @DBUtilsRetrievalMethod.with_position(value=0)
+    def get_dbutils_from_python_context(**kwargs):
+        try:
+            return (
+                locals().get("dbutils")
+                or globals().get("dbutils")
+            )
+        except Exception as e:
+            logger.warning(f"Failed to get dbutils from python context: {e}")
+            return None
+
+    @staticmethod
+    @DBUtilsRetrievalMethod.with_position(value=1)
+    def get_dbutils_from_sdk_context(**kwargs):
+        try:
+            from databricks.sdk.runtime import dbutils
+            return dbutils
+        except ImportError:
+            from databricks.sdk.runtime import get_dbutils
+            return get_dbutils()
+        except Exception as e:
+            logger.warning(f"Failed to get dbutils from SDK context: {e}")
+            return None
+
+    @staticmethod
+    @DBUtilsRetrievalMethod.with_position(value=2)
+    def get_dbutils_from_workspace_client(client: Optional['WorkspaceClient'] = None, **kwargs):
+        try:
+            if client is None:
+                from databricks.sdk import WorkspaceClient
+                client = WorkspaceClient()
+            return client.dbutils
+        except Exception as e:
+            logger.warning(f"Failed to get dbutils from workspace client: {e}")
+            return None
+        
+    @staticmethod
+    @DBUtilsRetrievalMethod.with_position(value=3)
+    def get_dbutils_from_pypspark_import(spark: Optional['SparkSession'] = None, **kwargs):
+        try:
+            from pyspark.dbutils import DBUtils  # type: ignore[import]
+            return DBUtils(spark)
+        except Exception as e:
+            logger.warning(f"Failed to get dbutils from pyspark context: {e}")
+            return None
+        
+    @staticmethod
+    @DBUtilsRetrievalMethod.with_position(value=4)
+    def get_dbutils_from_jvm_context(spark: Optional['SparkSession'] = None, **kwargs):
+        try:
+            if spark is None:
+                from pyspark.sql import SparkSession
+                spark = SparkSession.builder.getOrCreate()
+            return spark._jvm.dbutils
+        except Exception as e:
+            logger.warning(f"Failed to get dbutils from JVM context: {e}")
+            return None
+        
+    @classmethod
+    def find_dbutils(
+        cls,
+        spark: Optional['SparkSession'] = None,
+        client: Optional['WorkspaceClient'] = None,
+        start_with_index: int = 0,
+    ):
+        get_dbutils_methods = sorted(
+            [
+                method
+                for method in dir(cls)
+                if method.startswith("get_dbutils_from_")
+            ],
+            key=lambda m: getattr(cls, m).position
+        )
+
+        def try_methods(methods: list[str], index: int = 0):
+            # Early exit if index is out of bounds
+            if index >= len(methods):
+                return None
+            # Recursively try each method until one succeeds or we run out of options
+            get_dbutils_method, *others = methods[index:]
+            if (dbutils := getattr(cls, get_dbutils_method)(spark=spark, client=client)):
+                return dbutils
+            return try_methods(others, index + 1) if others else None
+
+        return try_methods(methods=get_dbutils_methods, index=start_with_index)
+    
+    def get(self, **kwargs):
+        if self.instance:
+            return self.instance
+        self.instance = self.find_dbutils(**kwargs)
+        return self.instance
+    
+
+@dataclass(frozen=True, slots=True)
+class DBUtilsWrapper:
+    instance: Optional[Any] = None
+
+    @classmethod
+    def auto(
+        cls,
+        spark: Optional['SparkSession'] = None,
+        client: Optional['WorkspaceClient'] = None,
+        start_with_index: int = 0,
+    ) -> 'DBUtilsWrapper':
+        return cls(
+            instance=DBUtilsFinder.find_dbutils(
+                spark=spark,
+                client=client,
+                start_with_index=start_with_index,
+            )
+        )

fred_oss-0.1.0/src/main/fred/integrations/runpod/__init__.py

@@ -0,0 +1,11 @@
+from fred.maturity import Maturity, MaturityLevel
+
+
+module_maturity = Maturity(
+    level=MaturityLevel.ALPHA,
+    reference=__name__,
+    message=(
+        "Runpod integration is in early development "
+        "and therefore currently with incomplete and unstable features."
+    )
+)

fred_oss-0.1.0/src/main/fred/integrations/runpod/cli_ext.py

@@ -0,0 +1,48 @@
+from fred.integrations.runpod.helper import HandlerHelper
+from fred.cli.interface import IntegrationExtCLI
+from fred.settings import logger_manager
+
+
+logger = logger_manager.get_logger(name=__name__)
+
+
+class RunPodExt(IntegrationExtCLI):
+
+    def get_handler_instance(self, import_pattern: str, handler_classname: str) -> HandlerHelper:
+        return HandlerHelper.find_handler(
+            import_pattern=import_pattern,
+            handler_classname=handler_classname,
+        )
+
+    def execute_local(self, import_pattern: str, handler_classname: str, **kwargs) -> dict:
+        payload = kwargs.pop("payload", {})
+        handler = self.get_handler_instance(
+            import_pattern=import_pattern,
+            handler_classname=handler_classname,
+        )
+        return handler.run(
+            event={
+                "id": "local-exec",
+                "payload": payload
+            }
+        )
+
+    def execute(self, import_pattern: str, handler_classname: str, local: bool = False, **kwargs):
+        # Early exit and redirect to local execution when specified.
+        if local:
+            return self.execute_local(import_pattern, handler_classname, **kwargs)
+        
+        # Lazy import to avoid dependency issues when not using RunPod
+        import runpod  # type: ignore
+        
+        logger.info(f"Starting RunPod serverless with handler '{handler_classname}' from '{import_pattern}'.")
+        handler = self.get_handler_instance(
+            import_pattern=import_pattern,
+            handler_classname=handler_classname,
+        )
+        runpod.serverless.start(
+            {
+                "handler": handler.run,
+                **kwargs,
+            }
+        )

fred_oss-0.1.0/src/main/fred/integrations/runpod/helper.py

@@ -0,0 +1,48 @@
+import time
+from dataclasses import dataclass
+from typing import Optional
+
+from fred.settings import logger_manager
+
+logger = logger_manager.get_logger(name=__name__)
+
+
+@dataclass(frozen=True, slots=True)
+class HandlerHelper:
+
+    @classmethod
+    def find_handler(cls, import_pattern: str, handler_classname: str) -> 'HandlerHelper':
+        import importlib
+
+        # Dynamically import the handler class
+        handler_module = importlib.import_module(import_pattern)
+        handler_cls = getattr(handler_module, handler_classname)
+        # Ensure the handler class exists and is a subclass of HandlerHelper
+        if not handler_cls or not issubclass(handler_cls, cls):
+            logger.error(f"Handler class '{handler_classname}' not found or is not a subclass of HandlerHelper.")
+            raise ValueError(f"Handler '{handler_classname}' not found in module '{import_pattern}' or is not a subclass of HandlerHelper.")
+        return handler_cls()
+
+    def handler(self, payload: dict) -> Optional[dict]:
+        logger.warning("Handler method not implemented.")
+        return payload
+
+    def run(self, event: dict) -> dict:
+        job_event_identifier = event.get("id")
+        payload = event.get("payload", {})
+        start_time = time.perf_counter()
+        ok = True
+        try:
+            response = self.handler(payload=payload)
+        except Exception as e:
+            ok = False
+            logger.error(f"Error processing event {job_event_identifier}: {e}")
+            response = {
+                "error": str(e)
+            }
+        return {
+            "id": job_event_identifier,
+            "duration": time.perf_counter() - start_time,
+            "response": response,
+            "ok": ok,
+        }

fred_oss-0.1.0/src/main/fred/maturity.py

@@ -0,0 +1,73 @@
+import enum
+from dataclasses import dataclass
+from typing import Optional
+
+
+from fred.settings import (
+    logger_manager,
+    get_environ_variable,
+)
+
+
+logger = logger_manager.get_logger(name=__name__)
+
+
+class MaturityLevel(enum.Enum):
+    ALPHA = (
+        "Alpha Maturity Level"
+        ": Initial development stage with potential instability and limited or unreliable features."
+    )
+    BETA = (
+        "Beta Maturity Level"
+        ": More stable than Alpha, with additional features and ongoing testing."
+    )
+    STABLE = (
+        "Stable Maturity Level"
+        ": Fully tested and mostly reliable, suitable for production use, but use at your own risk!"
+    )
+    TO_BE_DEPRECATED = (
+        "To Be Deprecated Maturity Level"
+        ": Functionality is planned to be removed in future releases. Consider alternatives."
+    )
+    DEPRECATED = (
+        "Deprecated Maturity Level"
+        ": Functionality is no longer supported and may be removed in future releases."
+    )
+    REMOVED = (
+        "Removed Maturity Level"
+        ": Functionality has been removed from the codebase and is no longer available."
+    )
+
+    def is_stable(self) -> bool:
+        return self == MaturityLevel.STABLE
+    
+    def is_unstable(self) -> bool:
+        return self in {MaturityLevel.ALPHA, MaturityLevel.BETA, MaturityLevel.TO_BE_DEPRECATED}
+    
+    def is_deprecated(self) -> bool:
+        return self in {MaturityLevel.DEPRECATED, MaturityLevel.REMOVED}
+
+
+@dataclass(frozen=True, slots=True)
+class Maturity:
+    level: MaturityLevel
+    reference: Optional[str] = None
+    message: Optional[str] = None
+
+
+    def __post_init__(self):
+        if not self.level.is_stable() and not self.quiet:
+            logger.warning(
+                "Functionality for {reference} is at {level} maturity level. {message}".format(
+                    reference=self.reference or "undefined",
+                    level=self.level.name,
+                    message=self.message or ""
+                )
+            )
+
+    @property
+    def quiet(self) -> bool:
+        return get_environ_variable(
+            name="FRD_DISABLE_MATURITY_WARN",
+            default="0",
+        ).upper() in ["1", "Y", "T", "TRUE", "YES"]

fred_oss-0.1.0/src/main/fred/settings.py

@@ -0,0 +1,142 @@
+import os
+import enum
+import logging
+from typing import Callable, Dict, Literal, NoReturn, Optional, Union, TypeVar, overload
+from logging.config import dictConfig
+
+T = TypeVar("T")
+
+
+@overload
+def get_environ_variable(
+        name: str,
+        default: Literal[None] = None,
+        enforce: bool = False,
+        apply: Optional[Callable[[Optional[str]], T]] = None,
+) -> Optional[Union[str, T]]:
+    ...
+
+
+@overload
+def get_environ_variable(
+        name: str,
+        default: str,
+        enforce: bool = False,
+        apply: Optional[Callable[[str], T]] = None,
+) -> Union[str, T]:
+    ...
+
+
+def get_environ_variable(
+        name: str,
+        default: Optional[str] = None,
+        enforce: bool = False,
+        apply: Optional[Union[Callable[[Optional[str]], T], Callable[[str], T]]] = None,
+) -> Optional[Union[Optional[str], T]]:
+    return (apply or (lambda x: x))(  # type: ignore
+        os.environ.get(name, default=default) if not enforce else  # type: ignore
+        os.environ.get(name) or (lambda: (_ for _ in ())
+                                 .throw(ValueError(f"Missing environ variable: {name}")))()
+    )
+
+
+# Environment variables for the OpenAI API
+FRD_OPENAI_API_KEY = get_environ_variable(
+    name="FRD_OPENAI_API_KEY",
+    enforce=False,
+)
+FRD_OPENAI_BASE_URL = get_environ_variable(
+    name="FRD_OPENAI_BASE_URL",
+    default="https://api.openai.com/v1"
+)
+FRD_OPENAI_DEFAULT_MODEL = get_environ_variable(
+    "FRD_OPENAI_DEFAULT_MODEL",
+    default="openai/gpt-oss-20b"
+)
+
+
+# Logger configuration
+default_logger_configuration = {
+    "version": 1,
+    "disable_existing_loggers": False,
+    "formatters": {
+        "standard": {
+            "format": get_environ_variable(
+                name="DEFAULT_PYTHON_LOGGER",
+                default="%(asctime)s [%(levelname)s] %(name)s: %(message)s"
+            )
+        },
+    },
+    "handlers": {
+        "default": {
+            "level": get_environ_variable(
+                name="DEFAULT_PYTHON_HANDLER_LEVEL",
+                default="INFO"
+            ),
+            "formatter": "standard",
+            "class": "logging.StreamHandler",
+        },
+    },
+    "loggers": {
+        "": {
+            "handlers": [
+                "default"
+            ],
+            "level": get_environ_variable(
+                name="DEFAULT_PYTHON_LOGGER_LEVEL",
+                default="INFO",
+            ),
+            "propagate": True
+        }
+    }
+}
+
+
+def configure_logger_callable(config_dictionary: Optional[Dict] = None) -> Callable:
+    def get_logger(name: str):
+        dictConfig(config_dictionary or default_logger_configuration)
+        return logging.getLogger(name)
+    return get_logger
+
+
+class LoggerManager:
+    class _Singleton:
+        count: int = 0
+        value: Optional['LoggerManager'] = None
+
+    def __new__(cls, *args, **kwargs):
+        if cls._Singleton.count == 0:
+            instance = super(LoggerManager, cls).__new__(cls)
+            cls._Singleton.count += 1
+            cls._Singleton.value = instance
+            return instance
+        return cls._Singleton.value
+
+    def __init__(self, config_dictionary: Optional[Dict] = None, disable_singleton: bool = False):
+        self.config_dictionary: Dict = config_dictionary or default_logger_configuration
+
+        if not disable_singleton and self._Singleton.count > 0:
+            return
+        self._Singleton.count += 1
+        self._Singleton.value = self
+
+    def set_configuration(self, **kwargs):
+        self.config_dictionary = kwargs
+
+    def get_logger(self, name: str, overwrite_config_dictionary: Optional[Dict] = None):
+        dictConfig(overwrite_config_dictionary or self.config_dictionary)
+        return logging.getLogger(name)
+
+    @classmethod
+    def singleton(cls, overwrite_config_dictionary: Optional[Dict] = None) -> 'LoggerManager':
+        if overwrite_config_dictionary or cls._Singleton.value is None:
+            cls._Singleton.value = cls(overwrite_config_dictionary)
+            if cls._Singleton.count > 1:
+                cls._Singleton.value.get_logger(name=__name__).warning("Creating a new logger manager instance.")
+        return cls._Singleton.value
+
+
+logger_manager = LoggerManager.singleton()
+
+if "openrouter" in FRD_OPENAI_BASE_URL and not FRD_OPENAI_DEFAULT_MODEL.endswith(":free"):
+    logger_manager.get_logger(__name__).warning("Using OpenRouter with a non-free model.")

fred_oss-0.1.0/src/main/fred/utils/dateops.py

@@ -0,0 +1,9 @@
+import datetime as dt
+from typing import Optional
+
+
+def datetime_now(tz: Optional[dt.tzinfo] = None) -> dt.datetime:
+    return dt.datetime.now(tz=tz)
+
+def datetime_utcnow() -> dt.datetime:
+    return datetime_now(tz=dt.timezone.utc)

fred_oss-0.1.0/src/main/fred/utils/runtime.py

@@ -0,0 +1,87 @@
+import datetime as dt
+from dataclasses import dataclass, asdict
+
+from fred.utils.dateops import datetime_utcnow
+
+
+@dataclass(frozen=True, slots=True)
+class RuntimeProfilingSnapshot:
+    snapshot_at: dt.datetime
+    cpu_percent: float
+    virtual_memory_percent: float
+    swap_memory_percent: float
+    disk_usage_percent: float
+
+    @classmethod
+    def auto(cls) -> 'RuntimeProfilingSnapshot':
+        import psutil
+
+        return cls(
+            snapshot_at=datetime_utcnow(),
+            cpu_percent=psutil.cpu_percent(interval=1),
+            virtual_memory_percent=psutil.virtual_memory().percent,
+            swap_memory_percent=psutil.swap_memory().percent,
+            disk_usage_percent=psutil.disk_usage("/").percent,
+        )
+    
+    def to_dict(self) -> dict:
+        payload = asdict(self)
+        payload["snapshot_at"] = self.snapshot_at.isoformat()
+        return payload
+
+
+@dataclass(frozen=True, slots=True)
+class RuntimeInfo:
+    snapshot_at: dt.datetime
+    python_version: str
+    platform: str
+    processor: str
+    modules: list[str]
+    profiling_snapshots: list[RuntimeProfilingSnapshot]
+
+
+    @classmethod
+    def auto(cls, exclude_initial_profile: bool = False) -> 'RuntimeInfo':
+        import platform
+
+        return cls(
+            python_version=platform.python_version(),
+            platform=platform.platform(),
+            processor=platform.processor(),
+            modules=sorted(cls.get_modules()),
+            snapshot_at=datetime_utcnow(),
+            profiling_snapshots=[] if exclude_initial_profile else [
+                RuntimeProfilingSnapshot.auto()
+            ],
+        )
+    
+    def append_profiling_snapshot(self):
+        self.profiling_snapshots.append(
+            RuntimeProfilingSnapshot.auto()
+        )
+
+    @staticmethod
+    def get_modules():
+        import sys
+        import pkgutil
+
+        return {
+            module.name
+            for module in pkgutil.iter_modules()
+        }.union(sys.builtin_module_names)
+    
+    def to_dict(
+            self,
+            exclude_modules: bool = False,
+            exclude_profiling_snapshots: bool = False,
+        ) -> dict:
+        payload = asdict(self)
+        payload["snapshot_at"] = self.snapshot_at.isoformat()
+        payload["profiling_snapshots"] = [
+            snapshot.to_dict() for snapshot in self.profiling_snapshots
+        ]
+        if exclude_modules:
+            payload.pop("modules", None)
+        if exclude_profiling_snapshots:
+            payload.pop("profiling_snapshots", None)
+        return payload

fred_oss-0.1.0/src/main/fred/version

@@ -0,0 +1 @@
+0.1.0

fred_oss-0.1.0/src/main/fred/version.py

@@ -0,0 +1,77 @@
+import os
+from typing import Dict, List, Optional
+from dataclasses import dataclass
+
+
+@dataclass(frozen=True, slots=True)
+class Version:
+    name: str
+    value: str
+
+    def get_upcoming_options(self) -> List['Version']:
+        vals = self.components(as_int=True)
+        return [
+            Version(
+                name=self.name,
+                value=".".join(
+                    str(v)
+                    for j, v in enumerate(vals[:i] + [val+1] + (2-i)*[0])
+                ),
+            )
+            for i, val in enumerate(vals)
+        ]
+
+    def get_upcoming_options_with_tag(self) -> Dict[str, Dict]:
+        tags = ["major", "minor", "patch"]
+        return {
+            version.value: {
+                "version": version,
+                "scope": tags[index],
+            }
+            for index, version in enumerate(self.get_upcoming_options())
+        }
+
+    def upcoming(
+            self,
+            major: bool = False,
+            minor: bool = False,
+            patch: bool = False,
+    ) -> 'Version':
+        ver_maj, ver_min, ver_pat = self.get_upcoming_options()
+        if sum([major, minor, patch]) != 1:
+            raise ValueError
+        return ver_maj if major else ver_min if minor else ver_pat
+
+    def components(self, as_int: bool = False) -> list:
+        return [int(val) if as_int else val for val in self.value.split(".")]
+
+    @property
+    def major(self) -> int:
+        component, *_ = self.components(as_int=True)
+        return component
+
+    @property
+    def minor(self) -> int:
+        _, component, *_ = self.components(as_int=True)
+        return component
+
+    @property
+    def patch(self) -> int:
+        *_, component = self.components(as_int=True)
+        return component
+
+    @classmethod
+    def from_path(cls, dirpath: str, name: str):
+        for file in os.listdir(dirpath):
+            if file.lower().endswith("version"):
+                filepath = os.path.join(dirpath, file)
+                break
+        else:
+            raise ValueError("Version file not found for package name: " + name)
+
+        with open(filepath, "r") as version_file:
+            version_value = version_file.readline().strip()  # TODO: Validate version pattern via regex
+            return cls(name=name, value=version_value)
+
+
+version = Version.from_path(name="fred", dirpath=os.path.dirname(__file__))

fred_oss-0.1.0/src/main/fred_oss.egg-info/PKG-INFO

@@ -0,0 +1,42 @@
+Metadata-Version: 2.4
+Name: fred-oss
+Version: 0.1.0
+Summary: FREDOSS
+Home-page: https://fred.fahera.mx
+Author: Fahera Research, Education, and Development
+Author-email: fred@fahera.mx
+Requires-Python: >=3.12
+Description-Content-Type: text/markdown
+License-File: NOTICE.txt
+Requires-Dist: fire==0.7.1
+Dynamic: author
+Dynamic: author-email
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: license-file
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
+
+# FREDOSS
+
+This is the open-source baseline python package called `fred` package by `fred.fahera.mx` (Fahera's Research, Education, and Development Team).
+
+## Installation
+
+```
+$ pip install fred-oss
+```
+
+By default, the `fred-oss` package will only install the `default` dependencies. You can control which
+dependency set to use via the 'dependency tags' via the following pattern:
+
+```
+$ pip install 'fred-oss[<tag-1>,<tag-2>,...]'
+```
+
+Where `<tag-i>` can be:
+* `default`
+* `all`
+* ...

fred_oss-0.1.0/src/main/fred_oss.egg-info/SOURCES.txt

@@ -0,0 +1,33 @@
+MANIFEST.in
+NOTICE.txt
+README.md
+requirements.txt
+setup.py
+src/main/fred/maturity.py
+src/main/fred/settings.py
+src/main/fred/version
+src/main/fred/version.py
+src/main/fred/cli/__init__.py
+src/main/fred/cli/__main__.py
+src/main/fred/cli/interface.py
+src/main/fred/cli/main.py
+src/main/fred/integrations/databricks/__init__.py
+src/main/fred/integrations/databricks/cli_ext.py
+src/main/fred/integrations/databricks/runtime.py
+src/main/fred/integrations/databricks/runtimes/__init__.py
+src/main/fred/integrations/databricks/runtimes/scanner.py
+src/main/fred/integrations/databricks/runtimes/sync.py
+src/main/fred/integrations/databricks/wrappers/__init__.py
+src/main/fred/integrations/databricks/wrappers/dbutils.py
+src/main/fred/integrations/runpod/__init__.py
+src/main/fred/integrations/runpod/cli_ext.py
+src/main/fred/integrations/runpod/helper.py
+src/main/fred/utils/__init__.py
+src/main/fred/utils/dateops.py
+src/main/fred/utils/runtime.py
+src/main/fred_oss.egg-info/PKG-INFO
+src/main/fred_oss.egg-info/SOURCES.txt
+src/main/fred_oss.egg-info/dependency_links.txt
+src/main/fred_oss.egg-info/entry_points.txt
+src/main/fred_oss.egg-info/requires.txt
+src/main/fred_oss.egg-info/top_level.txt

fred_oss-0.1.0/src/main/fred_oss.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

fred_oss-0.1.0/src/main/fred_oss.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+fred = fred.cli.main:CLI.cli_exec

fred_oss-0.1.0/src/main/fred_oss.egg-info/requires.txt

@@ -0,0 +1 @@
+fire==0.7.1

fred_oss-0.1.0/src/main/fred_oss.egg-info/top_level.txt

@@ -0,0 +1 @@
+fred