openconstructionerp 0.2.1__py3-none-any.whl

app/__main__.py

@@ -0,0 +1,56 @@
+"""Entry point for PyInstaller / standalone execution.
+
+Usage:
+    python -m app                    # Dev mode
+    openestimate-server.exe          # Production (PyInstaller bundle)
+"""
+
+import os
+import sys
+import multiprocessing
+
+
+def main() -> None:
+    """Start the OpenConstructionERP backend server."""
+    import uvicorn
+
+    # Parse CLI args: --host X --port Y
+    host = "127.0.0.1"
+    port = 8741
+    args = sys.argv[1:]
+    for i, arg in enumerate(args):
+        if arg == "--host" and i + 1 < len(args):
+            host = args[i + 1]
+        elif arg == "--port" and i + 1 < len(args):
+            try:
+                port = int(args[i + 1])
+            except ValueError:
+                pass
+
+    # Also check env vars as fallback
+    host = os.environ.get("HOST", host)
+    port = int(os.environ.get("PORT", str(port)))
+
+    # Desktop app mode: serve frontend, production settings
+    if getattr(sys, "frozen", False):
+        os.environ.setdefault("SERVE_FRONTEND", "1")
+        os.environ.setdefault("APP_ENV", "production")
+        os.environ.setdefault("APP_DEBUG", "false")
+
+    print(f"Starting OpenConstructionERP on http://{host}:{port}")
+
+    # Use direct app import for PyInstaller compatibility
+    from app.main import create_app
+    app = create_app()
+
+    uvicorn.run(
+        app,
+        host=host,
+        port=port,
+        log_level="info",
+    )
+
+
+if __name__ == "__main__":
+    multiprocessing.freeze_support()
+    main()

app/cli.py

