pfun-common 0.1.28__py3-none-any.whl

pfun_common/__init__.py

@@ -0,0 +1,28 @@
+import os
+
+__all__ = [
+    "settings",
+    "Settings",
+    "get_settings",
+    "utils",
+    "load_environment_variables",
+    "setup_logging"
+]
+
+try:
+    import pfun_common.pfun_common.settings as settings
+    import pfun_common.pfun_common.utils as utils
+    from pfun_common.pfun_common import (
+        load_environment_variables,
+        setup_logging
+    )
+except (ImportError, ModuleNotFoundError):
+    import pfun_common.settings as settings
+    from pfun_common.settings import (
+        Settings, get_settings
+    )
+    import pfun_common.utils as utils
+    from pfun_common.utils import (
+        load_environment_variables,
+        setup_logging
+    )

pfun_common/enums.py

@@ -0,0 +1,10 @@
+from typing import TypeVar, Type
+
+
+StringEnumType = TypeVar('StringEnumType', bound='StringEnum')
+
+
+class StringEnum:
+    @classmethod
+    def __getitem__(cls: Type[StringEnumType], item: str) -> StringEnumType:
+        return getattr(cls, item.upper())

pfun_common/plot.py

@@ -0,0 +1,12 @@
+import matplotlib.pyplot as plt
+from matplotlib.axes import Axes
+import seaborn as sns
+import pandas as pd
+import logging
+logger = logging.getLogger("pfun_cma_model")
+
+
+def lineplot(df: pd.DataFrame, tcol='ts_local', ycol='sg') -> Axes:
+    """Quality-of-life lineplot function for quick n dirty plots of glucose."""
+    axes = sns.lineplot(df, x=tcol, y=ycol)
+    return axes

pfun_common/settings.py

