senpai 2.9.1__py3-none-any.whl

senpai/__init__.py

@@ -0,0 +1,36 @@
+import warnings
+from importlib.metadata import PackageNotFoundError, version
+
+from senpai.core.logging import setup_logging
+
+setup_logging()
+
+
+try:
+    __version__ = version("senpai")
+except PackageNotFoundError:
+    try:
+        # astro-senpai <= 2.9.0 shipped the code under its own name
+        __version__ = version("astro-senpai")
+    except PackageNotFoundError:
+        __version__ = "unknown"  # Fallback if the package is not installed
+
+
+def _warn_if_installed_via_astro_senpai():
+    # astro-senpai is now an empty package that depends on senpai. Wheels cannot
+    # print at install time, so tell people at import to depend on senpai.
+    try:
+        version("senpai")
+        version("astro-senpai")
+    except PackageNotFoundError:
+        return
+    warnings.warn(
+        "senpai was installed through astro-senpai, its old PyPI name. Depend on "
+        "senpai instead: pip install senpai, or uv add senpai && uv remove "
+        "astro-senpai.",
+        FutureWarning,
+        stacklevel=3,
+    )
+
+
+_warn_if_installed_via_astro_senpai()

senpai/api/main.py

@@ -0,0 +1,165 @@
+"""
+Main entry point for API server.
+"""
+
+import concurrent.futures
+import contextlib
+import logging
+import os
+from pathlib import Path
+
+import click
+from fastapi import FastAPI
+from fastapi.middleware.cors import CORSMiddleware
+
+from senpai.astrometry import examine_indices, test_astrometry_install
+from senpai.core.config import AppConfig, initialize_config
+from senpai.core.constants import LOCAL_APP_CONFIG_OVERRIDE
+from senpai.core.logging import get_local_config, setup_logging
+
+logger = logging.getLogger(__name__)
+
+DEFAULT_EXECUTOR_MAX_WORKERS = max(1, (os.cpu_count() or 2) - 1)
+
+
+def setup_routes(app: FastAPI) -> None:
+    """Configure application routes"""
+    logger.info("Setting up routes...")
+    # Import routes here to avoid circular imports
+    from senpai.api.routes import astrometry, senpai
+
+    app.include_router(senpai.router, tags=["SENPAI"], prefix="/senpai")
+    app.include_router(astrometry.router, tags=["Astrometry"], prefix="/astrometry")
+
+    logger.info("Routes setup completed")
+
+
+@contextlib.asynccontextmanager
+async def lifespan(app: FastAPI):
+    max_workers_env = os.getenv("SENPAI_EXECUTOR_WORKERS")
+    max_workers = int(max_workers_env) if max_workers_env else DEFAULT_EXECUTOR_MAX_WORKERS
+    executor = concurrent.futures.ProcessPoolExecutor(max_workers=max_workers, initializer=_init_pool_worker)
+    logger.info(f"Using ProcessPoolExecutor with max_workers={max_workers}")
+
+    app.state.executor = executor
+
+    try:
+        test_astrometry_install()
+        examine_indices()
+        yield
+    finally:
+        executor.shutdown(wait=False, cancel_futures=True)
+
+
+def _init_pool_worker():
+    from senpai.core.config import initialize_config
+
+    cfg_path = os.getenv("SENPAI_CONFIG")
+    if cfg_path:
+        initialize_config(Path(cfg_path))
+
+
+def create_app(config: AppConfig | str | Path | None = None) -> FastAPI:
+    """Application factory supporting both local and Lambda environments"""
+    # Suppress specific warnings
+    # Setup logging, will check if already configured
+    # Example usage
+    setup_logging(
+        level="INFO",
+        disabled_loggers=["matplotlib", "astropy.io.fits", "scipy.optimize"],
+    )
+
+    if config is None:
+        config = Path(os.environ.get("SENPAI_CONFIG", LOCAL_APP_CONFIG_OVERRIDE))
+
+    if isinstance(config, (str, Path)):
+        logger.info(f"Loading config from path: {config}")
+        config = initialize_config(config)
+
+    # Create FastAPI app with conditional docs
+    logger.info(f"Creating app with config:\n{config.model_dump_json(indent=2)}")
+    app = FastAPI(
+        title="SENPAI API",
+        version=config.version,
+        debug=config.debug,
+        docs_url="/docs",
+        redoc_url="/redoc",
+        openapi_url="/openapi.json",
+        lifespan=lifespan,
+    )
+
+    # Store uvicorn logging config
+    app.state.log_config = get_local_config()
+    app.state.log_level = config.logging.level.lower()
+
+    # Add CORS middleware configuration
+    app.add_middleware(
+        CORSMiddleware,
+        allow_origins=["*"],
+        allow_credentials=True,
+        allow_methods=["*"],
+        allow_headers=["*"],
+    )
+
+    # Setup routes
+    setup_routes(app)
+
+    logger.info("App created successfully")
+
+    return app
+
+
+@click.command()
+@click.option("--host", default="0.0.0.0", show_default=True)
+@click.option("--port", default=8000, show_default=True)
+@click.option("--workers", default=1, show_default=True, envvar="WORKERS")
+@click.option(
+    "--config",
+    type=click.Path(exists=True, path_type=Path),
+    default=LOCAL_APP_CONFIG_OVERRIDE,  # CLI use defaults to local config. Lambda does not use this.
+    show_default=True,
+)
+def run_server(host: str, port: int, workers: int | None, config: Path | None = None) -> None:
+    """Run the API server locally"""
+    import uvicorn
+
+    # Load config first
+    config_path = config or LOCAL_APP_CONFIG_OVERRIDE
+    app_config = initialize_config(config_path)
+
+    logger.info("Starting uvicorn server...")
+
+    try:
+        workers = int(workers)
+    except ValueError:
+        workers = 1
+
+    if workers > 1:
+        # Set config path in the env so zero-arg factory can pick it up
+        os.environ.setdefault("SENPAI_CONFIG", str(config_path))
+
+        # Using zero-arg factory so workers can spawn
+        uvicorn.run(
+            "senpai.api.main:create_app",
+            factory=True,
+            host=host,
+            port=port,
+            workers=workers,
+            log_config=get_local_config(),
+            log_level=app_config.logging.level.lower(),
+        )
+    else:
+        # Create and run app
+        app = create_app(app_config)
+        # Single process - use in-memory app
+        uvicorn.run(
+            app,
+            host=host,
+            port=port,
+            log_config=app.state.log_config,
+            log_level=app.state.log_level,
+        )
+
+
+if __name__ == "__main__":
+    run_server()

