pyarchinit-mini 1.9.28__py3-none-any.whl

pyarchinit_mini/__init__.py

@@ -0,0 +1,40 @@
+"""
+PyArchInit-Mini: Standalone Archaeological Data Management System
+
+A lightweight, modular version of PyArchInit focused on core archaeological
+data management functionality without GIS dependencies.
+
+Features:
+- Site management with complete CRUD operations
+- Stratigraphic Unit (US) management (49 fields, 6 tabs)
+- Material inventory management (37 fields, 8 tabs, ICCD thesaurus)
+- Harris Matrix generation (Matplotlib + Graphviz with 4 grouping modes)
+- Stratigraphic validation (paradoxes, cycles, auto-fix)
+- Multi-database support (PostgreSQL/SQLite upload/connect)
+- PDF export (Sites, US, Inventario, Harris Matrix)
+- Excel/CSV export and batch import
+- Multi-user authentication with role-based permissions (Admin, Operator, Viewer)
+- Real-time collaboration with WebSocket notifications (Flask-SocketIO)
+- Analytics dashboard with 8 chart types (Chart.js for web, matplotlib for desktop)
+- REST API interface (FastAPI with JWT authentication)
+- Web UI interface (Flask with session-based auth) - 100% Desktop GUI parity
+- Desktop GUI interface (Tkinter)
+- CLI interface
+- Scalable and modular architecture
+"""
+
+__version__ = "1.9.23"
+__author__ = "PyArchInit Team"
+__email__ = "enzo.ccc@gmail.com"
+
+from .database.manager import DatabaseManager
+from .services.site_service import SiteService
+from .services.us_service import USService
+from .services.inventario_service import InventarioService
+
+__all__ = [
+    "DatabaseManager",
+    "SiteService", 
+    "USService",
+    "InventarioService"
+]

pyarchinit_mini/api/__init__.py

@@ -0,0 +1,92 @@
+"""
+FastAPI REST API for PyArchInit-Mini
+"""
+
+from fastapi import FastAPI
+from fastapi.middleware.cors import CORSMiddleware
+from pyarchinit_mini import __version__
+from .site import router as site_router
+from .us import router as us_router
+from .inventario import router as inventario_router
+from .auth import router as auth_router
+from .graphml import router as graphml_router
+
+def create_app(database_url: str = None) -> FastAPI:
+    """
+    Create and configure FastAPI application
+
+    Args:
+        database_url: Database connection URL
+
+    Returns:
+        Configured FastAPI app
+    """
+    app = FastAPI(
+        title="PyArchInit-Mini API",
+        description="REST API for archaeological data management",
+        version=__version__,
+        docs_url="/docs",
+        redoc_url="/redoc"
+    )
+    
+    # Add CORS middleware
+    app.add_middleware(
+        CORSMiddleware,
+        allow_origins=["*"],  # Configure appropriately for production
+        allow_credentials=True,
+        allow_methods=["*"],
+        allow_headers=["*"],
+    )
+    
+    # Include routers
+    app.include_router(auth_router)  # Auth routes already have /api/auth prefix
+    app.include_router(site_router, prefix="/api/v1/sites", tags=["sites"])
+    app.include_router(us_router, prefix="/api/v1/us", tags=["stratigraphic-units"])
+    app.include_router(inventario_router, prefix="/api/v1/inventario", tags=["inventory"])
+    app.include_router(graphml_router, prefix="/api/graphml", tags=["graphml-converter"])
+    
+    # Store database URL in app state
+    if database_url:
+        app.state.database_url = database_url
+    
+    @app.get("/")
+    async def root():
+        return {
+            "message": "PyArchInit-Mini API",
+            "version": __version__,
+            "docs": "/docs"
+        }
+    
+    @app.get("/health")
+    async def health_check():
+        return {"status": "healthy"}
+    
+    return app
+
+
+def run_server():
+    """
+    Entry point for running the API server via console script.
+    """
+    import uvicorn
+    import os
+
+    # Get configuration from environment or use defaults
+    host = os.getenv("PYARCHINIT_API_HOST", "0.0.0.0")
+    port = int(os.getenv("PYARCHINIT_API_PORT", "8000"))
+    reload = os.getenv("PYARCHINIT_API_RELOAD", "false").lower() == "true"
+
+    print(f"Starting PyArchInit-Mini API server on {host}:{port}")
+    print(f"API Documentation: http://{host if host != '0.0.0.0' else 'localhost'}:{port}/docs")
+
+    # Run the server
+    uvicorn.run(
+        "pyarchinit_mini.api:create_app",
+        host=host,
+        port=port,
+        reload=reload,
+        factory=True
+    )
+
+
+__all__ = ["create_app", "run_server"]

