added backend logic for upload and metadata module

backend/app/api/__init__.py

@@ -0,0 +1 @@
+# Placeholder

backend/app/api/animation.py

@@ -0,0 +1,14 @@
+from fastapi import APIRouter
+from app.schemas.common import ApiResponse
+from app.schemas.animation import AnimationSequenceResponse
+
+router = APIRouter()
+
+@router.get("/{file_id}/sequence", response_model=ApiResponse)
+async def get_sequence(file_id: str, start_time: str = "", end_time: str = "", fps: int = 10):
+    # Placeholder
+    return ApiResponse(
+        success=True,
+        message="Animation sequence retrieved",
+        data=None
+    )

backend/app/api/export.py

@@ -0,0 +1,24 @@
+from fastapi import APIRouter
+from app.schemas.common import ApiResponse
+from app.schemas.export import ExportRequest, ExportJobStatusResponse
+from app.schemas.interpolation import JobResponse
+
+router = APIRouter()
+
+@router.post("/job", response_model=ApiResponse)
+async def create_export_job(request: ExportRequest):
+    # Placeholder
+    return ApiResponse(
+        success=True,
+        message="Export job queued",
+        data=JobResponse(job_id="dummy-export-job", status="preparing")
+    )
+
+@router.get("/status/{job_id}", response_model=ApiResponse)
+async def get_export_status(job_id: str):
+    # Placeholder
+    return ApiResponse(
+        success=True,
+        message="Export status retrieved",
+        data=ExportJobStatusResponse(status="processing", progress=10.0)
+    )

backend/app/api/health.py

@@ -0,0 +1,16 @@
+from fastapi import APIRouter
+from app.schemas.common import ApiResponse
+
+router = APIRouter()
+
+@router.get("/")
+async def health_check():
+    return ApiResponse(success=True, message="API is healthy", data=None)
+
+@router.get("/gpu")
+async def health_gpu():
+    return ApiResponse(success=True, message="GPU status", data={"cuda_available": False})
+
+@router.get("/models")
+async def health_models():
+    return ApiResponse(success=True, message="Models status", data={"rife": "not_loaded"})

backend/app/api/interpolation.py

@@ -0,0 +1,28 @@
+from fastapi import APIRouter
+from app.schemas.common import ApiResponse
+from app.schemas.interpolation import InterpolationRequest, JobResponse, JobStatusResponse
+
+router = APIRouter()
+
+@router.post("/generate", response_model=ApiResponse)
+async def generate_interpolation(request: InterpolationRequest):
+    # Placeholder
+    return ApiResponse(
+        success=True, 
+        message="Job queued", 
+        data=JobResponse(job_id="dummy-job", status="queued")
+    )
+
+@router.get("/status/{job_id}", response_model=ApiResponse)
+async def get_status(job_id: str):
+    # Placeholder
+    return ApiResponse(
+        success=True,
+        message="Status retrieved",
+        data=JobStatusResponse(status="processing", progress=50.0)
+    )
+
+@router.get("/events/{job_id}")
+async def get_events(job_id: str):
+    # Placeholder for SSE
+    return {"message": "SSE endpoint placeholder"}

backend/app/api/metadata.py

@@ -0,0 +1,34 @@
+from fastapi import APIRouter, HTTPException
+from app.schemas.common import ApiResponse
+from app.services.scientific.metadata_service import MetadataService
+import os
+
+router = APIRouter()
+
+# Note: Depending on where uploads are stored, we assume a storage path.
+# Assuming standard backend/storage/uploads based on previous contexts.
+STORAGE_DIR = os.path.join(os.getcwd(), "storage", "uploads")
+
+@router.get("/{file_id}", response_model=ApiResponse)
+async def get_metadata(file_id: str):
+    # Search for the file in the storage directory
+    file_path = None
+    for ext in [".nc", ".h5", ".hdf5"]:
+        possible_path = os.path.join(STORAGE_DIR, f"{file_id}{ext}")
+        if os.path.exists(possible_path):
+            file_path = possible_path
+            break
+            
+    if not file_path:
+        raise HTTPException(status_code=404, detail="File not found")
+        
+    try:
+        metadata_response = MetadataService.extract_metadata(file_id, file_path)
+        return ApiResponse(
+            success=True,
+            message="Metadata retrieved successfully",
+            data=metadata_response
+        )
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Failed to extract metadata: {str(e)}")
+

