pyarchinit-mini 1.9.28__py3-none-any.whl

pyarchinit_mini/api/inventario.py

@@ -0,0 +1,107 @@
+"""
+Inventario Materiali API endpoints
+"""
+
+from typing import List, Optional
+from fastapi import APIRouter, Depends, HTTPException, Query
+
+from .schemas import InventarioCreate, InventarioUpdate, InventarioResponse, PaginatedResponse
+from .dependencies import get_inventario_service
+from ..services.inventario_service import InventarioService
+from ..utils.exceptions import ValidationError, RecordNotFoundError
+
+router = APIRouter()
+
+@router.get("/", response_model=PaginatedResponse)
+async def get_inventario_list(
+    page: int = Query(1, ge=1),
+    size: int = Query(10, ge=1, le=100),
+    sito: Optional[str] = Query(None, description="Filter by site"),
+    tipo_reperto: Optional[str] = Query(None, description="Filter by find type"),
+    inventario_service: InventarioService = Depends(get_inventario_service)
+):
+    """Get paginated list of inventory items"""
+    try:
+        filters = {}
+        if sito:
+            filters['sito'] = sito
+        if tipo_reperto:
+            filters['tipo_reperto'] = tipo_reperto
+        
+        items = inventario_service.get_all_inventario(page=page, size=size, filters=filters)
+        total = inventario_service.count_inventario(filters=filters)
+        
+        return PaginatedResponse(
+            items=[InventarioResponse.from_orm(item) for item in items],
+            total=total,
+            page=page,
+            size=size,
+            pages=(total + size - 1) // size
+        )
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+@router.get("/{item_id}", response_model=InventarioResponse)
+async def get_inventario_item(
+    item_id: int,
+    inventario_service: InventarioService = Depends(get_inventario_service)
+):
+    """Get inventory item by ID"""
+    try:
+        item = inventario_service.get_inventario_by_id(item_id)
+        if not item:
+            raise HTTPException(status_code=404, detail="Inventory item not found")
+        return InventarioResponse.from_orm(item)
+    except RecordNotFoundError:
+        raise HTTPException(status_code=404, detail="Inventory item not found")
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+@router.post("/", response_model=InventarioResponse, status_code=201)
+async def create_inventario_item(
+    item_data: InventarioCreate,
+    inventario_service: InventarioService = Depends(get_inventario_service)
+):
+    """Create a new inventory item"""
+    try:
+        item = inventario_service.create_inventario(item_data.dict())
+        return InventarioResponse.from_orm(item)
+    except ValidationError as e:
+        raise HTTPException(status_code=400, detail=str(e))
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+@router.put("/{item_id}", response_model=InventarioResponse)
+async def update_inventario_item(
+    item_id: int,
+    item_data: InventarioUpdate,
+    inventario_service: InventarioService = Depends(get_inventario_service)
+):
+    """Update an existing inventory item"""
+    try:
+        update_data = {k: v for k, v in item_data.dict().items() if v is not None}
+        item = inventario_service.update_inventario(item_id, update_data)
+        return InventarioResponse.from_orm(item)
+    except RecordNotFoundError:
+        raise HTTPException(status_code=404, detail="Inventory item not found")
+    except ValidationError as e:
+        raise HTTPException(status_code=400, detail=str(e))
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+@router.delete("/{item_id}")
+async def delete_inventario_item(
+    item_id: int,
+    inventario_service: InventarioService = Depends(get_inventario_service)
+):
+    """Delete an inventory item"""
+    try:
+        success = inventario_service.delete_inventario(item_id)
+        if success:
+            return {"message": "Inventory item deleted successfully"}
+        else:
+            raise HTTPException(status_code=404, detail="Inventory item not found")
+    except RecordNotFoundError:
+        raise HTTPException(status_code=404, detail="Inventory item not found")
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))

pyarchinit_mini/api/schemas.py

