pfmsoft-api-request 0.1.3__tar.gz → 0.1.7__tar.gz

{pfmsoft_api_request-0.1.3 → pfmsoft_api_request-0.1.7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pfmsoft-api-request
-Version: 0.1.3
+Version: 0.1.7
 Summary: A command line api request tool with caching and rate limiting.
 Author: Chad Lowe
 Author-email: Chad Lowe <pfmsoft.dev@gmail.com>
@@ -8,7 +8,7 @@ License-Expression: MIT
 License-File: LICENSE
 Requires-Dist: aiolimiter>=1.2.1
 Requires-Dist: httpx2>=2.5.0
-Requires-Dist: pfmsoft-eve-snippets>=0.1.4
+Requires-Dist: pfmsoft-eve-snippets>=0.1.7
 Requires-Dist: pydantic>=2.13.4
 Requires-Dist: pydantic-settings>=2.14.2
 Requires-Dist: typer>=0.26.8

pfmsoft_api_request-0.1.7/pyproject.toml

@@ -0,0 +1,82 @@
+[project]
+name = "pfmsoft-api-request"
+version = "0.1.7"
+description = "A command line api request tool with caching and rate limiting."
+readme = "README.md"
+requires-python = ">=3.14"
+dependencies = [
+    "aiolimiter>=1.2.1",
+    "httpx2>=2.5.0",
+    "pfmsoft-eve-snippets>=0.1.7",
+    "pydantic>=2.13.4",
+    "pydantic-settings>=2.14.2",
+    "typer>=0.26.8",
+    "whenever>=0.10.2",
+]
+license = "MIT"
+license-files = ["LICENSE"]
+
+[[project.authors]]
+name = "Chad Lowe"
+email = "pfmsoft.dev@gmail.com"
+
+[project.scripts]
+api-request = "pfmsoft.api_request.cli.main_typer:app"
+
+[project.urls]
+Documentation = "https://github.com/DonalChilde/pfmsoft-api-request#readme"
+Issues = "https://github.com/DonalChilde/pfmsoft-api-request/issues"
+Source = "https://github.com/DonalChilde/pfmsoft-api-request"
+
+[build-system]
+requires = ["uv_build>=0.11.21,<0.12.0"]
+build-backend = "uv_build"
+
+[tool.uv]
+exclude-newer = "1 week"
+
+[tool.uv.build-backend]
+module-name = "pfmsoft.api_request"
+
+[tool.uv.exclude-newer-package]
+pfmsoft-eve-snippets = false
+
+[tool.pytest.ini_options]
+pythonpath = "src"
+log_file = "dev/pytest-logs/tests.log"
+log_file_date_format = "%Y-%m-%dT%H:%M:%S.%f%z"
+log_file_format = "%(asctime)s %(levelname)s:%(funcName)s: %(message)s [in %(pathname)s:%(lineno)d]"
+log_file_level = "INFO"
+
+[tool.coverage.run]
+branch = true
+parallel = true
+
+[tool.ruff.lint]
+select = [
+    "B",
+    "UP",
+    "D",
+    "FIX",
+    "I",
+    "F401",
+]
+ignore = [
+    "D401",
+    "D101",
+    "D421",
+]
+
+[tool.ruff.lint.pydocstyle]
+convention = "google"
+
+[tool.ruff.format]
+docstring-code-format = true
+docstring-code-line-length = 88
+
+[dependency-groups]
+dev = [
+    "pytest>=9.1.1",
+    "pytest-cov>=7.1.0",
+    "ruff>=0.15.21",
+]

pfmsoft_api_request-0.1.3/pyproject.toml → pfmsoft_api_request-0.1.7/pyproject.toml.orig

@@ -1,6 +1,6 @@
 [project]
 name = "pfmsoft-api-request"
-version = "0.1.3"
+version = "0.1.7"
 description = "A command line api request tool with caching and rate limiting."
 readme = "README.md"
 authors = [{ name = "Chad Lowe", email = "pfmsoft.dev@gmail.com" }]
@@ -8,7 +8,7 @@ requires-python = ">=3.14"
 dependencies = [
     "aiolimiter>=1.2.1",
     "httpx2>=2.5.0",
-    "pfmsoft-eve-snippets>=0.1.4",
+    "pfmsoft-eve-snippets>=0.1.7",
     "pydantic>=2.13.4",
     "pydantic-settings>=2.14.2",
     "typer>=0.26.8",

{pfmsoft_api_request-0.1.3 → pfmsoft_api_request-0.1.7}/src/pfmsoft/api_request/cache/sqlite_cache/query_helpers.py

@@ -8,10 +8,24 @@ import logging
 import sqlite3
 from uuid import UUID
 
+from pfmsoft.api_request.helpers.package_resource import load_package_resouce_text
+
 from ..models import CachedResponse
 
 logger = logging.getLogger(__name__)
 
+_table_def_parent = "pfmsoft.api_request.cache.sqlite_cache"
+_table_def_sql = "table_definitions.sql"
+
+
+def load_table_definitions() -> str:
+    """Load the packaged SQL script for creating the database schema.
+
+    Returns:
+        The contents of the SQL script as a string.
+    """
+    return load_package_resouce_text(_table_def_parent, _table_def_sql)
+
 
 def write_cached_response(
     connection: sqlite3.Connection, cache_key: str, cached_response: CachedResponse

{pfmsoft_api_request-0.1.3 → pfmsoft_api_request-0.1.7}/src/pfmsoft/api_request/cache/sqlite_cache/sqlite_cache.py

@@ -10,14 +10,16 @@ from types import TracebackType
 from typing import Self
 from uuid import UUID
 
+from pfmsoft.eve_snippets.sqlite3.connection_helpers import create_read_write_connection
 from whenever import Instant
 
+from pfmsoft.api_request.cache.sqlite_cache.query_helpers import load_table_definitions
+
 from ...request.models import ResponseMetadata
 from ..metadata_helpers import merge_cached_revalidation_metadata
 from ..models import CachedResponse, CacheInfo
 from ..protocols import CacheFactoryProtocol, CacheProtocol
 from . import query_helpers
-from .connection_helpers import create_read_write_connection
 
 
 class SqliteCache(CacheProtocol):
@@ -56,7 +58,10 @@ class SqliteCache(CacheProtocol):
     async def __aenter__(self) -> Self:
         """Enter context and open path-owned connections when needed."""
         if self._connection_path is not None:
-            self._connection = create_read_write_connection(self._connection_path)
+            table_definitions = load_table_definitions()
+            self._connection = create_read_write_connection(
+                self._connection_path, init_sql=table_definitions
+            )
             self._close_connection_on_exit = True
         return self
 

{pfmsoft_api_request-0.1.3 → pfmsoft_api_request-0.1.7}/src/pfmsoft/api_request/cli/request/request.py

@@ -7,6 +7,7 @@ from pathlib import Path
 from typing import Annotated
 
 import typer
+from pfmsoft.eve_snippets import save_text_file
 from rich.console import Console
 from rich.json import JSON
 
@@ -16,7 +17,6 @@ from pfmsoft.api_request.cli.helpers import (
     get_api_request_settings_from_context,
     get_stdin,
 )
-from pfmsoft.api_request.helpers.save_text_file import save_text_file
 from pfmsoft.api_request.logging_config import setup_logging
 from pfmsoft.api_request.rate_limit.aio_limiter import AiolimiterRateLimiterFactory
 from pfmsoft.api_request.request.models import (
@@ -206,8 +206,8 @@ def request(
     else:
         output_path = save_text_file(
             text=ResponsesRoot(root=responses).model_dump_json(indent=indent),
-            output_directory=file_out.parent,
-            file_name=file_out.name,
+            directory=file_out.parent,
+            filename=file_out.name,
             overwrite=overwrite,
         )
         messenger.print(f"[bold green]Responses saved to {output_path}[/bold green]")

pfmsoft_api_request-0.1.7/src/pfmsoft/api_request/helpers/package_resource.py

@@ -0,0 +1,16 @@
+"""Helpers for working with package resources."""
+
+from importlib.resources import files as resource_files
+
+
+def load_package_resouce_text(package: str, resource_name: str) -> str:
+    """Load a resource from the package as text.
+
+    Args:
+        package: Package name where the resource is located.
+        resource_name: Name of the resource file to load.
+
+    Returns:
+        The contents of the resource file as a string.
+    """
+    return resource_files(package).joinpath(resource_name).read_text()

{pfmsoft_api_request-0.1.3 → pfmsoft_api_request-0.1.7}/src/pfmsoft/api_request/request/api_requester.py

@@ -76,12 +76,12 @@ from uuid import UUID
 
 from httpx2 import AsyncClient
 from httpx2 import Response as HttpResponse
+from pfmsoft.eve_snippets import json_io
+from pfmsoft.eve_snippets.httpx2.http_session_factory import config_async_http_client
 from whenever import Instant
 
 from pfmsoft.api_request.cache.models import CachedResponse
 from pfmsoft.api_request.cache.protocols import CacheFactory, CacheProtocol
-from pfmsoft.api_request.helpers import json_io
-from pfmsoft.api_request.helpers.http_session_factory import config_async_http_client
 from pfmsoft.api_request.rate_limit.protocols import (
     RateLimiterFactoryProtocol,
     RateLimiterProtocol,

pfmsoft_api_request-0.1.7/src/pfmsoft/api_request/settings.py

@@ -0,0 +1,94 @@
+"""Settings for the api-request module."""
+
+import logging
+from dataclasses import dataclass
+from pathlib import Path
+from uuid import NAMESPACE_DNS, uuid5
+
+from pydantic_settings import BaseSettings, SettingsConfigDict
+from typer import get_app_dir
+
+from pfmsoft.api_request import (
+    __app_name__,
+    __url__,
+    __version__,
+)
+
+logger = logging.getLogger(__name__)
+
+# Typical application settings
+USER_AGENT = f"{__app_name__}/{__version__} ({__url__})"
+"""User-Agent header value sent to remote OAuth and ESI services."""
+APP_DOMAIN = f"{__app_name__}"
+APP_NAMESPACE = uuid5(NAMESPACE_DNS, __app_name__)
+ENV_PREFIX = __app_name__.replace(".", "_").replace("-", "_").upper() + "_"
+SETTINGS_KEY = ENV_PREFIX + "SETTINGS"
+
+
+@dataclass(slots=True, kw_only=True)
+class ApiRequestSettings:
+    """Settings for the api-request module."""
+
+    application_directory: Path
+    """Directory where the application stores its data."""
+    logging_directory: Path
+    """Directory where the application stores its log files."""
+    web_cache_path: Path
+    """Path to the web cache SQLite database."""
+
+
+class ApiRequestSettingsPydantic(BaseSettings):
+    """Pydantic settings for the api-request module."""
+
+    application_directory: Path = Path(get_app_dir(__app_name__)).resolve()
+    """Directory where the application stores its data."""
+
+    model_config = SettingsConfigDict(
+        env_prefix=ENV_PREFIX,
+        env_file=(".env", ".env.dev"),
+        env_file_encoding="utf-8",
+    )
+
+
+def get_settings(
+    application_directory: Path | None = None,
+) -> ApiRequestSettings:
+    """Build runtime settings from a Pydantic settings model or application directory.
+
+    Args:
+        application_directory (Path | None): Optional application directory path.
+            If not provided, the default application directory is used.
+
+    Returns:
+        Runtime settings dataclass used by the application.
+
+    Raises:
+        ValueError: If the provided application directory exists but is not a directory.
+    """
+    if application_directory is None:
+        # If the application directory is not provided, use the value from the Pydantic
+        # settings model. This allows for environment variable overrides and .env file loading.
+        application_directory = ApiRequestSettingsPydantic().application_directory
+    application_directory = application_directory.expanduser().resolve()
+    if application_directory.exists() and not application_directory.is_dir():
+        raise ValueError(
+            f"Application directory '{application_directory}' exists but is not a directory."
+        )
+    settings = _initialize_settings(application_directory)
+    return settings
+
+
+def _initialize_settings(application_directory: Path) -> ApiRequestSettings:
+    """Build default runtime settings.
+
+    Also ensures that the application directories exist.
+    """
+    settings = ApiRequestSettings(
+        application_directory=application_directory,
+        logging_directory=application_directory / "logs",
+        web_cache_path=application_directory / "api_requests_web_cache.sqlite",
+    )
+    # Ensure that the application directories exist.
+    settings.application_directory.mkdir(parents=True, exist_ok=True)
+    settings.logging_directory.mkdir(parents=True, exist_ok=True)
+    return settings

pfmsoft_api_request-0.1.3/src/pfmsoft/api_request/cache/sqlite_cache/connection_helpers.py

@@ -1,126 +0,0 @@
-"""SQLite connection and schema bootstrap helpers.
-
-These helpers centralize URI construction and consistent connection setup for
-cache backends and tests.
-"""
-
-import logging
-import sqlite3
-from collections.abc import Iterator
-from contextlib import contextmanager
-from importlib.resources import files as resource_files
-from pathlib import Path
-
-logger = logging.getLogger(__name__)
-
-_table_def_parent = "pfmsoft.api_request.cache.sqlite_cache"
-_table_def_sql = "table_definitions.sql"
-
-
-def read_only_uri(db_path: str) -> str:
-    """Build a read-only SQLite URI for use with sqlite3.connect(uri=True).
-
-    Args:
-        db_path: Filesystem path to the SQLite database.
-
-    Returns:
-        URI string with mode=ro.
-    """
-    return f"file:{db_path}?mode=ro"
-
-
-def read_write_uri(db_path: str) -> str:
-    """Build a read-write/create SQLite URI for sqlite3.connect(uri=True).
-
-    Args:
-        db_path: Filesystem path to the SQLite database.
-
-    Returns:
-        URI string with mode=rwc.
-    """
-    return f"file:{db_path}?mode=rwc"
-
-
-def create_read_only_connection(db_path: str | Path) -> sqlite3.Connection:
-    """Create a read-only SQLite connection for an existing database.
-
-    The caller is responsible for closing the connection when done.
-
-    Args:
-        db_path: Path to an existing SQLite database file.
-
-    Returns:
-        Open SQLite connection configured with sqlite3.Row row factory.
-
-    Notes:
-        The target database is expected to already contain the required schema.
-        Read-only connections cannot modify schema or persisted rows.
-    """
-    if isinstance(db_path, Path):
-        db_path = str(db_path.resolve())
-    uri = read_only_uri(db_path)
-    connection = sqlite3.connect(uri, uri=True)
-    connection.row_factory = sqlite3.Row
-    return connection
-
-
-def create_read_write_connection(db_path: str | Path) -> sqlite3.Connection:
-    """Create a read-write SQLite connection and ensure the packaged schema exists.
-
-    The caller is responsible for closing the connection when done.
-
-    Args:
-        db_path: Path to the SQLite database file.
-
-    Returns:
-        Open SQLite connection configured with sqlite3.Row row factory.
-
-    Notes:
-        Missing tables and other schema objects defined in the packaged SQL
-        script are created before the connection is returned.
-    """
-    if isinstance(db_path, Path):
-        db_path.parent.mkdir(parents=True, exist_ok=True)
-        db_path = str(db_path.resolve())
-    else:
-        Path(db_path).parent.mkdir(parents=True, exist_ok=True)
-        db_path = str(Path(db_path).resolve())
-    uri = read_write_uri(db_path)
-    connection = sqlite3.connect(uri, uri=True)
-    logger.info(f"Created read-write connection to database at {db_path}")
-    connection.row_factory = sqlite3.Row
-    table_defs = resource_files(_table_def_parent).joinpath(_table_def_sql).read_text()
-    with connection:
-        connection.executescript(table_defs)
-        logger.info("Ensured database schema is created.")
-    return connection
-
-
-@contextmanager
-def db_connection_manager(
-    db_path: str | Path, read_only: bool = True
-) -> Iterator[sqlite3.Connection]:
-    """Yield a SQLite connection and close it automatically on exit.
-
-    Delegates to the read-only or read-write connection factory based on the
-    `read_only` flag.
-
-    Args:
-        db_path: Path to the SQLite database file.
-        read_only: Whether to open the connection in read-only mode.
-
-    Yields:
-        Open SQLite connection configured with sqlite3.Row row factory.
-    """
-    connection: sqlite3.Connection | None = None
-    try:
-        if read_only:
-            logger.info(f"Opening read-only connection to database at {db_path}")
-            connection = create_read_only_connection(db_path)
-        else:
-            logger.info(f"Opening read-write connection to database at {db_path}")
-            connection = create_read_write_connection(db_path)
-        yield connection
-    finally:
-        if connection is not None:
-            connection.close()

pfmsoft_api_request-0.1.3/src/pfmsoft/api_request/helpers/http_session_factory.py

@@ -1,80 +0,0 @@
-"""Create preconfigured sync and async HTTP clients for Eve Auth Manager."""
-
-from collections.abc import AsyncIterator, Iterator
-from contextlib import asynccontextmanager, contextmanager
-
-from httpx2 import AsyncClient, Client
-
-from pfmsoft.api_request.settings import USER_AGENT
-
-
-def config_http_client(user_agent: str = USER_AGENT) -> Client:
-    """Create an HTTP client configured with the project User-Agent header.
-
-    Args:
-        user_agent: User-Agent header value to send with requests. Defaults to
-            the project setting.
-
-    Returns:
-        Configured synchronous HTTP client.
-
-    Note:
-        The caller owns the returned client and must close it when finished.
-    """
-    return Client(headers={"User-Agent": user_agent})
-
-
-async def config_async_http_client(user_agent: str = USER_AGENT) -> AsyncClient:
-    """Create an async HTTP client configured with the project User-Agent header.
-
-    Args:
-        user_agent: User-Agent header value to send with requests. Defaults to
-            the project setting.
-
-    Returns:
-        Configured asynchronous HTTP client.
-
-    Note:
-        The caller owns the returned client and must close it when finished.
-    """
-    return AsyncClient(headers={"User-Agent": user_agent})
-
-
-@contextmanager
-def client_manager(user_agent: str = USER_AGENT) -> Iterator[Client]:
-    """Yield a configured HTTP client and close it automatically on exit.
-
-    Args:
-        user_agent: User-Agent header value to send with requests.
-
-    Yields:
-        Configured synchronous HTTP client.
-    """
-    client: Client | None = None
-    try:
-        client = config_http_client(user_agent)
-        yield client
-    finally:
-        if client is not None:
-            client.close()
-
-
-@asynccontextmanager
-async def async_client_manager(
-    user_agent: str = USER_AGENT,
-) -> AsyncIterator[AsyncClient]:
-    """Yield a configured async HTTP client and close it automatically on exit.
-
-    Args:
-        user_agent: User-Agent header value to send with requests.
-
-    Yields:
-        Configured asynchronous HTTP client.
-    """
-    client: AsyncClient | None = None
-    try:
-        client = await config_async_http_client(user_agent)
-        yield client
-    finally:
-        if client is not None:
-            await client.aclose()

pfmsoft_api_request-0.1.3/src/pfmsoft/api_request/helpers/json_io.py

@@ -1,256 +0,0 @@
-"""Helpers for loading, dumping, and streaming JSON and JSONL data with pydantic_core."""
-
-from collections.abc import Iterator
-from pathlib import Path
-from typing import Any, TextIO
-
-from pydantic_core import from_json, to_json
-
-
-def json_load_path(filepath: Path) -> Any:
-    """Load a JSON file into a Python object.
-
-    Args:
-        filepath: Path to a UTF-8 encoded JSON file.
-
-    Returns:
-        Parsed Python object produced by pydantic_core.from_json().
-    """
-    return from_json(filepath.read_text(encoding="utf-8"))
-
-
-def json_loads(json_string: str | bytes) -> Any:
-    """Parse a JSON text or byte payload into a Python object.
-
-    Args:
-        json_string: JSON document encoded as text or bytes.
-
-    Returns:
-        Parsed Python object produced by pydantic_core.from_json().
-    """
-    return from_json(json_string)
-
-
-def json_dumps(
-    obj: Any, indent: int | None = None, encoding: str = "utf-8", **kwargs: Any
-) -> str:
-    """Serialize a Python object to JSON text.
-
-    Args:
-        obj: Python object to serialize.
-        indent: Optional indentation level passed to pydantic_core.to_json().
-        encoding: Text encoding used to decode the serialized JSON bytes.
-        **kwargs: Additional keyword arguments forwarded to
-            pydantic_core.to_json().
-
-    Returns:
-        JSON document as a string.
-    """
-    return to_json(obj, indent=indent, **kwargs).decode(encoding)
-
-
-def json_dump_bytes(obj: Any, indent: int | None = None, **kwargs: Any) -> bytes:
-    """Serialize a Python object to JSON bytes.
-
-    Args:
-        obj: Python object to serialize.
-        indent: Optional indentation level passed to pydantic_core.to_json().
-        **kwargs: Additional keyword arguments forwarded to
-            pydantic_core.to_json().
-
-    Returns:
-        JSON document as bytes.
-    """
-    return to_json(obj, indent=indent, **kwargs)
-
-
-def json_dumps_path(
-    obj: Any,
-    *,
-    filepath: Path,
-    overwrite: bool = False,
-    encoding: str = "utf-8",
-    indent: int | None = None,
-    **kwargs: Any,
-) -> int:
-    """Dump a Python object to a JSON file.
-
-    Uses pydantic_core.to_json() to serialize the object and writes a trailing
-    newline after the JSON document.
-
-    Args:
-        obj: The Python object to dump.
-        filepath: The path to the JSON file.
-        overwrite: Whether to overwrite the file if it exists.
-        encoding: The encoding to use when writing the file.
-        indent: The indentation level for the JSON file.
-        **kwargs: Additional keyword arguments passed to `json_dumps`.
-
-    Returns:
-        The number of characters written to the file, including the trailing
-        newline.
-
-    Raises:
-        FileExistsError: If the file already exists and `overwrite` is False.
-    """
-    filepath.parent.mkdir(parents=True, exist_ok=True)
-    if overwrite:
-        mode = "w"
-    else:
-        mode = "x"
-    with filepath.open(mode, encoding=encoding) as f:
-        counter = 0
-        counter += f.write(json_dumps(obj, indent=indent, **kwargs))
-        counter += f.write("\n")
-        return counter
-
-
-def jsonl_loads(jsonl_string: str) -> Iterator[Any]:
-    """Yield Python objects parsed lazily from non-empty JSONL text lines."""
-    for line in jsonl_string.splitlines():
-        if line.strip():
-            yield from_json(line)
-
-
-def jsonl_loads_indexed(jsonl_string: str) -> Iterator[tuple[int, Any]]:
-    """Yield line-number and object pairs from non-empty JSONL text lines.
-
-    Line numbers correspond to the original input line positions, including
-    blank lines.
-    """
-    for line_number, line in enumerate(jsonl_string.splitlines(), start=1):
-        if line.strip():
-            yield line_number, from_json(line)
-
-
-def jsonl_load_bytes(jsonl_bytes: bytes) -> Iterator[Any]:
-    """Yield Python objects parsed lazily from non-empty JSONL byte lines."""
-    for line in jsonl_bytes.splitlines():
-        if line.strip():
-            yield from_json(line)
-
-
-def jsonl_load_bytes_indexed(jsonl_bytes: bytes) -> Iterator[tuple[int, Any]]:
-    """Yield line-number and object pairs from non-empty JSONL byte lines.
-
-    Line numbers correspond to the original input line positions, including
-    blank lines.
-    """
-    for line_number, line in enumerate(jsonl_bytes.splitlines(), start=1):
-        if line.strip():
-            yield line_number, from_json(line)
-
-
-def jsonl_load_path(filepath: Path) -> Iterator[Any]:
-    """Yield Python objects parsed lazily from non-empty lines in a JSONL file."""
-    with filepath.open("r", encoding="utf-8") as f:
-        for line in f:
-            if line.strip():
-                yield from_json(line)
-
-
-def jsonl_load_path_indexed(filepath: Path) -> Iterator[tuple[int, Any]]:
-    """Yield line-number and object pairs parsed from a JSONL file.
-
-    Line numbers correspond to the original file line positions, including
-    blank lines.
-    """
-    with filepath.open("r", encoding="utf-8") as f:
-        for line_number, line in enumerate(f, start=1):
-            if line.strip():
-                yield line_number, from_json(line)
-
-
-def jsonl_dump_path(
-    objs: Iterator[Any],
-    *,
-    filepath: Path,
-    encoding: str = "utf-8",
-    overwrite: bool = False,
-    append: bool = False,
-    **kwargs: Any,
-) -> int:
-    """Write JSONL output from an iterator of Python objects.
-
-    Serializes one object per line without materializing the full output in
-    memory.
-
-    Args:
-        objs: Iterator of Python objects to serialize as JSONL.
-        filepath: The path to the JSONL file.
-        encoding: The encoding to use when writing the file.
-        overwrite: Whether to overwrite the file if it exists.
-        append: Whether to append to the file if it exists.
-        **kwargs: Additional keyword arguments passed to `json_dumps`.
-
-    Returns:
-        Number of characters written to the file, including newline
-        separators.
-
-    Raises:
-        ValueError: If `indent` is provided or if `overwrite` and `append` are
-            both True.
-        FileExistsError: If the file already exists and neither overwrite nor
-            append permits writing.
-    """
-    if "indent" in kwargs:
-        raise ValueError("indent is not supported for JSONL files.")
-    filepath.parent.mkdir(parents=True, exist_ok=True)
-    if overwrite and append:
-        raise ValueError("overwrite and append are mutually exclusive.")
-    if append:
-        mode = "a"
-    elif overwrite:
-        mode = "w"
-    else:
-        mode = "x"
-
-    def write_objs(f: TextIO) -> int:
-        counter = 0
-        for obj in objs:
-            counter += f.write(json_dumps(obj, **kwargs))
-            counter += f.write("\n")
-        return counter
-
-    with filepath.open(mode, encoding=encoding) as f:
-        return write_objs(f)
-
-
-def jsonl_dumps(objs: Iterator[Any], encoding: str = "utf-8", **kwargs: Any) -> str:
-    """Serialize an iterator of objects to a JSONL string.
-
-    Args:
-        objs: Iterator of Python objects to serialize as JSONL.
-        encoding: Text encoding used when converting each JSON document.
-        **kwargs: Additional keyword arguments forwarded to json_dumps().
-
-    Returns:
-        JSONL document with one serialized object per line.
-
-    Raises:
-        ValueError: If `indent` is provided, because JSONL output must remain
-            one JSON value per line.
-    """
-    if "indent" in kwargs:
-        raise ValueError("indent is not supported for JSONL files.")
-    return "\n".join(json_dumps(obj, encoding=encoding, **kwargs) for obj in objs)
-
-
-def jsonl_dump_bytes(objs: Iterator[Any], **kwargs: Any) -> bytes:
-    """Serialize an iterator of objects to JSONL bytes.
-
-    Args:
-        objs: Iterator of Python objects to serialize as JSONL.
-        **kwargs: Additional keyword arguments forwarded to json_dump_bytes().
-
-    Returns:
-        JSONL document as bytes with one serialized object per line.
-
-    Raises:
-        ValueError: If `indent` is provided, because JSONL output must remain
-            one JSON value per line.
-    """
-    if "indent" in kwargs:
-        raise ValueError("indent is not supported for JSONL files.")
-    jsonl_bytes = b"\n".join(json_dump_bytes(obj, **kwargs) for obj in objs)
-    return jsonl_bytes

pfmsoft_api_request-0.1.3/src/pfmsoft/api_request/helpers/save_text_file.py

@@ -1,43 +0,0 @@
-"""Write text files while creating parent directories and enforcing overwrite policy."""
-
-from pathlib import Path
-
-
-def save_text_file(
-    *,
-    text: str,
-    output_directory: Path,
-    file_name: str,
-    overwrite: bool = False,
-    encoding: str = "utf-8",
-) -> Path:
-    """Write text to a file in the target output directory.
-
-    Args:
-        text: Text content to write.
-        output_directory: Directory that should contain the output file.
-        file_name: Name of the output file to create.
-        overwrite: If true, replace an existing file. If false, raise an error
-            when the target file already exists.
-        encoding: Text encoding to use when writing the file.
-
-    Returns:
-        Path object for the written file.
-
-    Raises:
-        FileExistsError: If the target file exists and overwrite is false.
-        OSError: If the parent directory cannot be created or the file cannot
-            be written.
-
-    Notes:
-        Parent directories are created automatically when missing.
-    """
-    output_file = output_directory / file_name
-    output_file.parent.mkdir(parents=True, exist_ok=True)
-    if overwrite:
-        mode = "w"
-    else:
-        mode = "x"
-    with output_file.open(mode, encoding=encoding) as f:
-        f.write(text)
-    return output_file

pfmsoft_api_request-0.1.3/src/pfmsoft/api_request/settings.py

@@ -1,65 +0,0 @@
-"""Settings for the api-request module."""
-
-import logging
-from dataclasses import asdict, dataclass
-from pathlib import Path
-from uuid import NAMESPACE_DNS, uuid5
-
-from pydantic_settings import BaseSettings, SettingsConfigDict
-from typer import get_app_dir
-
-from pfmsoft.api_request import (
-    __app_name__,
-    __project_namespace__,
-    __url__,
-    __version__,
-)
-
-logger = logging.getLogger(__name__)
-
-USER_AGENT = f"{__app_name__} ({__version__}) (+{__url__})"
-APP_DOMAIN = f"{__project_namespace__}.{__app_name__}"
-APP_NAMESPACE = uuid5(NAMESPACE_DNS, APP_DOMAIN)
-ENV_PREFIX = APP_DOMAIN.replace(".", "_").replace("-", "_").upper() + "_"
-SETTINGS_KEY = ENV_PREFIX + "SETTINGS"
-
-
-@dataclass(slots=True, kw_only=True)
-class ApiRequestSettings:
-    """Settings for the api-request module."""
-
-    application_directory: Path
-    logging_directory: Path
-    web_cache_path: Path
-
-
-class ApiRequestSettingsPydantic(BaseSettings):
-    """Pydantic settings for the api-request module."""
-
-    application_directory: Path = Path(get_app_dir(__app_name__))
-
-    model_config = SettingsConfigDict(
-        env_prefix=ENV_PREFIX,
-        env_file=(".env", ".env.dev"),
-        env_file_encoding="utf-8",
-    )
-
-
-def get_settings() -> ApiRequestSettings:
-    """Get the settings for the api-request module."""
-    logger.info("Loading settings from environment variables...")
-    logger.info(f"Environment variable prefix: {ENV_PREFIX}")
-    pydantic_settings = ApiRequestSettingsPydantic()
-    logger.info(
-        f"Loaded settings from environment variables: {pydantic_settings.model_dump()}"
-    )
-    application_directory = pydantic_settings.application_directory.resolve()
-    if not application_directory.exists():
-        application_directory.mkdir(parents=True, exist_ok=True)
-    settings = ApiRequestSettings(
-        application_directory=application_directory,
-        logging_directory=application_directory / "logs",
-        web_cache_path=application_directory / "api_requests_web_cache.sqlite",
-    )
-    logger.info(f"Resolved application settings: {asdict(settings)}")
-    return settings