backend/app/api/metrics.py

@@ -0,0 +1,14 @@
+from fastapi import APIRouter
+from app.schemas.common import ApiResponse
+from app.schemas.metrics import MetricsRequest, MetricsResponse
+
+router = APIRouter()
+
+@router.post("/compare", response_model=ApiResponse)
+async def compare_frames(request: MetricsRequest):
+    # Placeholder
+    return ApiResponse(
+        success=True,
+        message="Metrics computed",
+        data=None
+    )

backend/app/api/upload.py

@@ -0,0 +1,10 @@
+from fastapi import APIRouter, UploadFile, File
+from app.schemas.upload import UploadResponse
+from app.services.upload_service import UploadService
+
+router = APIRouter()
+
+@router.post("", response_model=UploadResponse)
+async def upload_file(file: UploadFile = File(...)):
+    result = await UploadService.process_upload(file)
+    return result

backend/app/api/visualization.py

@@ -0,0 +1,22 @@
+from fastapi import APIRouter
+from app.schemas.common import ApiResponse
+
+router = APIRouter()
+
+@router.get("/{file_id}/frame", response_model=ApiResponse)
+async def get_frame(file_id: str, time_index: int = 0, variable: str = ""):
+    # Placeholder
+    return ApiResponse(
+        success=True, 
+        message="Frame retrieved", 
+        data=None
+    )
+
+@router.get("/{file_id}/thumbnail", response_model=ApiResponse)
+async def get_thumbnail(file_id: str):
+    # Placeholder
+    return ApiResponse(
+        success=True,
+        message="Thumbnail retrieved",
+        data={"url": "dummy_url"}
+    )

backend/app/core/__init__.py

@@ -0,0 +1 @@
+# Placeholder

backend/app/core/config.py

@@ -0,0 +1 @@
+# Placeholder

backend/app/core/exceptions.py

@@ -0,0 +1 @@
+# Placeholder

backend/app/jobs/__init__.py

@@ -0,0 +1 @@
+# Placeholder

backend/app/jobs/cleanup_job.py

@@ -0,0 +1 @@
+# Placeholder

backend/app/jobs/export_job.py

@@ -0,0 +1 @@
+# Placeholder

backend/app/jobs/interpolation_job.py

@@ -0,0 +1 @@
+# Placeholder

backend/app/main.py

@@ -0,0 +1,32 @@
+from fastapi import FastAPI
+from fastapi.middleware.cors import CORSMiddleware
+from .api import upload, metadata, visualization, interpolation, metrics, animation, export, health
+
+app = FastAPI(
+    title="Fill the Frames API",
+    description="Scientific backend for satellite frame interpolation and visualization",
+    version="0.1.0"
+)
+
+# CORS configuration
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"], # Update for production
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+# Register routers
+app.include_router(health.router, tags=["Health"])
+app.include_router(upload.router, prefix="/api/v1/upload", tags=["Upload"])
+app.include_router(metadata.router, prefix="/api/v1/metadata", tags=["Metadata"])
+app.include_router(visualization.router, prefix="/api/v1/visualization", tags=["Visualization"])
+app.include_router(interpolation.router, prefix="/api/v1/interpolation", tags=["Interpolation"])
+app.include_router(metrics.router, prefix="/api/v1/metrics", tags=["Metrics"])
+app.include_router(animation.router, prefix="/api/v1/animation", tags=["Animation"])
+app.include_router(export.router, prefix="/api/v1/export", tags=["Export"])
+
+@app.get("/")
+def read_root():
+    return {"message": "Welcome to Fill the Frames API"}

backend/app/schemas/__init__.py

@@ -0,0 +1 @@
+# Placeholder

backend/app/schemas/animation.py