@@ -0,0 +1,236 @@
+"""OpenEstimate CLI — run the platform from the command line.
+
+Usage:
+    openestimate serve [--host HOST] [--port PORT] [--data-dir DIR]
+    openestimate init  [--data-dir DIR]
+    openestimate version
+    openestimate seed  [--demo]
+"""
+
+import argparse
+import logging
+import os
+import sys
+import webbrowser
+from pathlib import Path
+
+DEFAULT_DATA_DIR = Path.home() / ".openestimate"
+DEFAULT_HOST = "127.0.0.1"
+DEFAULT_PORT = 8080
+
+logger = logging.getLogger("openestimate.cli")
+
+BANNER = r"""
+   ____                   ______     __  _                 __
+  / __ \____  ___  ____  / ____/____/ /_(_)___ ___  ____ _/ /_____  _____
+ / / / / __ \/ _ \/ __ \/ __/ / ___/ __/ / __ `__ \/ __ `/ __/ __ \/ ___/
+/ /_/ / /_/ /  __/ / / / /___(__  ) /_/ / / / / / / /_/ / /_/ /_/ / /
+\____/ .___/\___/_/ /_/_____/____/\__/_/_/ /_/ /_/\__,_/\__/\____/_/
+    /_/                                                    v{version}
+"""
+
+
+def _setup_env(data_dir: Path, host: str, port: int) -> None:
+    """Configure environment variables for local-first operation."""
+    data_dir.mkdir(parents=True, exist_ok=True)
+
+    db_path = data_dir / "openestimate.db"
+
+    os.environ.setdefault("DATABASE_URL", f"sqlite+aiosqlite:///{db_path}")
+    os.environ.setdefault("DATABASE_SYNC_URL", f"sqlite:///{db_path}")
+    os.environ.setdefault("VECTOR_BACKEND", "lancedb")
+    os.environ.setdefault("VECTOR_DATA_DIR", str(data_dir / "vectors"))
+    os.environ.setdefault("APP_ENV", "development")
+    os.environ.setdefault("APP_DEBUG", "false")
+    os.environ.setdefault("ALLOWED_ORIGINS", f"http://{host}:{port}")
+    os.environ.setdefault("JWT_SECRET", "openestimate-local-dev-key")
+
+    # Enable frontend serving
+    os.environ["SERVE_FRONTEND"] = "true"
+
+
+def cmd_serve(args: argparse.Namespace) -> None:
+    """Start the OpenEstimate server."""
+    data_dir = Path(args.data_dir)
+    _setup_env(data_dir, args.host, args.port)
+
+    from app.config import get_settings
+
+    settings = get_settings()
+    print(BANNER.format(version=settings.app_version))
+    print(f"  Data directory:  {data_dir}")
+    print(f"  Database:        {os.environ.get('DATABASE_URL', 'sqlite')}")
+    print(f"  Server:          http://{args.host}:{args.port}")
+    print(f"  API docs:        http://{args.host}:{args.port}/api/docs")
+    print()
+
+    if args.open:
+        import threading
+
+        def _open_browser() -> None:
+            import time
+
+            time.sleep(2)
+            webbrowser.open(f"http://{args.host}:{args.port}")
+
+        threading.Thread(target=_open_browser, daemon=True).start()
+
+    import uvicorn
+
+    uvicorn.run(
+        "app.main:create_app",
+        factory=True,
+        host=args.host,
+        port=args.port,
+        log_level="info",
+    )
+
+
+def cmd_init(args: argparse.Namespace) -> None:
+    """Initialize data directory and database."""
+    data_dir = Path(args.data_dir)
+    data_dir.mkdir(parents=True, exist_ok=True)
+    (data_dir / "vectors").mkdir(exist_ok=True)
+    (data_dir / "uploads").mkdir(exist_ok=True)
+
+    print(f"Initialized data directory: {data_dir}")
+    print(f"  Database will be at: {data_dir / 'openestimate.db'}")
+    print(f"  Vector storage:      {data_dir / 'vectors'}")
+    print(f"  Uploads:             {data_dir / 'uploads'}")
+    print()
+    print("Run 'openestimate serve' to start the server.")
+
+
+def cmd_version(args: argparse.Namespace) -> None:
+    """Print version information."""
+    try:
+        from app.config import Settings
+
+        version = Settings.model_fields["app_version"].default
+    except Exception:
+        version = "unknown"
+
+    print(f"OpenEstimate v{version}")
+    print(f"Python {sys.version}")
+
+
+def cmd_seed(args: argparse.Namespace) -> None:
+    """Load demo data into the database."""
+    data_dir = Path(args.data_dir)
+    _setup_env(data_dir, DEFAULT_HOST, DEFAULT_PORT)
+
+    import asyncio
+
+    async def _run_seed() -> None:
+        # Initialize database tables
+        from app.config import get_settings
+
+        settings = get_settings()
+        if "sqlite" in settings.database_url:
+            from app.database import Base, engine
+
+            # Import all models
+            from app.modules.users import models as _  # noqa: F401
+            from app.modules.projects import models as _  # noqa: F401
+            from app.modules.boq import models as _  # noqa: F401
+            from app.modules.costs import models as _  # noqa: F401
+
+            async with engine.begin() as conn:
+                await conn.run_sync(Base.metadata.create_all)
+
+        print("Database tables created.")
+
+        if args.demo:
+            print("Loading demo project data...")
+            from app.core.demo_projects import install_demo_project
+            from app.database import async_session_factory
+
+            async with async_session_factory() as session:
+                result = await install_demo_project(session, "office_tower_berlin")
+                await session.commit()
+                print(f"Demo project installed: {result.get('project_name', 'OK')}")
+
+        print("Seed complete.")
+
+    asyncio.run(_run_seed())
+
+
+def main() -> None:
+    """CLI entry point."""
+    parser = argparse.ArgumentParser(
+        prog="openestimate",
+        description="OpenEstimate — open-source construction cost estimation platform",
+    )
+    subparsers = parser.add_subparsers(dest="command")
+
+    # serve
+    serve_p = subparsers.add_parser("serve", help="Start the OpenEstimate server")
+    serve_p.add_argument(
+        "--host",
+        default=DEFAULT_HOST,
+        help=f"Bind host (default: {DEFAULT_HOST})",
+    )
+    serve_p.add_argument(
+        "--port",
+        type=int,
+        default=DEFAULT_PORT,
+        help=f"Bind port (default: {DEFAULT_PORT})",
+    )
+    serve_p.add_argument(
+        "--data-dir",
+        default=str(DEFAULT_DATA_DIR),
+        help=f"Data directory (default: {DEFAULT_DATA_DIR})",
+    )
+    serve_p.add_argument(
+        "--open",
+        action="store_true",
+        help="Open browser after startup",
+    )
+
+    # init
+    init_p = subparsers.add_parser("init", help="Initialize data directory")
+    init_p.add_argument(
+        "--data-dir",
+        default=str(DEFAULT_DATA_DIR),
+        help=f"Data directory (default: {DEFAULT_DATA_DIR})",
+    )
+
+    # version
+    subparsers.add_parser("version", help="Show version information")
+
+    # seed
+    seed_p = subparsers.add_parser("seed", help="Load seed/demo data")
+    seed_p.add_argument(
+        "--demo",
+        action="store_true",
+        help="Install demo project with sample data",
+    )
+    seed_p.add_argument(
+        "--data-dir",
+        default=str(DEFAULT_DATA_DIR),
+        help=f"Data directory (default: {DEFAULT_DATA_DIR})",
+    )
+
+    args = parser.parse_args()
+
+    if args.command == "serve":
+        cmd_serve(args)
+    elif args.command == "init":
+        cmd_init(args)
+    elif args.command == "version":
+        cmd_version(args)
+    elif args.command == "seed":
+        cmd_seed(args)
+    elif args.command is None:
+        # Default: serve with defaults
+        args.host = DEFAULT_HOST
+        args.port = DEFAULT_PORT
+        args.data_dir = str(DEFAULT_DATA_DIR)
+        args.open = True
+        cmd_serve(args)
+    else:
+        parser.print_help()
+
+
+if __name__ == "__main__":
+    main()