@@ -0,0 +1,186 @@
+"""
+Pydantic schemas for API request/response validation
+"""
+
+from datetime import datetime
+from typing import Optional, List
+from pydantic import BaseModel, Field, validator
+
+# Base schemas
+
+class BaseSchema(BaseModel):
+    """Base schema with common fields"""
+    created_at: Optional[datetime] = None
+    updated_at: Optional[datetime] = None
+    
+    class Config:
+        from_attributes = True
+
+# Site schemas
+
+class SiteBase(BaseModel):
+    """Base site schema"""
+    sito: str = Field(..., min_length=1, max_length=350, description="Site name")
+    nazione: Optional[str] = Field(None, max_length=250, description="Country")
+    regione: Optional[str] = Field(None, max_length=250, description="Region")
+    comune: Optional[str] = Field(None, max_length=250, description="Municipality")
+    provincia: Optional[str] = Field(None, max_length=10, description="Province")
+    definizione_sito: Optional[str] = Field(None, max_length=250, description="Site definition")
+    descrizione: Optional[str] = Field(None, description="Description")
+    sito_path: Optional[str] = Field(None, max_length=500, description="Site path")
+    find_check: Optional[bool] = Field(False, description="Find check flag")
+
+class SiteCreate(SiteBase):
+    """Schema for creating a site"""
+    pass
+
+class SiteUpdate(BaseModel):
+    """Schema for updating a site"""
+    sito: Optional[str] = Field(None, min_length=1, max_length=350)
+    nazione: Optional[str] = Field(None, max_length=250)
+    regione: Optional[str] = Field(None, max_length=250)
+    comune: Optional[str] = Field(None, max_length=250)
+    provincia: Optional[str] = Field(None, max_length=10)
+    definizione_sito: Optional[str] = Field(None, max_length=250)
+    descrizione: Optional[str] = None
+    sito_path: Optional[str] = Field(None, max_length=500)
+    find_check: Optional[bool] = None
+
+class SiteResponse(SiteBase, BaseSchema):
+    """Schema for site response"""
+    id_sito: int = Field(..., description="Site ID")
+
+# US (Stratigraphic Unit) schemas
+
+class USBase(BaseModel):
+    """Base US schema"""
+    sito: str = Field(..., max_length=350, description="Site name")
+    area: Optional[str] = Field(None, max_length=20, description="Area")
+    us: int = Field(..., gt=0, description="US number")
+    d_stratigrafica: Optional[str] = Field(None, max_length=350, description="Stratigraphic description")
+    d_interpretativa: Optional[str] = Field(None, max_length=350, description="Interpretative description")
+    descrizione: Optional[str] = Field(None, description="Description")
+    interpretazione: Optional[str] = Field(None, description="Interpretation")
+    periodo_iniziale: Optional[str] = Field(None, max_length=300, description="Initial period")
+    fase_iniziale: Optional[str] = Field(None, max_length=300, description="Initial phase")
+    periodo_finale: Optional[str] = Field(None, max_length=300, description="Final period")
+    fase_finale: Optional[str] = Field(None, max_length=300, description="Final phase")
+    scavato: Optional[str] = Field(None, max_length=20, description="Excavated")
+    attivita: Optional[str] = Field(None, max_length=30, description="Activity")
+    anno_scavo: Optional[int] = Field(None, ge=1800, le=2100, description="Excavation year")
+    metodo_di_scavo: Optional[str] = Field(None, max_length=20, description="Excavation method")
+    schedatore: Optional[str] = Field(None, max_length=100, description="Recorder")
+    formazione: Optional[str] = Field(None, max_length=20, description="Formation")
+    stato_di_conservazione: Optional[str] = Field(None, max_length=20, description="Conservation state")
+    colore: Optional[str] = Field(None, max_length=20, description="Color")
+    consistenza: Optional[str] = Field(None, max_length=20, description="Consistency")
+    struttura: Optional[str] = Field(None, max_length=30, description="Structure")
+    
+    # Measurements
+    quota_relativa: Optional[float] = Field(None, ge=0, description="Relative elevation")
+    quota_abs: Optional[float] = Field(None, ge=0, description="Absolute elevation")
+    lunghezza_max: Optional[float] = Field(None, ge=0, description="Maximum length")
+    altezza_max: Optional[float] = Field(None, ge=0, description="Maximum height")
+    altezza_min: Optional[float] = Field(None, ge=0, description="Minimum height")
+    profondita_max: Optional[float] = Field(None, ge=0, description="Maximum depth")
+    profondita_min: Optional[float] = Field(None, ge=0, description="Minimum depth")
+    larghezza_media: Optional[float] = Field(None, ge=0, description="Average width")
+    
+    # Additional fields
+    osservazioni: Optional[str] = Field(None, description="Observations")
+    datazione: Optional[str] = Field(None, max_length=100, description="Dating")
+    direttore_us: Optional[str] = Field(None, max_length=100, description="US director")
+    responsabile_us: Optional[str] = Field(None, max_length=100, description="US responsible")
+
+class USCreate(USBase):
+    """Schema for creating a US"""
+    pass
+
+class USUpdate(BaseModel):
+    """Schema for updating a US"""
+    sito: Optional[str] = Field(None, max_length=350)
+    area: Optional[str] = Field(None, max_length=20)
+    us: Optional[int] = Field(None, gt=0)
+    d_stratigrafica: Optional[str] = Field(None, max_length=350)
+    d_interpretativa: Optional[str] = Field(None, max_length=350)
+    descrizione: Optional[str] = None
+    interpretazione: Optional[str] = None
+    anno_scavo: Optional[int] = Field(None, ge=1800, le=2100)
+    schedatore: Optional[str] = Field(None, max_length=100)
+    # ... other optional fields
+
+class USResponse(USBase, BaseSchema):
+    """Schema for US response"""
+    id_us: int = Field(..., description="US ID")
+
+# Inventario Materiali schemas
+
+class InventarioBase(BaseModel):
+    """Base inventory schema"""
+    sito: str = Field(..., max_length=350, description="Site name")
+    numero_inventario: int = Field(..., gt=0, description="Inventory number")
+    tipo_reperto: Optional[str] = Field(None, max_length=20, description="Find type")
+    criterio_schedatura: Optional[str] = Field(None, max_length=20, description="Recording criteria")
+    definizione: Optional[str] = Field(None, max_length=20, description="Definition")
+    descrizione: Optional[str] = Field(None, description="Description")
+    area: Optional[str] = Field(None, max_length=20, description="Area")
+    us: Optional[int] = Field(None, gt=0, description="US number")
+    lavato: Optional[str] = Field(None, max_length=5, description="Washed")
+    nr_cassa: Optional[str] = Field(None, max_length=20, description="Box number")
+    luogo_conservazione: Optional[str] = Field(None, max_length=350, description="Conservation location")
+    stato_conservazione: Optional[str] = Field(None, max_length=200, description="Conservation state")
+    datazione_reperto: Optional[str] = Field(None, max_length=100, description="Find dating")
+    
+    # Technical characteristics
+    forme_minime: Optional[int] = Field(None, ge=0, description="Minimum forms")
+    forme_massime: Optional[int] = Field(None, ge=0, description="Maximum forms") 
+    totale_frammenti: Optional[int] = Field(None, ge=0, description="Total fragments")
+    peso: Optional[float] = Field(None, ge=0, description="Weight")
+    diametro_orlo: Optional[float] = Field(None, ge=0, description="Rim diameter")
+    eve_orlo: Optional[float] = Field(None, ge=0, le=100, description="Rim EVE")
+    
+    # Classification
+    corpo_ceramico: Optional[str] = Field(None, max_length=20, description="Ceramic body")
+    rivestimento: Optional[str] = Field(None, max_length=20, description="Surface treatment")
+    tipo: Optional[str] = Field(None, max_length=300, description="Type")
+    repertato: Optional[str] = Field(None, max_length=2, description="Catalogued")
+    diagnostico: Optional[str] = Field(None, max_length=2, description="Diagnostic")
+
+    @validator('lavato', 'repertato', 'diagnostico')
+    def validate_yes_no_fields(cls, v):
+        if v is not None and v.upper() not in ['SI', 'NO', 'S', 'N']:
+            raise ValueError('Must be SI/NO or S/N')
+        return v
+
+class InventarioCreate(InventarioBase):
+    """Schema for creating inventory item"""
+    pass
+
+class InventarioUpdate(BaseModel):
+    """Schema for updating inventory item"""
+    sito: Optional[str] = Field(None, max_length=350)
+    numero_inventario: Optional[int] = Field(None, gt=0)
+    tipo_reperto: Optional[str] = Field(None, max_length=20)
+    # ... other optional fields
+
+class InventarioResponse(InventarioBase, BaseSchema):
+    """Schema for inventory response"""
+    id_invmat: int = Field(..., description="Inventory ID")
+
+# Pagination schemas
+
+class PaginationParams(BaseModel):
+    """Pagination parameters"""
+    page: int = Field(1, ge=1, description="Page number")
+    size: int = Field(10, ge=1, le=100, description="Page size")
+
+class PaginatedResponse(BaseModel):
+    """Paginated response wrapper"""
+    items: List[BaseModel]
+    total: int = Field(..., description="Total number of items")
+    page: int = Field(..., description="Current page")
+    size: int = Field(..., description="Page size")
+    pages: int = Field(..., description="Total number of pages")
+    
+    class Config:
+        from_attributes = True