@@ -0,0 +1,7 @@
+from pydantic import BaseModel
+from typing import List
+from .visualization import FrameDataResponse
+
+class AnimationSequenceResponse(BaseModel):
+    frames: List[FrameDataResponse]
+    total_frames: int

backend/app/schemas/common.py

@@ -0,0 +1,18 @@
+from pydantic import BaseModel
+from typing import Any
+from datetime import datetime
+
+class ApiResponse(BaseModel):
+    success: bool
+    message: str
+    data: Any
+
+class FrameData(BaseModel):
+    frame_id: str
+    timestamp: datetime
+    variable: str
+    width: int
+    height: int
+    min_value: float
+    max_value: float
+    source: str

backend/app/schemas/export.py

@@ -0,0 +1,15 @@
+from pydantic import BaseModel
+from typing import Optional
+
+class ExportRequest(BaseModel):
+    target_id: str
+    format: str
+    resolution: str
+    include_metadata: bool
+    include_metrics: bool
+    include_animation: bool = False
+
+class ExportJobStatusResponse(BaseModel):
+    status: str
+    progress: float
+    download_url: Optional[str] = None

backend/app/schemas/interpolation.py

@@ -0,0 +1,17 @@
+from pydantic import BaseModel
+from typing import Optional
+from .visualization import FrameDataResponse
+
+class InterpolationRequest(BaseModel):
+    file_id: str
+    time_ratio: float
+    model: str
+
+class JobResponse(BaseModel):
+    job_id: str
+    status: str
+
+class JobStatusResponse(BaseModel):
+    status: str
+    progress: float
+    result_frame: Optional[FrameDataResponse] = None

backend/app/schemas/metadata.py

@@ -0,0 +1,44 @@
+from pydantic import BaseModel
+from typing import List, Dict, Any, Optional
+
+class DimensionInfo(BaseModel):
+    name: str
+    size: int
+
+class VariableInfo(BaseModel):
+    name: str
+    datatype: str
+    dimensions: List[str]
+    shape: List[int]
+    attributes: Dict[str, Any]
+    min_value: Optional[float] = None
+    max_value: Optional[float] = None
+
+class CoordinateInfo(BaseModel):
+    latitude: Optional[str] = None
+    longitude: Optional[str] = None
+    projection: Optional[str] = None
+
+class TemporalInfo(BaseModel):
+    start_time: Optional[str] = None
+    end_time: Optional[str] = None
+    time_steps: Optional[int] = None
+
+class DatasetSummary(BaseModel):
+    file_format: str
+    variable_count: int
+    dimension_count: int
+    coordinate_count: int
+    dataset_size: int
+
+class MetadataResponse(BaseModel):
+    file_id: str
+    filename: str
+    size: int
+    format: str
+    global_attributes: Dict[str, Any]
+    dimensions: List[DimensionInfo]
+    variables: List[VariableInfo]
+    coordinates: CoordinateInfo
+    temporal_info: TemporalInfo
+    summary: DatasetSummary

backend/app/schemas/metrics.py

@@ -0,0 +1,12 @@
+from pydantic import BaseModel
+from typing import List, Dict
+from .visualization import FrameDataResponse
+
+class MetricsRequest(BaseModel):
+    frame_a_id: str
+    frame_b_id: str
+    metrics: List[str]
+
+class MetricsResponse(BaseModel):
+    scores: Dict[str, float]
+    difference_map: FrameDataResponse

backend/app/schemas/upload.py

@@ -0,0 +1,10 @@
+from pydantic import BaseModel, Field
+
+class UploadResponse(BaseModel):
+    success: bool = True
+    fileId: str = Field(..., alias="fileId")
+    filename: str
+    status: str
+
+    class Config:
+        populate_by_name = True

backend/app/schemas/visualization.py

@@ -0,0 +1,7 @@
+from pydantic import BaseModel
+from typing import List
+from .common import FrameData
+
+class FrameDataResponse(BaseModel):
+    frame_metadata: FrameData
+    z: List[List[float]]

backend/app/services/__init__.py