pyarchinit_mini/api/auth.py

@@ -0,0 +1,312 @@
+"""
+Authentication API endpoints
+"""
+
+from typing import Optional
+from datetime import timedelta
+
+from fastapi import APIRouter, Depends, HTTPException, status
+from fastapi.security import OAuth2PasswordBearer, OAuth2PasswordRequestForm
+from pydantic import BaseModel, EmailStr
+
+from pyarchinit_mini.database.manager import DatabaseManager
+from pyarchinit_mini.services.user_service import UserService
+from pyarchinit_mini.models.user import UserRole
+from pyarchinit_mini.utils.auth import create_access_token, decode_access_token
+from pyarchinit_mini.api.dependencies import get_database_manager
+
+
+# OAuth2 scheme
+oauth2_scheme = OAuth2PasswordBearer(tokenUrl="/api/auth/login")
+
+
+# Pydantic schemas
+class Token(BaseModel):
+    """Token response"""
+    access_token: str
+    token_type: str
+
+
+class TokenData(BaseModel):
+    """Token payload data"""
+    username: Optional[str] = None
+
+
+class UserResponse(BaseModel):
+    """User response schema"""
+    id: int
+    username: str
+    email: str
+    full_name: Optional[str] = None
+    role: str
+    is_active: bool
+    is_superuser: bool
+
+
+class UserCreate(BaseModel):
+    """User creation schema"""
+    username: str
+    email: EmailStr
+    password: str
+    full_name: Optional[str] = None
+    role: UserRole = UserRole.VIEWER
+
+
+class UserUpdate(BaseModel):
+    """User update schema"""
+    email: Optional[EmailStr] = None
+    full_name: Optional[str] = None
+    role: Optional[UserRole] = None
+    is_active: Optional[bool] = None
+    password: Optional[str] = None
+
+
+# Router
+router = APIRouter(prefix="/api/auth", tags=["authentication"])
+
+
+async def get_current_user(
+    token: str = Depends(oauth2_scheme),
+    db_manager: DatabaseManager = Depends(get_database_manager)
+) -> dict:
+    """
+    Get current authenticated user from token
+
+    Args:
+        token: JWT token
+        db_manager: Database manager
+
+    Returns:
+        dict: Current user data
+
+    Raises:
+        HTTPException: If authentication fails
+    """
+    credentials_exception = HTTPException(
+        status_code=status.HTTP_401_UNAUTHORIZED,
+        detail="Could not validate credentials",
+        headers={"WWW-Authenticate": "Bearer"},
+    )
+
+    # Decode token
+    payload = decode_access_token(token)
+    if payload is None:
+        raise credentials_exception
+
+    username: str = payload.get("sub")
+    if username is None:
+        raise credentials_exception
+
+    # Get user
+    user_service = UserService(db_manager)
+    user = user_service.get_user_by_username(username)
+
+    if user is None:
+        raise credentials_exception
+
+    if not user["is_active"]:
+        raise HTTPException(
+            status_code=status.HTTP_403_FORBIDDEN,
+            detail="User is inactive"
+        )
+
+    return user
+
+
+async def get_current_active_admin(
+    current_user: dict = Depends(get_current_user)
+) -> dict:
+    """
+    Verify current user is admin
+
+    Args:
+        current_user: Current user from token
+
+    Returns:
+        dict: Current user data
+
+    Raises:
+        HTTPException: If user is not admin
+    """
+    if current_user["role"] != UserRole.ADMIN.value and not current_user["is_superuser"]:
+        raise HTTPException(
+            status_code=status.HTTP_403_FORBIDDEN,
+            detail="Not enough permissions"
+        )
+
+    return current_user
+
+
+@router.post("/login", response_model=Token)
+async def login(
+    form_data: OAuth2PasswordRequestForm = Depends(),
+    db_manager: DatabaseManager = Depends(get_database_manager)
+):
+    """
+    Login endpoint - Returns JWT token
+
+    Args:
+        form_data: Username and password
+        db_manager: Database manager
+
+    Returns:
+        Token: Access token
+    """
+    user_service = UserService(db_manager)
+    user = user_service.authenticate_user(form_data.username, form_data.password)
+
+    if not user:
+        raise HTTPException(
+            status_code=status.HTTP_401_UNAUTHORIZED,
+            detail="Incorrect username or password",
+            headers={"WWW-Authenticate": "Bearer"},
+        )
+
+    # Create access token
+    access_token_expires = timedelta(minutes=30)
+    access_token = create_access_token(
+        data={"sub": user["username"]},
+        expires_delta=access_token_expires
+    )
+
+    return {"access_token": access_token, "token_type": "bearer"}
+
+
+@router.get("/me", response_model=UserResponse)
+async def get_me(current_user: dict = Depends(get_current_user)):
+    """
+    Get current user information
+
+    Args:
+        current_user: Current authenticated user
+
+    Returns:
+        UserResponse: Current user data
+    """
+    return current_user
+
+
+@router.post("/register", response_model=UserResponse)
+async def register(
+    user_data: UserCreate,
+    db_manager: DatabaseManager = Depends(get_database_manager),
+    current_user: dict = Depends(get_current_active_admin)
+):
+    """
+    Register a new user (admin only)
+
+    Args:
+        user_data: User creation data
+        db_manager: Database manager
+        current_user: Current admin user
+
+    Returns:
+        UserResponse: Created user
+    """
+    user_service = UserService(db_manager)
+
+    try:
+        user = user_service.create_user(
+            username=user_data.username,
+            email=user_data.email,
+            password=user_data.password,
+            full_name=user_data.full_name,
+            role=user_data.role
+        )
+        return user
+    except ValueError as e:
+        raise HTTPException(
+            status_code=status.HTTP_400_BAD_REQUEST,
+            detail=str(e)
+        )
+
+
+@router.get("/users", response_model=list[UserResponse])
+async def list_users(
+    db_manager: DatabaseManager = Depends(get_database_manager),
+    current_user: dict = Depends(get_current_active_admin)
+):
+    """
+    List all users (admin only)
+
+    Args:
+        db_manager: Database manager
+        current_user: Current admin user
+
+    Returns:
+        List[UserResponse]: List of all users
+    """
+    user_service = UserService(db_manager)
+    users = user_service.get_all_users()
+    return users
+
+
+@router.put("/users/{user_id}", response_model=UserResponse)
+async def update_user(
+    user_id: int,
+    user_data: UserUpdate,
+    db_manager: DatabaseManager = Depends(get_database_manager),
+    current_user: dict = Depends(get_current_active_admin)
+):
+    """
+    Update user (admin only)
+
+    Args:
+        user_id: User ID to update
+        user_data: Update data
+        db_manager: Database manager
+        current_user: Current admin user
+
+    Returns:
+        UserResponse: Updated user
+    """
+    user_service = UserService(db_manager)
+
+    # Prepare update dict (exclude None values)
+    updates = {k: v for k, v in user_data.dict().items() if v is not None}
+
+    user = user_service.update_user(user_id, **updates)
+
+    if not user:
+        raise HTTPException(
+            status_code=status.HTTP_404_NOT_FOUND,
+            detail="User not found"
+        )
+
+    return user
+
+
+@router.delete("/users/{user_id}")
+async def delete_user(
+    user_id: int,
+    db_manager: DatabaseManager = Depends(get_database_manager),
+    current_user: dict = Depends(get_current_active_admin)
+):
+    """
+    Delete user (admin only)
+
+    Args:
+        user_id: User ID to delete
+        db_manager: Database manager
+        current_user: Current admin user
+
+    Returns:
+        dict: Success message
+    """
+    # Prevent deleting yourself
+    if user_id == current_user["id"]:
+        raise HTTPException(
+            status_code=status.HTTP_400_BAD_REQUEST,
+            detail="Cannot delete your own account"
+        )
+
+    user_service = UserService(db_manager)
+    deleted = user_service.delete_user(user_id)
+
+    if not deleted:
+        raise HTTPException(
+            status_code=status.HTTP_404_NOT_FOUND,
+            detail="User not found"
+        )
+
+    return {"message": "User deleted successfully"}

