openai-sdk-helpers 0.0.2__py3-none-any.whl → 0.0.3__py3-none-any.whl

openai_sdk_helpers/utils/core.py

@@ -1,208 +0,0 @@
-"""Core utility helpers for openai-sdk-helpers."""
-
-from __future__ import annotations
-
-import json
-import logging
-from dataclasses import asdict, is_dataclass
-from datetime import datetime
-from enum import Enum
-from pathlib import Path
-from typing import Any, Dict, Iterable, List, TypeVar
-
-T = TypeVar("T")
-_configured_logging = False
-
-
-def ensure_list(value: Iterable[T] | T | None) -> List[T]:
-    """Normalize a single item or iterable into a list.
-
-    Parameters
-    ----------
-    value : Iterable[T] | T | None
-        Item or iterable to wrap. ``None`` yields an empty list.
-
-    Returns
-    -------
-    list[T]
-        Normalized list representation of ``value``.
-    """
-    if value is None:
-        return []
-    if isinstance(value, list):
-        return value
-    if isinstance(value, tuple):
-        return list(value)
-    return [value]  # type: ignore[list-item]
-
-
-def check_filepath(
-    filepath: Path | None = None, *, fullfilepath: str | None = None
-) -> Path:
-    """Ensure the parent directory for a file path exists.
-
-    Parameters
-    ----------
-    filepath : Path | None, optional
-        Path object to validate. Mutually exclusive with ``fullfilepath``.
-    fullfilepath : str | None, optional
-        String path to validate. Mutually exclusive with ``filepath``.
-
-    Returns
-    -------
-    Path
-        Path object representing the validated file path.
-
-    Raises
-    ------
-    ValueError
-        If neither ``filepath`` nor ``fullfilepath`` is provided.
-    """
-    if filepath is None and fullfilepath is None:
-        raise ValueError("filepath or fullfilepath is required.")
-    if fullfilepath is not None:
-        target = Path(fullfilepath)
-    elif filepath is not None:
-        target = Path(filepath)
-    else:
-        raise ValueError("filepath or fullfilepath is required.")
-    target.parent.mkdir(parents=True, exist_ok=True)
-    return target
-
-
-def _to_jsonable(value: Any) -> Any:
-    """Convert common helper types to JSON-serializable forms.
-
-    Parameters
-    ----------
-    value : Any
-        Value to convert.
-
-    Returns
-    -------
-    Any
-        A JSON-safe representation of ``value``.
-    """
-    if value is None:
-        return None
-    if isinstance(value, Enum):
-        return value.value
-    if isinstance(value, Path):
-        return str(value)
-    if isinstance(value, datetime):
-        return value.isoformat()
-    if is_dataclass(value) and not isinstance(value, type):
-        return {k: _to_jsonable(v) for k, v in asdict(value).items()}
-    if hasattr(value, "model_dump"):
-        model_dump = getattr(value, "model_dump")
-        return model_dump()
-    if isinstance(value, dict):
-        return {str(k): _to_jsonable(v) for k, v in value.items()}
-    if isinstance(value, (list, tuple, set)):
-        return [_to_jsonable(v) for v in value]
-    return value
-
-
-class customJSONEncoder(json.JSONEncoder):
-    """Encode common helper types like enums and paths.
-
-    Methods
-    -------
-    default(o)
-        Return a JSON-serializable representation of ``o``.
-    """
-
-    def default(self, o: Any) -> Any:
-        """Return a JSON-serializable representation of ``o``.
-
-        Parameters
-        ----------
-        o : Any
-            Object to serialize.
-
-        Returns
-        -------
-        Any
-            JSON-safe representation of ``o``.
-        """
-        return _to_jsonable(o)
-
-
-class JSONSerializable:
-    """Mixin for classes that can be serialized to JSON.
-
-    Methods
-    -------
-    to_json()
-        Return a JSON-compatible dict representation of the instance.
-    to_json_file(filepath)
-        Write serialized JSON data to a file path.
-    """
-
-    def to_json(self) -> Dict[str, Any]:
-        """Return a JSON-compatible dict representation.
-
-        Returns
-        -------
-        dict[str, Any]
-            Mapping with only JSON-serializable values.
-        """
-        if is_dataclass(self) and not isinstance(self, type):
-            return {k: _to_jsonable(v) for k, v in asdict(self).items()}
-        if hasattr(self, "model_dump"):
-            model_dump = getattr(self, "model_dump")
-            return _to_jsonable(model_dump())
-        return _to_jsonable(self.__dict__)
-
-    def to_json_file(self, filepath: str | Path) -> str:
-        """Write serialized JSON data to a file path.
-
-        Parameters
-        ----------
-        filepath : str | Path
-            Destination file path. Parent directories are created as needed.
-
-        Returns
-        -------
-        str
-            String representation of the file path written.
-        """
-        target = Path(filepath)
-        check_filepath(fullfilepath=str(target))
-        with open(target, "w", encoding="utf-8") as handle:
-            json.dump(
-                self.to_json(),
-                handle,
-                indent=2,
-                ensure_ascii=False,
-                cls=customJSONEncoder,
-            )
-        return str(target)
-
-
-def log(message: str, level: int = logging.INFO) -> None:
-    """Log a message with a basic configuration.
-
-    Parameters
-    ----------
-    message : str
-        Message to emit.
-    level : int, optional
-        Logging level, by default ``logging.INFO``.
-    """
-    global _configured_logging
-    if not _configured_logging:
-        logging.basicConfig(
-            level=logging.INFO, format="%(asctime)s %(levelname)s %(message)s"
-        )
-        _configured_logging = True
-    logging.log(level, message)
-
-
-__all__ = [
-    "ensure_list",
-    "check_filepath",
-    "JSONSerializable",
-    "customJSONEncoder",
-    "log",
-]