@@ -0,0 +1 @@
+# Placeholder

backend/app/services/inference/__init__.py

@@ -0,0 +1 @@
+# Placeholder

backend/app/services/inference/model_loader.py

@@ -0,0 +1 @@
+# Placeholder

backend/app/services/inference/onnx_runtime.py

@@ -0,0 +1 @@
+# Placeholder

backend/app/services/inference/rife.py

@@ -0,0 +1 @@
+# Placeholder

backend/app/services/scientific/__init__.py

@@ -0,0 +1 @@
+# Placeholder

backend/app/services/scientific/base_parser.py

@@ -0,0 +1,11 @@
+from abc import ABC, abstractmethod
+from typing import Dict, Any
+
+class BaseDatasetParser(ABC):
+    @abstractmethod
+    def load_dataset(self, file_path: str):
+        pass
+        
+    @abstractmethod
+    def extract_metadata(self) -> Dict[str, Any]:
+        pass

backend/app/services/scientific/hdf_parser.py

@@ -0,0 +1,156 @@
+import h5py
+import numpy as np
+from typing import Dict, Any, List
+from .base_parser import BaseDatasetParser
+
+class HDFParser(BaseDatasetParser):
+    def __init__(self):
+        self.file = None
+
+    def load_dataset(self, file_path: str):
+        self.file = h5py.File(file_path, "r")
+
+    def _convert_type(self, val):
+        if isinstance(val, (np.integer, int)):
+            return int(val)
+        if isinstance(val, (np.floating, float)):
+            return float(val)
+        if isinstance(val, np.ndarray):
+            if val.size == 1:
+                return self._convert_type(val.item())
+            return [self._convert_type(v) for v in val.tolist()]
+        if isinstance(val, bytes):
+            try:
+                return val.decode('utf-8')
+            except Exception:
+                return str(val)
+        return str(val)
+
+    def extract_metadata(self) -> Dict[str, Any]:
+        if self.file is None:
+            raise ValueError("Dataset not loaded")
+
+        # Global Attributes
+        global_attributes = {k: self._convert_type(v) for k, v in self.file.attrs.items()}
+
+        variables = []
+        dimensions_map = {}
+        coordinate_names = []
+        
+        # Helper to traverse HDF5 recursively
+        def visit_func(name, node):
+            if isinstance(node, h5py.Dataset):
+                var_attrs = {k: self._convert_type(v) for k, v in node.attrs.items()}
+                
+                # Check if it's a dimension scale (often used as coordinates in HDF5/netCDF4-hdf5)
+                is_scale = False
+                if "CLASS" in var_attrs and var_attrs["CLASS"] == "DIMENSION_SCALE":
+                    is_scale = True
+                    coordinate_names.append(name.split('/')[-1])
+                
+                # Extract dimension sizes
+                dims = []
+                for i, dim in enumerate(node.dims):
+                    if len(dim) > 0 and dim[0].name:
+                        dim_name = dim[0].name.split('/')[-1]
+                        dims.append(dim_name)
+                        dimensions_map[dim_name] = node.shape[i]
+                    else:
+                        dim_name = f"{name}_dim_{i}"
+                        dims.append(dim_name)
+                        dimensions_map[dim_name] = node.shape[i]
+                
+                if not dims:
+                    # If dims aren't formally defined, make placeholder names
+                    for i, s in enumerate(node.shape):
+                        dim_name = f"dim_{i}"
+                        dims.append(dim_name)
+                        dimensions_map[dim_name] = s
+
+                min_val = None
+                max_val = None
+                if node.size > 0 and node.size < 100000:
+                    try:
+                        # Only read small datasets to avoid memory issues
+                        data = node[:]
+                        min_val = float(np.min(data))
+                        max_val = float(np.max(data))
+                    except Exception:
+                        pass
+                
+                variables.append({
+                    "name": name,
+                    "datatype": str(node.dtype),
+                    "dimensions": dims,
+                    "shape": list(node.shape),
+                    "attributes": var_attrs,
+                    "min_value": min_val,
+                    "max_value": max_val
+                })
+
+        self.file.visititems(visit_func)
+
+        dimensions = [{"name": str(k), "size": int(v)} for k, v in dimensions_map.items()]
+
+        # Coordinates
+        lat_names = ["lat", "latitude", "y", "geolocation/latitude"]
+        lon_names = ["lon", "longitude", "x", "geolocation/longitude"]
+        
+        lat_coord = next((c for c in coordinate_names if c.lower() in lat_names), None)
+        lon_coord = next((c for c in coordinate_names if c.lower() in lon_names), None)
+        
+        # Sometimes lat/lon are just variables not marked as scales
+        if not lat_coord:
+            lat_coord = next((v["name"] for v in variables if v["name"].split('/')[-1].lower() in lat_names), None)
+        if not lon_coord:
+            lon_coord = next((v["name"] for v in variables if v["name"].split('/')[-1].lower() in lon_names), None)
+
+        projection = global_attributes.get("projection") or global_attributes.get("grid_mapping_name")
+        for var in variables:
+            if "grid_mapping" in var["attributes"] or "grid_mapping_name" in var["attributes"]:
+                projection = var["attributes"].get("grid_mapping_name") or "mapped"
+                break
+
+        coordinates = {
+            "latitude": lat_coord,
+            "longitude": lon_coord,
+            "projection": str(projection) if projection else None
+        }
+
+        # Temporal Information
+        time_names = ["time", "valid_time", "timestamp", "forecast_time"]
+        time_coord_name = next((c for c in coordinate_names if c.lower() in time_names), None)
+        if not time_coord_name:
+            time_coord_name = next((v["name"] for v in variables if v["name"].split('/')[-1].lower() in time_names), None)
+            
+        temporal_info = {
+            "start_time": None,
+            "end_time": None,
+            "time_steps": None
+        }
+
+        if time_coord_name and time_coord_name in self.file:
+            t_var = self.file[time_coord_name]
+            temporal_info["time_steps"] = int(t_var.size)
+            if t_var.size > 0:
+                try:
+                    data = t_var[:]
+                    temporal_info["start_time"] = str(data[0])
+                    temporal_info["end_time"] = str(data[-1])
+                except Exception:
+                    pass
+
+        return {
+            "global_attributes": global_attributes,
+            "dimensions": dimensions,
+            "variables": variables,
+            "coordinates": coordinates,
+            "temporal_info": temporal_info,
+            "variable_count": len(variables),
+            "dimension_count": len(dimensions),
+            "coordinate_count": len(coordinate_names)
+        }
+
+    def close(self):
+        if self.file is not None:
+            self.file.close()