senpai/api/models/examples.py

@@ -0,0 +1,51 @@
+from typing import Any, Dict
+
+from pydantic import BaseModel
+
+from senpai.engine.models.starfield import ImageMetadata, StarInImage, StarListImage
+
+# A small (x, y, counts) sample of a real 1024x1024 detection list, spanning the
+# brightness range of the field. This is an illustrative payload for /docs, not
+# a solvable star field -- a full field would swamp the Swagger UI.
+#
+# It is a literal on purpose. FastAPI evaluates ``Body(examples=...)`` at import
+# time, so anything read from disk here runs on every ``create_app()``; reading
+# a repo test fixture there broke non-editable installs entirely (issue #6).
+_EXAMPLE_DETECTIONS: list[tuple[float, float, float]] = [
+    (125.432, 568.183, 917909.8),
+    (291.171, 210.435, 10242.4),
+    (611.514, 645.360, 6810.8),
+    (501.782, 543.489, 4385.3),
+    (545.078, 117.519, 3354.3),
+    (158.725, 198.313, 2544.5),
+    (205.254, 510.905, 1744.2),
+    (372.452, 621.724, 1586.4),
+    (415.934, 294.103, 1235.9),
+    (78.394, 195.271, 1004.6),
+]
+
+
+class StarListImageExample(BaseModel):
+    def __init__(self):
+        super().__init__()
+        self._value: StarListImage | None = None
+
+    @property
+    def summary(self) -> str:
+        return "A list of stars in an image with image metadata"
+
+    @property
+    def value(self) -> StarListImage:
+        """Get example StarListImage value"""
+        if self._value is None:
+            self._value = StarListImage(
+                detections=[StarInImage(x=x, y=y, counts=counts) for x, y, counts in _EXAMPLE_DETECTIONS],
+                image_metadata=ImageMetadata(
+                    image_id="x_y_counts", width=1024, height=1024, boresight_ra=245.45, boresight_dec=41.8
+                ),
+            )
+        return self._value
+
+    def get_openapi_examples(self) -> Dict[str, Dict[str, Any]]:
+        """Convert to OpenAPI examples format"""
+        return [self.value]