@@ -0,0 +1,139 @@
+"""pfun_common settings module."""
+import logging
+from base64 import b64encode
+from datetime import datetime
+from urllib.parse import urlparse
+from secrets import token_urlsafe
+
+from pydantic import field_validator, Field
+from pydantic_settings import BaseSettings, SettingsConfigDict
+
+
+def generate_default_secret_key() -> str:
+    """Generate a default secret key based on the current timestamp.
+
+    Note: This is not secure and should only be used for development purposes.
+    In production, set the SECRET_KEY environment variable to a secure value.
+    """
+    timestamp = datetime.now().isoformat().encode("utf-8")
+    timestamp_nonce = b64encode(timestamp).decode("utf-8")
+    rand_token = token_urlsafe(16) # 16 bytes of randomness
+    return f"{timestamp_nonce}-{rand_token}"
+
+
+class Settings(BaseSettings):
+    """Application settings"""
+
+    debug: bool = False
+    server_scheme: str = "http"
+    server_host: str = "localhost"
+    server_port: str | int = "8001"
+    gradio_server_scheme: str = "http"
+    gradio_server_host: str = "localhost"
+    gradio_server_port: str | int = "7860"
+    redis_user: str = "default"
+    redis_password: str = ""
+    redis_host: str = "localhost"
+    redis_port: str | int = "6379"
+    redis_db: str | int | bool = "0"
+    redis_connection_string: str = ""
+    perplexity_api_key: str = ""
+    secret_key: str = Field(default_factory=lambda: generate_default_secret_key())
+    google_cloud_project_id: str = "pfun-cma-model"
+    google_cloud_location: str = "us-central1"
+
+    model_config = SettingsConfigDict(
+        case_sensitive=False,
+        env_file=(".env",),
+        env_file_encoding="utf-8",
+        extra="allow",
+    )
+
+    @field_validator("redis_connection_string", mode="after")
+    @classmethod
+    def parse_redis_connection_string(cls, v: str, info) -> str:
+        """
+        Parse REDIS_CONNECTION_STRING and override individual Redis settings.
+
+        Supports URLs in the format: redis://[user[:password]@]host[:port][/db]
+        """
+        if not v:
+            return v
+
+        try:
+            # initially, strip any surrounding whitespace
+            v = v.strip()
+            # somewhat intelligently access the URL itself (without extra params)
+            v = [piece for piece in v.split(" ") if "redis://" in piece][0].strip()
+            logging.debug("Parsing REDIS_CONNECTION_STRING: %s", v)
+
+            # parse the URL
+            parsed = urlparse(v)
+            logging.debug("Parsed Redis URL: %s", parsed)
+
+            # Extract host (required)
+            if parsed.hostname:
+                logging.debug("Parsed Redis host: %s", parsed.hostname)
+                info.data["redis_host"] = parsed.hostname
+
+            # Extract port (optional, defaults to 6379)
+            if parsed.port:
+                info.data["redis_port"] = parsed.port
+            elif parsed.hostname:  # Only set default if we have a hostname
+                info.data["redis_port"] = 6379
+
+            # Extract username (optional, defaults to "default")
+            if parsed.username:
+                info.data["redis_user"] = parsed.username
+
+            # Extract password (optional)
+            if parsed.password:
+                info.data["redis_password"] = parsed.password
+
+            # Extract database number from path (optional, e.g., "/0")
+            if parsed.path and parsed.path != "/":
+                db_str = parsed.path.lstrip("/")
+                if db_str:
+                    try:
+                        info.data["redis_db"] = int(db_str)
+                    except ValueError:
+                        pass  # Keep existing value if db is not a valid integer
+            
+            logging.debug("Parsed Redis settings: host=%s, port=%s, user=%s, db=%s",
+                          info.data.get("redis_host"),
+                          info.data.get("redis_port"),
+                          info.data.get("redis_user"),
+                          info.data.get("redis_db"))
+        except Exception as exc:
+            logging.warning("Failed to parse REDIS_CONNECTION_STRING: %s", v, exc_info=exc)
+            logging.debug("No such REDIS_CONNECTION_STRING: %s", v, exc_info=exc)
+            pass  # Keep existing values if parsing fails
+
+        return v
+
+    @property
+    def llm_gen_scenario_endpoint(self) -> str:
+        """
+        LLM generate-scenario endpoint URL.
+
+        :param self: Description
+        :return: Description
+        :rtype: str
+        """
+        return f"{self.server_scheme}://{self.server_host}:{self.server_port}/llm/generate-scenario"
+
+    @property
+    def gradio_demo_endpoint(self) -> str:
+        """
+        Gradio demo endpoint URL.
+
+        :param self: Description
+        :return: Description
+        :rtype: str
+        """
+        return f"{self.gradio_server_scheme}://{self.gradio_server_host}:{self.gradio_server_port}/gradio/"
+
+
+def get_settings() -> Settings:
+    """Initialize the settings object (dependency injection helper method)."""
+    return Settings()

pfun_common/utils.py

