rudrakshyadav1/deepseapoc

Purpose and Topology

This repository is a bioinformatics analysis product: a Next.js frontend lets users upload and inspect site/sample analyses, while a Python backend exposes job-oriented APIs and a standalone Python pipeline processes sequencing data through QC, taxonomy, and reporting stages.

Frontend Application

Next.js App Router provides public pages, authentication, and a dashboard. Primary page entry points are:

• frontend/src/app/page.tsx

• frontend/src/app/dashboard/page.tsx

• frontend/src/app/layout.tsx

Dashboard UI is organized around upload, map/site selection, and result presentation:

• frontend/src/app/components/dashboard/UploadPanel.tsx

• frontend/src/app/components/dashboard/MapComponent.tsx

• frontend/src/app/components/dashboard/ResultsPanel.tsx

The map uses a bundled India GeoJSON dataset at frontend/public/india-composite.geojson.

Frontend State, Identity, and Backend Boundary

JobContext coordinates analysis-job state across dashboard components, while Redux store setup includes an authentication slice:

• frontend/src/app/contexts/JobContext.tsx

• frontend/src/store/store.tsx

• frontend/src/store/authSlice.ts

Firebase is the apparent client authentication integration:

• frontend/src/firebase/firebase.ts

BackendDataService is the principal frontend-to-backend boundary; it should encapsulate API calls rather than allowing dashboard components to depend directly on backend endpoints:

• frontend/src/app/services/BackendDataService.ts

Mock site/sample data supports frontend operation independent of completed backend analyses:

• frontend/src/data/mockSamples.json

• frontend/src/data/mockSites.json

Backend API and Job Control Plane

The Python backend is structured as an API service with versioned route modules. Application startup and shared infrastructure are centered in:

• backend/app/main.py

• backend/app/db.py

• backend/app/core/config.py

The externally meaningful workflow endpoints are separated by responsibility:

• upload intake: backend/app/api/v1/upload.py

• job creation/status: backend/app/api/v1/jobs.py

• analysis retrieval: backend/app/api/v1/results.py

A health endpoint supports service monitoring at backend/app/api/v1/health.py. There is also a routes-level jobs module, suggesting job routing or compatibility logic:

• backend/app/routes/jobs.py

Persistence, Schemas, and Security

Backend models define persisted job/result domain entities, and schemas define request/response contracts:

• backend/app/models/models.py

• backend/app/schemas/schemas.py

Security concerns are isolated from endpoint handlers:

• backend/app/core/security.py

The database implementation is represented by backend/app/db.py; the tree does not identify its database vendor. Logging is similarly centralized:

• backend/app/core/logger.py

Asynchronous Processing Boundary

Celery is the designated background-worker runtime, separating API request handling from long-running analysis execution:

• backend/app/workers/celery_worker.py

• backend/app/api/v1/jobs.py

The intended control flow is: frontend uploads data → backend creates/persists a job → Celery worker executes analysis → frontend polls or retrieves job results through the results API. Broker/result-backend infrastructure is not identifiable from the supplied tree.

Bioinformatics Pipeline

The standalone pipeline orchestrator is:

• pipeline/run_pipeline.py

It composes a staged analysis flow over uploaded sequencing inputs:

1. Input conversion and QC: pipeline/converter.py, pipeline/steps/qc.py

2. Read cleanup: pipeline/steps/adapters.py, pipeline/steps/filter.py, pipeline/steps/chimera.py, pipeline/steps/contam.py

3. Biological reduction/classification: pipeline/steps/cluster.py, pipeline/steps/annotate.py, pipeline/steps/genus.py

4. Analytical output generation: pipeline/steps/abundance.py, pipeline/steps/embed.py, pipeline/steps/reduce.py, pipeline/steps/report.py

pipeline/cache/ncbi_cache.json indicates NCBI-derived lookup/cache usage, likely associated with annotation. Pipeline outputs must be translated into the backend’s result model/API contract for dashboard consumption.