backend/app/services/scientific/metadata_service.py

@@ -0,0 +1,64 @@
+import os
+import logging
+from typing import Dict, Any
+
+from app.schemas.metadata import MetadataResponse, DimensionInfo, VariableInfo, CoordinateInfo, TemporalInfo, DatasetSummary
+from .netcdf_parser import NetCDFParser
+from .hdf_parser import HDFParser
+
+logger = logging.getLogger(__name__)
+
+class MetadataService:
+    @staticmethod
+    def get_parser(file_path: str):
+        ext = os.path.splitext(file_path)[1].lower()
+        if ext == ".nc":
+            return NetCDFParser()
+        elif ext in [".h5", ".hdf5"]:
+            return HDFParser()
+        else:
+            raise ValueError(f"Unsupported file extension: {ext}")
+
+    @staticmethod
+    def extract_metadata(file_id: str, file_path: str) -> MetadataResponse:
+        logger.info(f"Opening dataset {file_id} at {file_path}")
+        parser = None
+        try:
+            parser = MetadataService.get_parser(file_path)
+            parser.load_dataset(file_path)
+            
+            raw_metadata = parser.extract_metadata()
+            
+            file_size = os.path.getsize(file_path)
+            file_format = os.path.splitext(file_path)[1].lower().strip(".")
+            
+            summary = DatasetSummary(
+                file_format=file_format,
+                variable_count=raw_metadata["variable_count"],
+                dimension_count=raw_metadata["dimension_count"],
+                coordinate_count=raw_metadata["coordinate_count"],
+                dataset_size=file_size
+            )
+            
+            response = MetadataResponse(
+                file_id=file_id,
+                filename=os.path.basename(file_path),
+                size=file_size,
+                format=file_format,
+                global_attributes=raw_metadata["global_attributes"],
+                dimensions=[DimensionInfo(**d) for d in raw_metadata["dimensions"]],
+                variables=[VariableInfo(**v) for v in raw_metadata["variables"]],
+                coordinates=CoordinateInfo(**raw_metadata["coordinates"]),
+                temporal_info=TemporalInfo(**raw_metadata["temporal_info"]),
+                summary=summary
+            )
+            
+            logger.info(f"Metadata extracted successfully for {file_id}")
+            return response
+            
+        except Exception as e:
+            logger.error(f"Metadata extraction failed for {file_id}: {str(e)}")
+            raise e
+        finally:
+            if parser is not None:
+                parser.close()