app/cli_static.py

@@ -0,0 +1,92 @@
+"""Serve frontend static files from the installed package or dev build.
+
+When running via `openestimate serve` or with SERVE_FRONTEND=true,
+the FastAPI app serves the pre-built React frontend directly — no Nginx needed.
+
+Frontend is found in two locations (checked in order):
+1. app/_frontend_dist/ — bundled inside the Python wheel (pip install)
+2. ../frontend/dist/   — development mode (repo checkout)
+"""
+
+import logging
+from pathlib import Path
+
+from fastapi import FastAPI
+from fastapi.staticfiles import StaticFiles
+from starlette.responses import FileResponse
+
+logger = logging.getLogger(__name__)
+
+
+def get_frontend_dir() -> Path:
+    """Find the bundled frontend dist directory.
+
+    Returns:
+        Path to the directory containing index.html and assets/.
+
+    Raises:
+        FileNotFoundError: If no frontend build is found.
+    """
+    # Option 1: installed as package (pip install openestimate)
+    pkg_dir = Path(__file__).parent / "_frontend_dist"
+    if pkg_dir.is_dir() and (pkg_dir / "index.html").exists():
+        return pkg_dir
+
+    # Option 2: development — frontend/dist relative to repo root
+    repo_root = Path(__file__).resolve().parent.parent.parent  # backend/app/../../
+    dev_dist = repo_root / "frontend" / "dist"
+    if dev_dist.is_dir() and (dev_dist / "index.html").exists():
+        return dev_dist
+
+    raise FileNotFoundError(
+        "Frontend dist not found. "
+        "Run 'npm run build' in frontend/ or install the openestimate wheel."
+    )
+
+
+def mount_frontend(app: FastAPI) -> None:
+    """Mount frontend static files on the FastAPI app.
+
+    Serves:
+    - /assets/* — hashed JS/CSS bundles (long cache)
+    - /favicon.svg, /logo.svg — static resources
+    - /* (catch-all) — index.html for SPA routing
+    """
+    try:
+        frontend_dir = get_frontend_dir()
+    except FileNotFoundError:
+        logger.warning("Frontend dist not found — serving API only")
+        return
+
+    logger.info("Serving frontend from %s", frontend_dir)
+
+    # Serve hashed assets (JS, CSS)
+    assets_dir = frontend_dir / "assets"
+    if assets_dir.is_dir():
+        app.mount(
+            "/assets",
+            StaticFiles(directory=str(assets_dir)),
+            name="frontend-assets",
+        )
+
+    # Serve individual static files
+    index_path = frontend_dir / "index.html"
+
+    for static_name in ("favicon.svg", "logo.svg"):
+        static_path = frontend_dir / static_name
+        if static_path.exists():
+            # Use a factory to capture the correct path in the closure
+            def _make_static_handler(fpath: Path):  # noqa: ANN202
+                async def _handler():  # noqa: ANN202
+                    return FileResponse(str(fpath))
+                return _handler
+
+            app.get(f"/{static_name}", include_in_schema=False)(
+                _make_static_handler(static_path)
+            )
+
+    # SPA catch-all: any route not matched by /api/* or /assets/* → index.html
+    @app.get("/{path:path}", include_in_schema=False)
+    async def spa_fallback(path: str) -> FileResponse:
+        """Serve index.html for all frontend routes (SPA routing)."""
+        return FileResponse(str(index_path))

app/config.py