openai_sdk_helpers/vector_storage/__init__.py

@@ -1,15 +0,0 @@
-"""Vector store helpers."""
-
-from __future__ import annotations
-
-from .cleanup import _delete_all_files, _delete_all_vector_stores
-from .storage import VectorStorage
-from .types import VectorStorageFileInfo, VectorStorageFileStats
-
-__all__ = [
-    "VectorStorage",
-    "VectorStorageFileInfo",
-    "VectorStorageFileStats",
-    "_delete_all_vector_stores",
-    "_delete_all_files",
-]

openai_sdk_helpers/vector_storage/cleanup.py

@@ -1,91 +0,0 @@
-"""Cleanup helpers for vector stores."""
-
-from __future__ import annotations
-
-import logging
-
-from openai import OpenAI
-
-from ..utils import log
-
-
-def _delete_all_vector_stores() -> None:
-    """Delete all vector stores and clean up any orphaned files.
-
-    This utility iterates over every vector store owned by the account,
-    deleting each one after removing all of its files. Any standalone files that
-    remain after the stores are deleted are also removed.
-
-    Returns
-    -------
-    None
-    """
-    try:
-        client = OpenAI()
-        stores = client.vector_stores.list().data
-        log(f"Found {len(stores)} vector stores.")
-
-        attached_file_ids = set()
-
-        for store in stores:
-            log(f"Deleting vector store: {store.name} (ID: {store.id})")
-
-            files = client.vector_stores.files.list(vector_store_id=store.id).data
-            for file in files:
-                attached_file_ids.add(file.id)
-                log(f" - Deleting file {file.id}")
-                try:
-                    client.vector_stores.files.delete(
-                        vector_store_id=store.id, file_id=file.id
-                    )
-                except Exception as file_err:
-                    log(
-                        f"Failed to delete file {file.id}: {file_err}",
-                        level=logging.WARNING,
-                    )
-
-            try:
-                client.vector_stores.delete(store.id)
-                log(f"Vector store {store.name} deleted.")
-            except Exception as store_err:
-                log(
-                    f"Failed to delete vector store {store.name}: {store_err}",
-                    level=logging.WARNING,
-                )
-
-        log("Checking for orphaned files in client.files...")
-        all_files = client.files.list().data
-        for file in all_files:
-            if file.id not in attached_file_ids:
-                try:
-                    log(f"Deleting orphaned file {file.id}")
-                    client.files.delete(file_id=file.id)
-                except Exception as exc:
-                    log(
-                        f"Failed to delete orphaned file {file.id}: {exc}",
-                        level=logging.WARNING,
-                    )
-
-    except Exception as exc:
-        log(f"Error during cleanup: {exc}", level=logging.ERROR)
-
-
-def _delete_all_files() -> None:
-    """Delete all files from the OpenAI account.
-
-    This utility iterates over every file owned by the account and deletes them.
-    It does not check for vector stores, so it will delete all files regardless
-    of their association.
-
-    Returns
-    -------
-    None
-    """
-    client = OpenAI()
-    all_files = client.files.list().data
-    for file in all_files:
-        try:
-            log(f"Deleting file {file.id}")
-            client.files.delete(file_id=file.id)
-        except Exception as exc:
-            log(f"Failed to delete file {file.id}: {exc}", level=logging.WARNING)