pyarchinit_mini/api/dependencies.py

@@ -0,0 +1,63 @@
+"""
+FastAPI dependencies for PyArchInit-Mini
+"""
+
+from fastapi import Depends, HTTPException, Request
+from ..database.connection import DatabaseConnection
+from ..database.manager import DatabaseManager
+from ..services.site_service import SiteService
+from ..services.us_service import USService
+from ..services.inventario_service import InventarioService
+
+# Global database connection (will be initialized by app)
+_db_connection = None
+
+def get_database_connection() -> DatabaseConnection:
+    """Get database connection dependency"""
+    global _db_connection
+    if _db_connection is None:
+        raise HTTPException(status_code=500, detail="Database not initialized")
+    return _db_connection
+
+def get_database_manager(
+    db_conn: DatabaseConnection = Depends(get_database_connection)
+) -> DatabaseManager:
+    """Get database manager dependency"""
+    return DatabaseManager(db_conn)
+
+def get_site_service(
+    db_manager: DatabaseManager = Depends(get_database_manager)
+) -> SiteService:
+    """Get site service dependency"""
+    return SiteService(db_manager)
+
+def get_us_service(
+    db_manager: DatabaseManager = Depends(get_database_manager)
+) -> USService:
+    """Get US service dependency"""
+    return USService(db_manager)
+
+def get_inventario_service(
+    db_manager: DatabaseManager = Depends(get_database_manager)
+) -> InventarioService:
+    """Get inventario service dependency"""
+    return InventarioService(db_manager)
+
+def init_database(database_url: str):
+    """Initialize global database connection"""
+    global _db_connection
+    _db_connection = DatabaseConnection.from_url(database_url)
+    
+    # Initialize database with migrations
+    _db_connection.initialize_database()
+    
+    # Test connection
+    if not _db_connection.test_connection():
+        raise Exception("Failed to establish database connection")
+
+def close_database():
+    """Close global database connection"""
+    global _db_connection
+    if _db_connection:
+        _db_connection.close()
+        _db_connection = None