pyarchinit_mini/api/site.py

@@ -0,0 +1,220 @@
+"""
+Site API endpoints
+"""
+
+from typing import List, Optional
+from fastapi import APIRouter, Depends, HTTPException, Query
+from fastapi.responses import JSONResponse
+
+from .schemas import SiteCreate, SiteUpdate, SiteResponse, PaginatedResponse
+from .dependencies import get_site_service
+from ..services.site_service import SiteService
+from ..utils.exceptions import ValidationError, RecordNotFoundError, DuplicateRecordError
+
+router = APIRouter()
+
+@router.get("/", response_model=PaginatedResponse)
+async def get_sites(
+    page: int = Query(1, ge=1, description="Page number"),
+    size: int = Query(10, ge=1, le=100, description="Page size"),
+    search: Optional[str] = Query(None, description="Search term"),
+    nazione: Optional[str] = Query(None, description="Filter by country"),
+    regione: Optional[str] = Query(None, description="Filter by region"),
+    comune: Optional[str] = Query(None, description="Filter by municipality"),
+    site_service: SiteService = Depends(get_site_service)
+):
+    """
+    Get paginated list of sites with optional filtering and search
+    """
+    try:
+        # Build filters
+        filters = {}
+        if nazione:
+            filters['nazione'] = nazione
+        if regione:
+            filters['regione'] = regione
+        if comune:
+            filters['comune'] = comune
+        
+        # Get sites
+        if search:
+            sites = site_service.search_sites(search, page=page, size=size, filters=filters)
+        else:
+            sites = site_service.get_all_sites(page=page, size=size, filters=filters)
+        
+        # Get total count for pagination
+        total = site_service.count_sites(filters=filters)
+        
+        return PaginatedResponse(
+            items=[SiteResponse.from_orm(site) for site in sites],
+            total=total,
+            page=page,
+            size=size,
+            pages=(total + size - 1) // size
+        )
+    
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+@router.get("/{site_id}", response_model=SiteResponse)
+async def get_site(
+    site_id: int,
+    site_service: SiteService = Depends(get_site_service)
+):
+    """
+    Get site by ID
+    """
+    try:
+        site = site_service.get_site_by_id(site_id)
+        if not site:
+            raise HTTPException(status_code=404, detail="Site not found")
+        return SiteResponse.from_orm(site)
+    
+    except RecordNotFoundError:
+        raise HTTPException(status_code=404, detail="Site not found")
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+@router.get("/by-name/{site_name}", response_model=SiteResponse)
+async def get_site_by_name(
+    site_name: str,
+    site_service: SiteService = Depends(get_site_service)
+):
+    """
+    Get site by name
+    """
+    try:
+        site = site_service.get_site_by_name(site_name)
+        if not site:
+            raise HTTPException(status_code=404, detail="Site not found")
+        return SiteResponse.from_orm(site)
+    
+    except RecordNotFoundError:
+        raise HTTPException(status_code=404, detail="Site not found")
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+@router.post("/", response_model=SiteResponse, status_code=201)
+async def create_site(
+    site_data: SiteCreate,
+    site_service: SiteService = Depends(get_site_service)
+):
+    """
+    Create a new site
+    """
+    try:
+        site = site_service.create_site(site_data.dict())
+        return SiteResponse.from_orm(site)
+    
+    except ValidationError as e:
+        raise HTTPException(status_code=400, detail=str(e))
+    except DuplicateRecordError as e:
+        raise HTTPException(status_code=409, detail=str(e))
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+@router.put("/{site_id}", response_model=SiteResponse)
+async def update_site(
+    site_id: int,
+    site_data: SiteUpdate,
+    site_service: SiteService = Depends(get_site_service)
+):
+    """
+    Update an existing site
+    """
+    try:
+        # Only include non-None values in update
+        update_data = {k: v for k, v in site_data.dict().items() if v is not None}
+        site = site_service.update_site(site_id, update_data)
+        return SiteResponse.from_orm(site)
+    
+    except RecordNotFoundError:
+        raise HTTPException(status_code=404, detail="Site not found")
+    except ValidationError as e:
+        raise HTTPException(status_code=400, detail=str(e))
+    except DuplicateRecordError as e:
+        raise HTTPException(status_code=409, detail=str(e))
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+@router.delete("/{site_id}")
+async def delete_site(
+    site_id: int,
+    site_service: SiteService = Depends(get_site_service)
+):
+    """
+    Delete a site
+    """
+    try:
+        success = site_service.delete_site(site_id)
+        if success:
+            return JSONResponse(
+                status_code=200,
+                content={"message": "Site deleted successfully"}
+            )
+        else:
+            raise HTTPException(status_code=404, detail="Site not found")
+    
+    except RecordNotFoundError:
+        raise HTTPException(status_code=404, detail="Site not found")
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+@router.get("/{site_id}/stats")
+async def get_site_stats(
+    site_id: int,
+    site_service: SiteService = Depends(get_site_service)
+):
+    """
+    Get statistics for a site (US count, inventory count, etc.)
+    """
+    try:
+        stats = site_service.get_site_statistics(site_id)
+        return stats
+    
+    except RecordNotFoundError:
+        raise HTTPException(status_code=404, detail="Site not found")
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+@router.get("/locations/countries")
+async def get_countries(
+    site_service: SiteService = Depends(get_site_service)
+):
+    """
+    Get list of unique countries from sites
+    """
+    try:
+        countries = site_service.get_unique_countries()
+        return {"countries": countries}
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+@router.get("/locations/regions")
+async def get_regions(
+    nazione: Optional[str] = Query(None, description="Filter by country"),
+    site_service: SiteService = Depends(get_site_service)
+):
+    """
+    Get list of unique regions, optionally filtered by country
+    """
+    try:
+        regions = site_service.get_unique_regions(nazione)
+        return {"regions": regions}
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+@router.get("/locations/municipalities")
+async def get_municipalities(
+    nazione: Optional[str] = Query(None, description="Filter by country"),
+    regione: Optional[str] = Query(None, description="Filter by region"),
+    site_service: SiteService = Depends(get_site_service)
+):
+    """
+    Get list of unique municipalities, optionally filtered by country and region
+    """
+    try:
+        municipalities = site_service.get_unique_municipalities(nazione, regione)
+        return {"municipalities": municipalities}
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))