@@ -0,0 +1,109 @@
+import os
+from datetime import datetime
+from dotenv import load_dotenv
+from json import dumps
+import sys
+from pathlib import Path
+import logging
+
+try:
+    # Python 2 fallback
+    from urllib import urlencode, unquote  # type: ignore
+    from urlparse import urlparse, parse_qsl, ParseResult  # type: ignore
+except ImportError:
+    # Python 3 fallback
+    from urllib.parse import (
+        urlencode, unquote, urlparse, parse_qsl, ParseResult
+    )
+
+
+def setup_logging(logger: logging.Logger, debug_mode: bool = False):
+    """Setup logging configuration."""
+    # Set the logger to the desired level
+    if debug_mode:
+        logger.setLevel(logging.DEBUG)
+        logger.debug("Debug mode is enabled. Setting logger level to DEBUG.")
+    else:
+        logger.setLevel(logging.INFO)
+        logger.info("Debug mode is disabled. Setting logger level to INFO.")
+    logger.info("...Logging setup complete.")
+
+
+def load_environment_variables(
+        logger: logging.Logger = logging.getLogger(__name__)
+    ) -> tuple[bool, Path]:
+    """Load environment variables from .env file."""
+    logger.debug("Attempting to load environment variables from .env file...")
+    env_file = Path(__file__).parent.parent.parent / ".env"
+    logger.debug("Checking for .env file at: %s", str(env_file))
+    if not env_file.exists():
+        logger.warning(
+            "No .env file found at '%s'. Using system environment variables.",
+            str(env_file))
+        return False, env_file
+    logger.debug("...env file exists.")
+    loaded = load_dotenv(dotenv_path=env_file)
+    if not loaded:
+        logger.warning(
+            f"Failed to load environment variables from {env_file}.")
+    logger.debug(f"Loaded environment variables from {env_file}")
+    return loaded, env_file
+        
+
+
+def add_url_params(url, params):
+    """ Add GET params to provided URL being aware of existing.
+
+    :param url: string of target URL
+    :param params: dict containing requested params to be added
+    :return: string with updated URL
+
+    ref: https://stackoverflow.com/a/25580545/1871569
+
+    >> url = 'https://stackoverflow.com/test?answers=true'
+    >> new_params = {'answers': False, 'data': ['some','values']}
+    >> add_url_params(url, new_params)
+    'https://stackoverflow.com/test?data=some&data=values&answers=false'
+    """
+    # Unquoting URL first so we don't lose existing args
+    url = unquote(url)
+    # Extracting url info
+    parsed_url = urlparse(url)
+    # Extracting URL arguments from parsed URL
+    get_args = parsed_url.query
+    # Converting URL arguments to dict
+    parsed_get_args = dict(parse_qsl(get_args))
+    # Merging URL arguments dict with new params
+    parsed_get_args.update(params)
+
+    # Bool and Dict values should be converted to json-friendly values
+    # you may throw this part away if you don't like it :)
+    parsed_get_args.update(
+        {k: dumps(v) for k, v in parsed_get_args.items()
+         if isinstance(v, (bool, dict))}
+    )
+
+    # Converting URL argument to proper query string
+    encoded_get_args = urlencode(parsed_get_args, doseq=True)
+    # Creating new parsed result object based on provided with new
+    # URL arguments. Same thing happens inside urlparse.
+    new_url = ParseResult(
+        parsed_url.scheme, parsed_url.netloc, parsed_url.path,
+        parsed_url.params, encoded_get_args, parsed_url.fragment
+    ).geturl()
+
+    return new_url
+
+
+def append_root_path():
+    """
+    adds the root path to the python path
+    """
+    #: pfun imports (relative)
+    root_path = str(Path(__file__).parents[1])
+    mod_path = str(Path(__file__).parent)
+    if root_path not in sys.path:
+        sys.path.insert(0, root_path)
+    if mod_path not in sys.path:
+        sys.path.insert(0, mod_path)
+    return sys.path

pfun_common-0.1.28.dist-info/METADATA

@@ -0,0 +1,9 @@
+Metadata-Version: 2.4
+Name: pfun-common
+Version: 0.1.28
+Summary: Common utilities and functions for PFun projects.
+Author-email: Robbie Capps <robbie@pfun.me>
+Requires-Python: ==3.12.11
+Requires-Dist: matplotlib>=3.8.0
+Requires-Dist: pandas>=2.2.0
+Requires-Dist: pydantic-settings>=2.2.1

pfun_common-0.1.28.dist-info/RECORD

@@ -0,0 +1,8 @@
+pfun_common/__init__.py,sha256=5gTRGLWWpT7LTv7kJkh9DJGuDiNGsxvq4mC3Cfo6a-k,662
+pfun_common/enums.py,sha256=yfUzPJmtFpIPJ-QJ7PTVsVmt_xMum3FaDvZ5CDM1w3k,253
+pfun_common/plot.py,sha256=41TbtmhAp4swIl75_ub1GGl0D38LdyviU5q_YYRc6pg,377
+pfun_common/settings.py,sha256=WCVYi9PpvllE0zqjLLnSvxPthqT3lbguWJMibausYg8,5019
+pfun_common/utils.py,sha256=cKyrOGaXPyuJGIV3KMCMwveWtfAq7bE3JUghCJc0Oy0,3767
+pfun_common-0.1.28.dist-info/METADATA,sha256=ipXvBP0d2iHp9oBbHllHj0sHt64H5PWMhqNmj8Z6xcQ,288
+pfun_common-0.1.28.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+pfun_common-0.1.28.dist-info/RECORD,,

pfun_common-0.1.28.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.28.0
+Root-Is-Purelib: true
+Tag: py3-none-any