backend/app/services/scientific/metrics.py

@@ -0,0 +1 @@
+# Placeholder

backend/app/services/scientific/netcdf_parser.py

@@ -0,0 +1,110 @@
+import xarray as xr
+import numpy as np
+from typing import Dict, Any
+from .base_parser import BaseDatasetParser
+
+class NetCDFParser(BaseDatasetParser):
+    def __init__(self):
+        self.ds = None
+
+    def load_dataset(self, file_path: str):
+        self.ds = xr.open_dataset(file_path, engine="netcdf4")
+
+    def _convert_type(self, val):
+        if isinstance(val, (np.integer, int)):
+            return int(val)
+        if isinstance(val, (np.floating, float)):
+            return float(val)
+        if isinstance(val, np.ndarray):
+            return val.tolist()
+        return str(val)
+
+    def extract_metadata(self) -> Dict[str, Any]:
+        if self.ds is None:
+            raise ValueError("Dataset not loaded")
+
+        # Global Attributes
+        global_attributes = {k: self._convert_type(v) for k, v in self.ds.attrs.items()}
+
+        # Dimensions
+        dimensions = [{"name": str(k), "size": int(v)} for k, v in self.ds.sizes.items()]
+
+        # Variables
+        variables = []
+        for name, var in self.ds.variables.items():
+            # Skip if it's purely a coordinate (optional, but requested all variables? Usually we list all)
+            min_val = None
+            max_val = None
+            # Only calculate min/max if it's not a huge dataset or inexpensive. For metadata, we can sample or ignore.
+            # To be safe and inexpensive, we might just skip or do min/max on small arrays.
+            if var.size < 100000:  # arbitrary small limit
+                try:
+                    min_val = float(var.min().values)
+                    max_val = float(var.max().values)
+                except Exception:
+                    pass
+
+            variables.append({
+                "name": str(name),
+                "datatype": str(var.dtype),
+                "dimensions": list(var.dims),
+                "shape": list(var.shape),
+                "attributes": {k: self._convert_type(v) for k, v in var.attrs.items()},
+                "min_value": min_val,
+                "max_value": max_val
+            })
+
+        # Coordinates
+        lat_names = ["lat", "latitude", "y"]
+        lon_names = ["lon", "longitude", "x"]
+        
+        lat_coord = next((c for c in self.ds.coords if c.lower() in lat_names), None)
+        lon_coord = next((c for c in self.ds.coords if c.lower() in lon_names), None)
+        
+        # Look for projection attributes or standard grid mappings
+        projection = global_attributes.get("projection") or global_attributes.get("grid_mapping_name")
+        for var in variables:
+            if "grid_mapping" in var["attributes"] or "grid_mapping_name" in var["attributes"]:
+                projection = var["attributes"].get("grid_mapping_name") or var["attributes"].get("grid_mapping") or "mapped"
+                break
+
+        coordinates = {
+            "latitude": lat_coord,
+            "longitude": lon_coord,
+            "projection": str(projection) if projection else None
+        }
+
+        # Temporal Information
+        time_names = ["time", "valid_time", "timestamp", "forecast_time"]
+        time_coord = next((c for c in self.ds.coords if c.lower() in time_names), None)
+        
+        temporal_info = {
+            "start_time": None,
+            "end_time": None,
+            "time_steps": None
+        }
+        
+        if time_coord is not None:
+            t_var = self.ds[time_coord]
+            temporal_info["time_steps"] = int(t_var.size)
+            if t_var.size > 0:
+                try:
+                    temporal_info["start_time"] = str(t_var.values[0])
+                    temporal_info["end_time"] = str(t_var.values[-1])
+                except Exception:
+                    pass
+
+        return {
+            "global_attributes": global_attributes,
+            "dimensions": dimensions,
+            "variables": variables,
+            "coordinates": coordinates,
+            "temporal_info": temporal_info,
+            "variable_count": len(variables),
+            "dimension_count": len(dimensions),
+            "coordinate_count": len(self.ds.coords)
+        }
+
+    def close(self):
+        if self.ds is not None:
+            self.ds.close()