pyarchinit_mini/api/graphml.py

@@ -0,0 +1,160 @@
+"""
+GraphML Converter API endpoints
+"""
+from fastapi import APIRouter, UploadFile, File, Form, HTTPException
+from fastapi.responses import Response, FileResponse
+from typing import Optional
+import tempfile
+import os
+
+from pyarchinit_mini.graphml_converter import (
+    convert_dot_to_graphml,
+    convert_dot_content_to_graphml,
+    get_template_path
+)
+
+router = APIRouter()
+
+
+@router.post("/convert",
+             summary="Convert DOT file to GraphML",
+             description="Upload a Graphviz DOT file and convert it to yEd-compatible GraphML format")
+async def convert_dot_file(
+    file: UploadFile = File(..., description="DOT file to convert"),
+    title: str = Form("", description="Diagram title/header"),
+    reverse_epochs: bool = Form(False, description="Whether to reverse epoch ordering")
+):
+    """
+    Convert uploaded DOT file to GraphML format.
+
+    Args:
+        file: DOT file upload
+        title: Optional diagram title
+        reverse_epochs: Whether to reverse epoch ordering (default: False)
+
+    Returns:
+        GraphML file content
+
+    Example:
+        curl -X POST "http://localhost:8000/api/graphml/convert" \
+             -F "file=@harris_matrix.dot" \
+             -F "title=Pompei - Regio VI" \
+             -F "reverse_epochs=false"
+    """
+    if not file.filename.endswith('.dot'):
+        raise HTTPException(status_code=400, detail="File must have .dot extension")
+
+    try:
+        # Read uploaded file content
+        content = await file.read()
+        dot_content = content.decode('utf-8')
+
+        # Convert to GraphML
+        graphml_content = convert_dot_content_to_graphml(
+            dot_content,
+            title=title,
+            reverse_epochs=reverse_epochs
+        )
+
+        if graphml_content is None:
+            raise HTTPException(status_code=500, detail="Conversion failed")
+
+        # Return GraphML content
+        filename = file.filename.replace('.dot', '.graphml')
+        return Response(
+            content=graphml_content,
+            media_type="application/xml",
+            headers={
+                "Content-Disposition": f"attachment; filename={filename}"
+            }
+        )
+
+    except UnicodeDecodeError:
+        raise HTTPException(status_code=400, detail="File must be UTF-8 encoded text")
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Conversion error: {str(e)}")
+
+
+@router.post("/convert-content",
+             summary="Convert DOT content to GraphML",
+             description="Convert DOT content string to GraphML format")
+async def convert_dot_content(
+    dot_content: str = Form(..., description="DOT file content as string"),
+    title: str = Form("", description="Diagram title/header"),
+    reverse_epochs: bool = Form(False, description="Whether to reverse epoch ordering")
+):
+    """
+    Convert DOT content string to GraphML format.
+
+    Args:
+        dot_content: DOT file content as string
+        title: Optional diagram title
+        reverse_epochs: Whether to reverse epoch ordering (default: False)
+
+    Returns:
+        GraphML content as string
+
+    Example:
+        curl -X POST "http://localhost:8000/api/graphml/convert-content" \
+             -F "dot_content=digraph { \"US 100\" -> \"US 101\"; }" \
+             -F "title=Test Site"
+    """
+    try:
+        graphml_content = convert_dot_content_to_graphml(
+            dot_content,
+            title=title,
+            reverse_epochs=reverse_epochs
+        )
+
+        if graphml_content is None:
+            raise HTTPException(status_code=500, detail="Conversion failed")
+
+        return Response(
+            content=graphml_content,
+            media_type="application/xml"
+        )
+
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Conversion error: {str(e)}")
+
+
+@router.get("/template",
+            summary="Download yEd GraphML template",
+            description="Download the EM_palette.graphml template used for Harris Matrix diagrams")
+async def download_template():
+    """
+    Download the yEd GraphML template file.
+
+    Returns:
+        EM_palette.graphml template file
+
+    Example:
+        curl -X GET "http://localhost:8000/api/graphml/template" -o EM_palette.graphml
+    """
+    template_path = get_template_path()
+
+    if not os.path.exists(template_path):
+        raise HTTPException(status_code=404, detail="Template file not found")
+
+    return FileResponse(
+        path=template_path,
+        media_type="application/xml",
+        filename="EM_palette.graphml"
+    )
+
+
+@router.get("/health",
+            summary="Health check",
+            description="Check if the GraphML converter service is running")
+async def health_check():
+    """
+    Health check endpoint.
+
+    Returns:
+        Service status
+    """
+    return {
+        "status": "ok",
+        "service": "graphml-converter",
+        "version": "1.0.0"
+    }