@@ -0,0 +1,94 @@
+"""Application configuration.
+
+Loads from environment variables with .env file fallback.
+All settings are typed and validated via Pydantic.
+"""
+
+from functools import lru_cache
+from typing import Literal
+
+from pydantic import Field, computed_field
+from pydantic_settings import BaseSettings, SettingsConfigDict
+
+
+class Settings(BaseSettings):
+    """OpenConstructionERP application settings."""
+
+    model_config = SettingsConfigDict(
+        env_file=".env",
+        env_file_encoding="utf-8",
+        case_sensitive=False,
+        extra="ignore",
+    )
+
+    # ── App ──────────────────────────────────────────────────────────────
+    app_name: str = "OpenConstructionERP"
+    app_version: str = "0.2.1"
+    app_env: Literal["development", "staging", "production"] = "development"
+    app_debug: bool = True
+    log_level: Literal["DEBUG", "INFO", "WARNING", "ERROR"] = "INFO"
+    allowed_origins: str = "http://localhost:5173"
+
+    # ── Database ─────────────────────────────────────────────────────────
+    # Default: SQLite (zero config, works out of the box)
+    # For production: set DATABASE_URL=postgresql+asyncpg://user:pass@host/db
+    database_url: str = "sqlite+aiosqlite:///./openestimate.db"
+    database_sync_url: str = "sqlite:///./openestimate.db"
+    database_pool_size: int = 20
+    database_max_overflow: int = 10
+    database_echo: bool = False
+
+    # ── Redis ────────────────────────────────────────────────────────────
+    redis_url: str | None = "redis://localhost:6379/0"
+
+    # ── Storage (S3/MinIO) ───────────────────────────────────────────────
+    s3_endpoint: str = "http://localhost:9000"
+    s3_access_key: str = ""
+    s3_secret_key: str = ""
+    s3_bucket: str = "openestimate"
+    s3_region: str = "us-east-1"
+
+    # ── Auth ─────────────────────────────────────────────────────────────
+    jwt_secret: str = "openestimate-local-dev-key"
+    jwt_algorithm: str = "HS256"
+    jwt_expire_minutes: int = 60
+    jwt_refresh_expire_days: int = 30
+
+    # ── AI / Vector ──────────────────────────────────────────────────────
+    vector_backend: str = "lancedb"  # "lancedb" (embedded, default) or "qdrant" (server)
+    qdrant_url: str | None = "http://localhost:6333"
+    vector_data_dir: str = ""  # LanceDB storage path, default: ~/.openestimator/data/vectors
+    openai_api_key: str | None = None
+    anthropic_api_key: str | None = None
+    gemini_api_key: str | None = None
+    openrouter_api_key: str | None = None
+    mistral_api_key: str | None = None
+    groq_api_key: str | None = None
+    deepseek_api_key: str | None = None
+
+    # ── External Services ────────────────────────────────────────────────
+    cad_converter_url: str | None = "http://localhost:8001"
+    cv_pipeline_url: str | None = "http://localhost:8002"
+
+    # ── Validation ───────────────────────────────────────────────────────
+    default_validation_rule_sets: list[str] = Field(
+        default=["boq_quality"],
+        description="Default validation rule sets applied to all projects",
+    )
+
+    # ── Computed ─────────────────────────────────────────────────────────
+    @computed_field  # type: ignore[prop-decorator]
+    @property
+    def is_production(self) -> bool:
+        return self.app_env == "production"
+
+    @computed_field  # type: ignore[prop-decorator]
+    @property
+    def cors_origins(self) -> list[str]:
+        return [o.strip() for o in self.allowed_origins.split(",")]
+
+
+@lru_cache
+def get_settings() -> Settings:
+    """Cached settings singleton."""
+    return Settings()

app/core/cache.py