pyarchinit_mini/api/us.py

@@ -0,0 +1,107 @@
+"""
+US (Stratigraphic Unit) API endpoints
+"""
+
+from typing import List, Optional
+from fastapi import APIRouter, Depends, HTTPException, Query
+
+from .schemas import USCreate, USUpdate, USResponse, PaginatedResponse
+from .dependencies import get_us_service
+from ..services.us_service import USService
+from ..utils.exceptions import ValidationError, RecordNotFoundError
+
+router = APIRouter()
+
+@router.get("/", response_model=PaginatedResponse)
+async def get_us_list(
+    page: int = Query(1, ge=1),
+    size: int = Query(10, ge=1, le=100),
+    sito: Optional[str] = Query(None, description="Filter by site"),
+    area: Optional[str] = Query(None, description="Filter by area"),
+    us_service: USService = Depends(get_us_service)
+):
+    """Get paginated list of stratigraphic units"""
+    try:
+        filters = {}
+        if sito:
+            filters['sito'] = sito
+        if area:
+            filters['area'] = area
+        
+        us_list = us_service.get_all_us(page=page, size=size, filters=filters)
+        total = us_service.count_us(filters=filters)
+        
+        return PaginatedResponse(
+            items=[USResponse.from_orm(us) for us in us_list],
+            total=total,
+            page=page,
+            size=size,
+            pages=(total + size - 1) // size
+        )
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+@router.get("/{us_id}", response_model=USResponse)
+async def get_us(
+    us_id: int,
+    us_service: USService = Depends(get_us_service)
+):
+    """Get US by ID"""
+    try:
+        us = us_service.get_us_by_id(us_id)
+        if not us:
+            raise HTTPException(status_code=404, detail="US not found")
+        return USResponse.from_orm(us)
+    except RecordNotFoundError:
+        raise HTTPException(status_code=404, detail="US not found")
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+@router.post("/", response_model=USResponse, status_code=201)
+async def create_us(
+    us_data: USCreate,
+    us_service: USService = Depends(get_us_service)
+):
+    """Create a new stratigraphic unit"""
+    try:
+        us = us_service.create_us(us_data.dict())
+        return USResponse.from_orm(us)
+    except ValidationError as e:
+        raise HTTPException(status_code=400, detail=str(e))
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+@router.put("/{us_id}", response_model=USResponse)
+async def update_us(
+    us_id: int,
+    us_data: USUpdate,
+    us_service: USService = Depends(get_us_service)
+):
+    """Update an existing stratigraphic unit"""
+    try:
+        update_data = {k: v for k, v in us_data.dict().items() if v is not None}
+        us = us_service.update_us(us_id, update_data)
+        return USResponse.from_orm(us)
+    except RecordNotFoundError:
+        raise HTTPException(status_code=404, detail="US not found")
+    except ValidationError as e:
+        raise HTTPException(status_code=400, detail=str(e))
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+@router.delete("/{us_id}")
+async def delete_us(
+    us_id: int,
+    us_service: USService = Depends(get_us_service)
+):
+    """Delete a stratigraphic unit"""
+    try:
+        success = us_service.delete_us(us_id)
+        if success:
+            return {"message": "US deleted successfully"}
+        else:
+            raise HTTPException(status_code=404, detail="US not found")
+    except RecordNotFoundError:
+        raise HTTPException(status_code=404, detail="US not found")
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))

pyarchinit_mini/cli/__init__.py

@@ -0,0 +1,7 @@
+"""
+CLI commands for PyArchInit-Mini
+"""
+
+from .export_import_cli import export_import
+
+__all__ = ['export_import']