backend/app/services/scientific/visualization.py

@@ -0,0 +1 @@
+# Placeholder

backend/app/services/upload_service.py

@@ -0,0 +1,56 @@
+import os
+import uuid
+import shutil
+from pathlib import Path
+from fastapi import UploadFile, HTTPException
+from typing import Dict, Any
+
+UPLOAD_DIR = Path("storage/uploads")
+
+ALLOWED_EXTENSIONS = {".nc", ".h5", ".hdf5"}
+ALLOWED_MIME_TYPES = {
+    "application/x-netcdf",
+    "application/netcdf",
+    "application/x-hdf5",
+    "application/x-hdf",
+    "application/octet-stream",
+}
+
+MAX_FILE_SIZE = 100 * 1024 * 1024  # 100 MB
+
+class UploadService:
+    @staticmethod
+    async def process_upload(file: UploadFile) -> Dict[str, Any]:
+        if not file.filename:
+            raise HTTPException(status_code=400, detail="Filename missing")
+            
+        ext = Path(file.filename).suffix.lower()
+        if ext not in ALLOWED_EXTENSIONS:
+            raise HTTPException(status_code=400, detail=f"File extension {ext} not allowed. Supported: .nc, .h5, .hdf5")
+            
+        if file.content_type not in ALLOWED_MIME_TYPES:
+            raise HTTPException(status_code=400, detail=f"Invalid MIME type: {file.content_type}")
+            
+        # File size validation
+        file.file.seek(0, os.SEEK_END)
+        file_size = file.file.tell()
+        file.file.seek(0)
+        
+        if file_size > MAX_FILE_SIZE:
+            raise HTTPException(status_code=400, detail="File size exceeds maximum allowed limit (100MB)")
+
+        UPLOAD_DIR.mkdir(parents=True, exist_ok=True)
+        
+        file_id = str(uuid.uuid4())
+        safe_filename = f"{file_id}{ext}"
+        file_path = UPLOAD_DIR / safe_filename
+        
+        with open(file_path, "wb") as buffer:
+            shutil.copyfileobj(file.file, buffer)
+            
+        return {
+            "success": True,
+            "fileId": file_id,
+            "filename": file.filename,
+            "status": "uploaded"
+        }

backend/app/storage/__init__.py

@@ -0,0 +1 @@
+# Placeholder

backend/app/utils/__init__.py

@@ -0,0 +1 @@
+# Placeholder

backend/requirements.txt

@@ -0,0 +1,10 @@
+# Backend dependencies
+fastapi>=0.100.0
+uvicorn>=0.23.0
+pydantic>=2.0.0
+python-multipart>=0.0.6
+xarray>=2023.0.0
+netCDF4>=1.6.0
+h5py>=3.8.0
+h5netcdf>=1.1.0
+pytest>=7.0.0

backend/tests/test_metadata.py