@@ -0,0 +1,180 @@
+"""Simple caching layer with in-memory fallback.
+
+Uses Redis if available, falls back to in-memory LRU cache.
+Thread-safe. TTL-based expiration.
+
+Usage:
+    from app.core.cache import cache
+
+    # Set/get
+    await cache.set("key", {"data": 123}, ttl=300)
+    value = await cache.get("key")
+
+    # Decorator
+    @cached(ttl=60, prefix="costs")
+    async def search_costs(query: str) -> list:
+        ...
+"""
+
+import asyncio
+import json
+import logging
+import time
+from collections import OrderedDict
+from functools import wraps
+from threading import Lock
+from typing import Any, Callable
+
+logger = logging.getLogger(__name__)
+
+
+class InMemoryCache:
+    """LRU cache with TTL expiration. No external dependencies."""
+
+    def __init__(self, max_size: int = 1000) -> None:
+        self.max_size = max_size
+        self._store: OrderedDict[str, tuple[Any, float]] = OrderedDict()
+        self._lock = Lock()
+
+    async def get(self, key: str) -> Any | None:
+        with self._lock:
+            if key not in self._store:
+                return None
+            value, expires_at = self._store[key]
+            if expires_at and time.time() > expires_at:
+                del self._store[key]
+                return None
+            self._store.move_to_end(key)
+            return value
+
+    async def set(self, key: str, value: Any, ttl: int = 300) -> None:
+        expires_at = time.time() + ttl if ttl > 0 else 0
+        with self._lock:
+            self._store[key] = (value, expires_at)
+            self._store.move_to_end(key)
+            # Evict oldest if over max size
+            while len(self._store) > self.max_size:
+                self._store.popitem(last=False)
+
+    async def delete(self, key: str) -> None:
+        with self._lock:
+            self._store.pop(key, None)
+
+    async def clear(self) -> None:
+        with self._lock:
+            self._store.clear()
+
+    def stats(self) -> dict[str, Any]:
+        with self._lock:
+            now = time.time()
+            active = sum(1 for _, (_, exp) in self._store.items() if not exp or exp > now)
+            return {
+                "engine": "in-memory",
+                "total_keys": len(self._store),
+                "active_keys": active,
+                "max_size": self.max_size,
+            }
+
+
+class RedisCache:
+    """Redis-backed cache. Falls back to in-memory if Redis unavailable."""
+
+    def __init__(self) -> None:
+        self._redis: Any | None = None
+        self._fallback = InMemoryCache()
+
+    async def _get_redis(self) -> Any | None:
+        if self._redis is not None:
+            return self._redis
+        try:
+            from app.config import get_settings
+
+            settings = get_settings()
+            if not settings.redis_url:
+                return None
+            import redis.asyncio as aioredis
+
+            self._redis = aioredis.from_url(
+                settings.redis_url, decode_responses=True
+            )
+            await self._redis.ping()
+            logger.info("Redis cache connected: %s", settings.redis_url)
+            return self._redis
+        except Exception:
+            logger.debug("Redis not available, using in-memory cache")
+            self._redis = False  # Mark as unavailable
+            return None
+
+    async def get(self, key: str) -> Any | None:
+        r = await self._get_redis()
+        if r:
+            try:
+                val = await r.get(f"oe:{key}")
+                return json.loads(val) if val else None
+            except Exception:
+                pass
+        return await self._fallback.get(key)
+
+    async def set(self, key: str, value: Any, ttl: int = 300) -> None:
+        r = await self._get_redis()
+        if r:
+            try:
+                await r.setex(f"oe:{key}", ttl, json.dumps(value, default=str))
+                return
+            except Exception:
+                pass
+        await self._fallback.set(key, value, ttl)
+
+    async def delete(self, key: str) -> None:
+        r = await self._get_redis()
+        if r:
+            try:
+                await r.delete(f"oe:{key}")
+            except Exception:
+                pass
+        await self._fallback.delete(key)
+
+    async def clear(self) -> None:
+        await self._fallback.clear()
+
+    def stats(self) -> dict[str, Any]:
+        if self._redis and self._redis is not False:
+            return {"engine": "redis", "status": "connected"}
+        return self._fallback.stats()
+
+
+# Global cache instance
+cache = RedisCache()
+
+
+def cached(ttl: int = 300, prefix: str = "") -> Callable:
+    """Decorator for caching async function results.
+
+    Args:
+        ttl: Time-to-live in seconds (default 5 minutes).
+        prefix: Key prefix for namespacing.
+    """
+
+    def decorator(func: Callable) -> Callable:
+        @wraps(func)
+        async def wrapper(*args: Any, **kwargs: Any) -> Any:
+            # Build cache key from function name + args
+            key_parts = [prefix or func.__name__]
+            key_parts.extend(str(a) for a in args)
+            key_parts.extend(f"{k}={v}" for k, v in sorted(kwargs.items()))
+            key = ":".join(key_parts)
+
+            # Check cache
+            result = await cache.get(key)
+            if result is not None:
+                return result
+
+            # Call function and cache result
+            result = await func(*args, **kwargs)
+            if result is not None:
+                await cache.set(key, result, ttl)
+            return result
+
+        return wrapper
+
+    return decorator