@@ -0,0 +1,104 @@
+import os
+import tempfile
+import pytest
+import h5py
+import netCDF4 as nc
+import numpy as np
+from fastapi.testclient import TestClient
+
+from app.main import app
+from app.services.scientific.metadata_service import MetadataService
+from app.schemas.metadata import MetadataResponse
+
+client = TestClient(app)
+
+@pytest.fixture
+def mock_netcdf():
+    fd, path = tempfile.mkstemp(suffix=".nc")
+    os.close(fd)
+    
+    # Create a mock netcdf file
+    ds = nc.Dataset(path, 'w', format='NETCDF4')
+    ds.title = "Mock NetCDF"
+    ds.projection = "mercator"
+    
+    ds.createDimension('time', None) # unlimited
+    ds.createDimension('lat', 10)
+    ds.createDimension('lon', 10)
+    
+    times = ds.createVariable('time', 'f8', ('time',))
+    lats = ds.createVariable('lat', 'f4', ('lat',))
+    lons = ds.createVariable('lon', 'f4', ('lon',))
+    temp = ds.createVariable('temperature', 'f4', ('time', 'lat', 'lon',))
+    
+    lats.units = 'degrees_north'
+    lons.units = 'degrees_east'
+    temp.units = 'K'
+    temp.grid_mapping = 'mercator'
+    
+    times[:] = [1620000000, 1620003600] # two time steps
+    lats[:] = np.linspace(-90, 90, 10)
+    lons[:] = np.linspace(-180, 180, 10)
+    temp[:] = np.random.uniform(200, 300, size=(2, 10, 10))
+    
+    ds.close()
+    
+    yield path
+    os.remove(path)
+
+@pytest.fixture
+def mock_hdf5():
+    fd, path = tempfile.mkstemp(suffix=".h5")
+    os.close(fd)
+    
+    with h5py.File(path, "w") as f:
+        f.attrs["title"] = "Mock HDF5"
+        f.attrs["projection"] = "geospatial"
+        
+        # Dimensions
+        lat_dim = f.create_dataset("latitude", data=np.linspace(-90, 90, 10))
+        lat_dim.attrs["CLASS"] = "DIMENSION_SCALE"
+        
+        lon_dim = f.create_dataset("longitude", data=np.linspace(-180, 180, 10))
+        lon_dim.attrs["CLASS"] = "DIMENSION_SCALE"
+        
+        time_dim = f.create_dataset("time", data=np.array([1620000000, 1620003600]))
+        time_dim.attrs["CLASS"] = "DIMENSION_SCALE"
+        
+        # Variable
+        temp = f.create_dataset("temperature", data=np.random.uniform(200, 300, size=(2, 10, 10)))
+        temp.dims[0].label = "time"
+        temp.dims[1].label = "lat"
+        temp.dims[2].label = "lon"
+        temp.attrs["units"] = "K"
+        
+    yield path
+    os.remove(path)
+
+def test_extract_netcdf_metadata(mock_netcdf):
+    metadata = MetadataService.extract_metadata("test_nc", mock_netcdf)
+    assert metadata.format == "nc"
+    assert metadata.summary.file_format == "nc"
+    assert metadata.coordinates.latitude == "lat"
+    assert metadata.coordinates.longitude == "lon"
+    assert metadata.coordinates.projection == "mercator"
+    assert metadata.temporal_info.time_steps == 2
+    assert "time" in [d.name for d in metadata.dimensions]
+    assert "temperature" in [v.name for v in metadata.variables]
+
+def test_extract_hdf5_metadata(mock_hdf5):
+    metadata = MetadataService.extract_metadata("test_h5", mock_hdf5)
+    assert metadata.format == "h5"
+    assert metadata.coordinates.latitude == "latitude"
+    assert metadata.coordinates.longitude == "longitude"
+    assert metadata.coordinates.projection == "geospatial"
+    assert metadata.temporal_info.time_steps == 2
+    assert "temperature" in [v.name for v in metadata.variables]
+
+def test_metadata_api_not_found():
+    response = client.get("/api/v1/metadata/non_existent_file")
+    assert response.status_code == 404
+
+def test_metadata_service_invalid_ext():
+    with pytest.raises(ValueError):
+        MetadataService.get_parser("test.txt")