Upload 33 files

.gitignore

@@ -0,0 +1,64 @@
+.git
+__pycache__/
+*.py[cod]
+*$py.class
+*.so
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+
+# Virtual Environment
+venv/
+ENV/
+env/
+
+# Neo4j data
+neo4j_data/
+
+# Downloaded data
+data/gdc/*
+data/boinc/*
+data/cache/*
+data/processed/*
+
+# Logs
+logs/
+*.log
+
+# IDE
+.vscode/
+.idea/
+*.swp
+*.swo
+*~
+
+# OS
+.DS_Store
+Thumbs.db
+
+# Config overrides
+config.local.yml
+
+# Test coverage
+htmlcov/
+.coverage
+.pytest_cache/
+
+# Jupyter
+.ipynb_checkpoints/
+
+# Docker
+.dockerignore

ARCHITECTURE.md

@@ -0,0 +1,256 @@
+# Cancer@Home v2 - Architecture Diagram
+
+## System Architecture
+
+```
+┌─────────────────────────────────────────────────────────────────────────┐
+│                         WEB BROWSER                                      │
+│                      http://localhost:5000                               │
+└────────────────────────────┬────────────────────────────────────────────┘
+                             │
+                             │ HTTP/WebSocket
+                             ▼
+┌─────────────────────────────────────────────────────────────────────────┐
+│                    FRONTEND (HTML5/CSS3/JS)                             │
+│  ┌──────────┬──────────┬──────────┬──────────┬──────────────────────┐  │
+│  │Dashboard │  Neo4j   │  BOINC   │   GDC    │    Pipeline          │  │
+│  │  View    │   Viz    │  Tasks   │   Data   │    Tools             │  │
+│  └──────────┴──────────┴──────────┴──────────┴──────────────────────┘  │
+│                                                                          │
+│  Technologies: D3.js, Chart.js, Vanilla JavaScript                      │
+└────────────────────────────┬────────────────────────────────────────────┘
+                             │
+                             │ REST API + GraphQL
+                             ▼
+┌─────────────────────────────────────────────────────────────────────────┐
+│                    BACKEND (FastAPI + Python)                           │
+│  ┌─────────────────────────────────────────────────────────────────┐   │
+│  │                      API Layer                                   │   │
+│  │  • REST Endpoints (/api/*)                                      │   │
+│  │  • GraphQL Endpoint (/graphql)                                  │   │
+│  │  • WebSocket Support                                            │   │
+│  │  • Swagger Documentation (/docs)                                │   │
+│  └─────────────────────────────────────────────────────────────────┘   │
+│                             │                                            │
+│                             │ Python Modules                             │
+│                             ▼                                            │
+│  ┌──────────┬──────────┬──────────┬──────────┬─────────────────────┐   │
+│  │  BOINC   │   GDC    │  Neo4j   │ Pipeline │   Utilities         │   │
+│  │  Client  │  Client  │   DB     │ Tools    │                     │   │
+│  └──────────┴──────────┴──────────┴──────────┴─────────────────────┘   │
+└───────┬──────────┬──────────┬──────────┬────────────────────────────────┘
+        │          │          │          │
+        │          │          │          │
+        ▼          ▼          ▼          ▼
+┌─────────────────────────────────────────────────────────────────────────┐
+│                        DATA & SERVICES LAYER                            │
+│                                                                          │
+│  ┌────────────────────┐  ┌────────────────────┐  ┌──────────────────┐ │
+│  │    Neo4j Graph     │  │   BOINC Server     │  │   GDC Portal     │ │
+│  │     Database       │  │   (Distributed)    │  │   (External)     │ │
+│  │                    │  │                    │  │                  │ │
+│  │ Port: 7687 (Bolt)  │  │ Local/Remote       │  │ api.gdc.cancer   │
+│  │       7474 (HTTP)  │  │ Task Processing    │  │ .gov             │ │
+│  │                    │  │                    │  │                  │ │
+│  │ • Genes            │  │ • Variant Calling  │  │ • TCGA Data      │ │
+│  │ • Mutations        │  │ • BLAST Search     │  │ • TARGET Data    │ │
+│  │ • Patients         │  │ • Alignment        │  │ • Clinical Data  │ │
+│  │ • Cancer Types     │  │ • Annotation       │  │ • Genomic Files  │ │
+│  └────────────────────┘  └────────────────────┘  └──────────────────┘ │
+│                                                                          │
+│  ┌────────────────────────────────────────────────────────────────────┐│
+│  │              Bioinformatics Tools (Local)                          ││
+│  │                                                                     ││
+│  │  ┌──────────────┐  ┌──────────────┐  ┌──────────────────────┐    ││
+│  │  │   FASTQ      │  │    BLAST     │  │   Variant Caller     │    ││
+│  │  │  Processor   │  │    Runner    │  │                      │    ││
+│  │  │              │  │              │  │                      │    ││
+│  │  │ • QC         │  │ • BLASTN     │  │ • VCF Generation     │    ││
+│  │  │ • Filtering  │  │ • BLASTP     │  │ • Annotation         │    ││
+│  │  │ • Trimming   │  │ • Parsing    │  │ • TMB Calculation    │    ││
+│  │  └──────────────┘  └──────────────┘  └──────────────────────┘    ││
+│  └────────────────────────────────────────────────────────────────────┘│
+└─────────────────────────────────────────────────────────────────────────┘
+                             │
+                             ▼
+┌─────────────────────────────────────────────────────────────────────────┐
+│                       FILE STORAGE                                       │
+│                                                                          │
+│  data/                                                                   │
+│  ├── gdc/              # Downloaded GDC files                           │
+│  ├── boinc/            # BOINC task data                                │
+│  ├── processed/        # Analysis results                               │
+│  │   ├── fastq/                                                         │
+│  │   ├── blast/                                                         │
+│  │   └── variants/                                                      │
+│  └── cache/            # Temporary files                                │
+│                                                                          │
+│  logs/                 # Application logs                               │
+└─────────────────────────────────────────────────────────────────────────┘
+```
+
+## Data Flow Diagram
+
+```
+┌──────────────┐
+│   User       │
+│   Browser    │
+└──────┬───────┘
+       │ 1. Request
+       ▼
+┌──────────────────────────���───────┐
+│   Dashboard                      │
+│   (View Gene/Mutation Data)      │
+└──────┬───────────────────────────┘
+       │ 2. GraphQL Query
+       ▼
+┌──────────────────────────────────┐
+│   FastAPI Backend                │
+│   - Parse Query                  │
+│   - Validate Request             │
+└──────┬───────────────────────────┘
+       │ 3. Cypher Query
+       ▼
+┌──────────────────────────────────┐
+│   Neo4j Database                 │
+│   - Execute Graph Query          │
+│   - Traverse Relationships       │
+│   - Aggregate Results            │
+└──────┬───────────────────────────┘
+       │ 4. Graph Data
+       ▼
+┌──────────────────────────────────┐
+│   GraphQL Resolver               │
+│   - Transform Data               │
+│   - Format Response              │
+└──────┬───────────────────────────┘
+       │ 5. JSON Response
+       ▼
+┌──────────────────────────────────┐
+│   Frontend Visualization         │
+│   - Render Graph                 │
+│   - Display Charts               │
+│   - Show Statistics              │
+└──────────────────────────────────┘
+```
+
+## BOINC Task Processing Flow
+
+```
+┌──────────────┐      ┌──────────────┐      ┌──────────────┐
+│   Submit     │      │   Queue      │      │   Execute    │
+│   Task       │─────▶│   Task       │─────▶│   Analysis   │
+│              │      │              │      │              │
+└──────────────┘      └──────────────┘      └──────┬───────┘
+                                                    │
+                                                    ▼
+┌──────────────┐      ┌──────────────┐      ┌──────────────┐
+│   Store      │      │   Import to  │      │   Generate   │
+│   Results    │◀─────│   Neo4j      │◀─────│   Results    │
+│              │      │              │      │              │
+└──────────────┘      └──────────────┘      └──────────────┘
+```
+
+## Neo4j Graph Schema
+
+```
+┌─────────────────────────────────────────────────────────────────┐
+│                       Neo4j Graph Model                         │
+│                                                                  │
+│   ┌──────────┐                    ┌──────────┐                 │
+│   │   Gene   │                    │ Mutation │                 │
+│   ├──────────┤                    ├──────────┤                 │
+│   │ gene_id  │◀───────AFFECTS─────│mut_id    │                 │
+│   │ symbol   │                    │ chr      │                 │
+│   │ name     │                    │ position │                 │
+│   │ chr      │                    │ ref      │                 │
+│   └──────────┘                    │ alt      │                 │
+│                                    └────▲─────┘                 │
+│                                         │                        │
+│                                         │ HAS_MUTATION           │
+│                                         │                        │
+│   ┌──────────┐                    ┌────┴─────┐                 │
+│   │  Cancer  │                    │ Patient  │                 │
+│   │   Type   │                    ├──────────┤                 │
+│   ├──────────┤                    │patient_id│                 │
+│   │cancer_id │                    │ age      │                 │
+│   │ name     │◀──DIAGNOSED_WITH───│ gender   │                 │
+│   │ tissue   │                    │ race     │                 │
+│   └──────────┘                    │ status   │                 │
+│                                    └──────────┘                 │
+│                                                                  │
+│  Relationships:                                                 │
+│  • Gene ← AFFECTS ← Mutation                                   │
+│  • Patient → HAS_MUTATION → Mutation                           │
+│  • Patient → DIAGNOSED_WITH → CancerType                       │
+└─────────────────────────────────────────────────────────────────┘
+```
+
+## Technology Stack
+
+```
+┌─────────────────────────────────────────────────────────────────┐
+│                    Technology Layers                            │
+│                                                                  │
+│  Frontend:                                                      │
+│  • HTML5, CSS3, JavaScript (ES6+)                              │
+│  • D3.js (Graph Visualization)                                 │
+│  • Chart.js (Charts & Analytics)                               │
+│  • Responsive Design                                            │
+│                                                                  │
+│  Backend:                                                       │
+│  • Python 3.8+                                                 │
+│  • FastAPI (Web Framework)                                     │
+│  • Uvicorn (ASGI Server)                                       │
+│  • Strawberry (GraphQL)                                        │
+│                                                                  │
+│  Database:                                                      │
+│  • Neo4j 5.13 (Graph Database)                                │
+│  • Bolt Protocol                                               │
+│  • APOC & GDS Plugins                                          │
+│                                                                  │
+│  Data Processing:                                              │
+│  • Biopython (Sequence Analysis)                               │
+│  • NumPy & Pandas (Data Manipulation)                         │
+│  • BLAST+ (Sequence Alignment)                                 │
+│                                                                  │
+│  Infrastructure:                                               │
+│  • Docker & Docker Compose                                     │
+│  • YAML Configuration                                          │
+│  • Python Virtual Environments                                 │
+│                                                                  │
+│  External APIs:                                                │
+│  • GDC Portal API (Cancer Data)                               │
+│  • BOINC RPC (Distributed Computing)                          │
+└─────────────────────────────────────────────────────────────────┘
+```
+
+## Deployment Architecture
+
+```
+┌─────────────────────────────────────────────────────────────────┐
+│                    Local Development                            │
+│                                                                  │
+│  ┌──────────────────────────────────────────────────────────┐  │
+│  │  Host Machine                                            │  │
+│  │                                                           │  │
+│  │  ┌─────────────────┐         ┌──────────────────────┐   │  │
+│  │  │  Python venv    │         │  Docker Desktop      │   │  │
+│  │  │  Port 5000      │         │                      │   │  │
+│  │  │                 │         │  ┌────────────────┐  │   │  │
+│  │  │  • FastAPI      │         │  │  Neo4j         │  │   │  │
+│  │  │  • Backend API  │◀───────▶│  │  Port 7474     │  │   │  │
+│  │  │  • GraphQL      │         │  │  Port 7687     │  │   │  │
+│  │  │  • WebSocket    │         │  └────────────────┘  │   │  │
+│  │  │                 │         │                      │   │  │
+│  │  └─────────────────┘         └──────────────────────┘   │  │
+│  │                                                           │  │
+│  └──────────────────────────────────────────────────────────┘  │
+│                                                                  │
+│  Access URLs:                                                  │
+│  • http://localhost:5000      - Main Application              │
+│  • http://localhost:5000/docs  - API Documentation            │
+│  • http://localhost:5000/graphql - GraphQL Playground         │
+│  • http://localhost:7474       - Neo4j Browser                │
+└─────────────────────────────────────────────────────────────────┘
+```

CHANGELOG.md

@@ -0,0 +1,182 @@
+# Changelog
+
+All notable changes to Cancer@Home v2 will be documented in this file.
+
+## [2.0.0] - 2025-11-19
+
+### 🎉 Initial Release
+
+#### Added
+- **Core Infrastructure**
+  - FastAPI backend with REST and GraphQL APIs
+  - Neo4j graph database integration
+  - Docker Compose setup for easy deployment
+  - Python virtual environment configuration
+  - Comprehensive YAML-based configuration system
+
+- **BOINC Integration**
+  - Distributed computing task submission
+  - Task status monitoring and tracking
+  - Support for variant calling, BLAST, and alignment tasks
+  - Task statistics and performance metrics
+  - JSON-based task persistence
+
+- **GDC Data Portal Integration**
+  - API client for GDC cancer data
+  - File search and download capabilities
+  - Support for TCGA and TARGET projects
+  - MAF and VCF file parsers
+  - Clinical data extraction
+
+- **Bioinformatics Pipeline**
+  - FASTQ quality control and filtering
+  - Adapter trimming
+  - BLAST sequence alignment (BLASTN/BLASTP)
+  - Variant calling from sequencing data
+  - Cancer variant identification
+  - Tumor mutation burden calculation
+
+- **Neo4j Graph Database**
+  - Comprehensive graph schema (Genes, Mutations, Patients, Cancer Types)
+  - Repository pattern for data access
+  - GraphQL schema with flexible querying
+  - Sample dataset with 7 genes, 5 mutations, 5 patients, 4 cancer types
+  - Optimized with constraints and indexes
+
+- **Web Dashboard**
+  - Modern, responsive HTML5/CSS3/JavaScript interface
+  - 5 main sections: Dashboard, Neo4j Visualization, BOINC Tasks, GDC Data, Pipeline
+  - Interactive D3.js graph visualization
+  - Chart.js analytics and statistics
+  - Real-time data updates
+  - Clean gradient-based design
+
+- **API Endpoints**
+  - `/api/health` - System health check
+  - `/api/neo4j/summary` - Database statistics
+  - `/api/neo4j/genes/{symbol}` - Gene information
+  - `/api/boinc/*` - BOINC task management
+  - `/api/gdc/*` - GDC data access
+  - `/api/pipeline/*` - Bioinformatics tools
+  - `/graphql` - GraphQL playground
+  - `/docs` - Swagger API documentation
+
+- **Documentation**
+  - Comprehensive README with installation guide
+  - Quick start guide (QUICKSTART.md)
+  - Detailed user guide (USER_GUIDE.md)
+  - GraphQL query examples (GRAPHQL_EXAMPLES.md)
+  - Architecture documentation (ARCHITECTURE.md)
+  - Project summary (PROJECT_SUMMARY.md)
+  - MIT License
+
+- **Setup & Deployment**
+  - Automated Windows setup script (setup.ps1)
+  - Automated Linux/Mac setup script (setup.sh)
+  - One-command application launcher (run.py)
+  - Rich terminal output with progress tracking
+  - Automatic directory structure creation
+  - Database schema initialization
+
+- **Testing**
+  - Comprehensive test suite (test_cancer_at_home.py)
+  - Module import tests
+  - Integration tests
+  - Directory structure validation
+
+#### Features Highlights
+
+✓ **Easy Installation**: 5-minute setup with automated scripts  
+✓ **Interactive Dashboard**: Modern web UI with real-time updates  
+✓ **Graph Visualization**: Neo4j-powered relationship mapping  
+✓ **Flexible Querying**: Both REST and GraphQL APIs  
+✓ **Distributed Computing**: BOINC integration for heavy workloads  
+✓ **Real Data**: GDC Portal integration for cancer genomics  
+✓ **Bioinformatics**: Complete FASTQ → BLAST → VCF pipeline  
+✓ **Well Documented**: 7 documentation files covering all aspects  
+✓ **Production Ready**: Error handling, logging, configuration  
+
+#### Technical Specifications
+
+- **Python**: 3.8+
+- **Neo4j**: 5.13 Community Edition
+- **FastAPI**: 0.104.1
+- **Docker**: Latest
+- **Supported OS**: Windows, Linux, macOS
+
+#### Sample Data Included
+
+**Genes**: TP53, BRAF, BRCA1, BRCA2, PIK3CA, KRAS, EGFR  
+**Cancer Types**: Breast Cancer, Lung Adenocarcinoma, Colon Adenocarcinoma, Glioblastoma  
+**Projects**: TCGA-BRCA, TCGA-LUAD, TCGA-COAD, TCGA-GBM, TARGET-AML  
+
+---
+
+## Version Numbering
+
+This project follows [Semantic Versioning](https://semver.org/):
+- **MAJOR**: Incompatible API changes
+- **MINOR**: New functionality, backwards compatible
+- **PATCH**: Bug fixes, backwards compatible
+
+---
+
+## Future Roadmap
+
+### Planned Features (v2.1.0)
+- [ ] Machine learning for mutation prediction
+- [ ] Multi-omics data integration (RNA-seq, proteomics)
+- [ ] Advanced graph algorithms (PageRank, community detection)
+- [ ] Export and report generation (PDF, Excel)
+- [ ] User authentication and authorization
+- [ ] Data caching for improved performance
+
+### Planned Features (v2.2.0)
+- [ ] Survival analysis and clinical outcomes
+- [ ] Drug response prediction
+- [ ] Mobile-responsive design improvements
+- [ ] Real-time collaboration features
+- [ ] Batch data import wizard
+- [ ] Advanced search and filtering
+
+### Long-term Goals
+- [ ] Cloud deployment support (AWS, Azure, GCP)
+- [ ] Kubernetes orchestration
+- [ ] Microservices architecture
+- [ ] Real-time BOINC cluster management
+- [ ] Integration with additional data sources
+- [ ] AI-powered data analysis
+
+---
+
+## Contributing
+
+Contributions are welcome! Please see CONTRIBUTING.md (to be created) for guidelines.
+
+---
+
+## Support
+
+For issues, questions, or suggestions:
+- Check the documentation first
+- Review logs in `logs/cancer_at_home.log`
+- Open a GitHub issue (if applicable)
+
+---
+
+## Acknowledgments
+
+Built with inspiration from:
+- Cancer@Home v1 (HeroX DCx Challenge)
+- Andrew Kamal's Neo4j Cancer Visualization Dashboard
+- The Cancer Genome Atlas (TCGA) Project
+- BOINC Project at UC Berkeley
+
+Data provided by:
+- Genomic Data Commons (GDC) Portal
+- National Cancer Institute (NCI)
+- The Cancer Genome Atlas Program
+
+---
+
+**Cancer@Home v2** - Making cancer genomics research accessible, distributed, and visual.

GRAPHQL_EXAMPLES.md

@@ -0,0 +1,258 @@
+# Example GraphQL Queries for Cancer@Home v2
+
+## Basic Queries
+
+### Get all genes
+```graphql
+query {
+  genes(limit: 10) {
+    gene_id
+    symbol
+    name
+    chromosome
+    gene_type
+  }
+}
+```
+
+### Get specific gene by symbol
+```graphql
+query {
+  gene(symbol: "TP53") {
+    gene_id
+    symbol
+    name
+    chromosome
+    start_position
+    end_position
+  }
+}
+```
+
+### Get mutations for a specific gene
+```graphql
+query {
+  mutations(gene: "TP53", limit: 20) {
+    mutation_id
+    chromosome
+    position
+    reference
+    alternate
+    consequence
+    variant_type
+    quality
+  }
+}
+```
+
+### Get mutations on a chromosome
+```graphql
+query {
+  mutations(chromosome: "chr17", limit: 50) {
+    mutation_id
+    position
+    reference
+    alternate
+    consequence
+  }
+}
+```
+
+## Patient Queries
+
+### Get all patients
+```graphql
+query {
+  patients(limit: 100) {
+    patient_id
+    project_id
+    age
+    gender
+    race
+    vital_status
+  }
+}
+```
+
+### Get patients by project
+```graphql
+query {
+  patients(project_id: "TCGA-BRCA") {
+    patient_id
+    age
+    gender
+    vital_status
+  }
+}
+```
+
+### Get patients by cancer type
+```graphql
+query {
+  patients(cancer_type: "BRCA", limit: 50) {
+    patient_id
+    age
+    gender
+    race
+  }
+}
+```
+
+## Cancer Type Queries
+
+### Get all cancer types
+```graphql
+query {
+  cancerTypes {
+    cancer_type_id
+    name
+    tissue
+    disease_type
+  }
+}
+```
+
+### Get statistics for a cancer type
+```graphql
+query {
+  cancerStatistics(cancer_type_id: "BRCA") {
+    cancer_type
+    total_patients
+    total_mutations
+    avg_mutations_per_patient
+  }
+}
+```
+
+## Mutation Analysis
+
+### Get mutation frequency
+```graphql
+query {
+  mutationFrequency(mutation_id: "MUT-TP53-001") {
+    mutation_id
+    patients_with_mutation
+    total_patients
+    frequency
+  }
+}
+```
+
+## Complex Queries
+
+### Combined gene and mutation data
+```graphql
+query {
+  gene(symbol: "BRCA1") {
+    symbol
+    name
+    chromosome
+  }
+  
+  mutations(gene: "BRCA1") {
+    mutation_id
+    position
+    consequence
+    quality
+  }
+}
+```
+
+### Multiple cancer statistics
+```graphql
+query {
+  breastCancer: cancerStatistics(cancer_type_id: "BRCA") {
+    cancer_type
+    total_patients
+    total_mutations
+  }
+  
+  lungCancer: cancerStatistics(cancer_type_id: "LUAD") {
+    cancer_type
+    total_patients
+    total_mutations
+  }
+}
+```
+
+## Using Variables
+
+### Query with variables
+```graphql
+query GetGeneInfo($geneSymbol: String!) {
+  gene(symbol: $geneSymbol) {
+    symbol
+    name
+    chromosome
+  }
+  
+  mutations(gene: $geneSymbol) {
+    mutation_id
+    position
+    consequence
+  }
+}
+```
+
+Variables:
+```json
+{
+  "geneSymbol": "TP53"
+}
+```
+
+### Pagination example
+```graphql
+query GetMutations($limit: Int = 10) {
+  mutations(limit: $limit) {
+    mutation_id
+    chromosome
+    position
+  }
+}
+```
+
+Variables:
+```json
+{
+  "limit": 25
+}
+```
+
+## Filtering Examples
+
+### Get high-quality mutations
+```graphql
+query {
+  mutations(gene: "KRAS", limit: 100) {
+    mutation_id
+    quality
+    consequence
+  }
+}
+```
+
+### Get patients by demographics
+```graphql
+query {
+  patients(project_id: "TCGA-BRCA") {
+    patient_id
+    age
+    gender
+    race
+    vital_status
+  }
+}
+```
+
+## Tips for Using GraphQL
+
+1. **Use the GraphQL Playground**: Navigate to http://localhost:5000/graphql for an interactive interface with autocomplete and documentation
+
+2. **Request only needed fields**: GraphQL allows you to request exactly the data you need, improving performance
+
+3. **Combine multiple queries**: Use aliases to fetch different datasets in a single request
+
+4. **Use variables**: Make queries reusable by parameterizing them with variables
+
+5. **Explore the schema**: Use the GraphQL Playground's "Docs" panel to see all available queries and fields

LICENSE

@@ -0,0 +1,36 @@
+MIT License
+
+Copyright (c) 2025 Cancer@Home Contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+
+---
+
+This project is inspired by:
+- Cancer@Home v1 (HeroX DCx Challenge)
+- Andrew Kamal's Neo4j Cancer Visualization Dashboard
+
+Data sources:
+- Genomic Data Commons (GDC) Portal: https://portal.gdc.cancer.gov/
+- The Cancer Genome Atlas (TCGA)
+- Therapeutically Applicable Research to Generate Effective Treatments (TARGET)
+
+For data usage and citation requirements, please refer to:
+- GDC Data Policies: https://gdc.cancer.gov/about-gdc/gdc-policies
+- TCGA Publication Guidelines

MODEL_CARD.md

@@ -0,0 +1,373 @@
+---
+license: mit
+tags:
+- cancer-genomics
+- bioinformatics
+- graph-database
+- neo4j
+- distributed-computing
+- boinc
+- healthcare
+- genomics
+- fastq
+- blast
+- variant-calling
+- gdc-portal
+- tcga
+library_name: fastapi
+pipeline_tag: other
+---
+
+# Cancer@Home v2
+
+<div align="center">
+  <img src="https://img.shields.io/badge/version-2.0.0-blue.svg" alt="Version">
+  <img src="https://img.shields.io/badge/license-MIT-green.svg" alt="License">
+  <img src="https://img.shields.io/badge/python-3.8+-blue.svg" alt="Python">
+  <img src="https://img.shields.io/badge/neo4j-5.13-brightgreen.svg" alt="Neo4j">
+</div>
+
+## 🧬 Overview
+
+Cancer@Home v2 is a comprehensive distributed computing platform for cancer genomics research that combines **BOINC distributed computing**, **GDC cancer data analysis**, **sequence processing (FASTQ/BLAST)**, and **Neo4j graph visualization** into a unified, easy-to-use system.
+
+Inspired by [Cancer@Home v1](https://www.herox.com/DCx/round/516/entry/23285) and [Andrew Kamal's Neo4j Dashboard](https://medium.com/neo4j/visualize-cancer-1c80a95f5bb4), this platform makes cancer genomics research accessible, distributed, and visual.
+
+## 🎯 Key Features
+
+- 🌐 **Interactive Web Dashboard** - Modern UI with real-time visualizations
+- 🔍 **Neo4j Graph Database** - Model complex gene-mutation-patient relationships
+- ⚡ **BOINC Integration** - Distributed computing for intensive analyses
+- 📊 **GraphQL API** - Flexible data querying
+- 🧪 **Bioinformatics Pipeline** - FASTQ processing, BLAST alignment, variant calling
+- 📚 **GDC Portal Integration** - Access TCGA/TARGET cancer datasets
+- 🚀 **Quick Setup** - Running in under 5 minutes
+
+## 🏗️ Architecture
+
+```
+┌─────────────────────────────────────────────┐
+│     Web Dashboard (D3.js + Chart.js)        │
+├─────────────────────────────────────────────┤
+│     FastAPI Backend (REST + GraphQL)        │
+├──────┬──────┬──────┬──────┬────────────────┤
+│Neo4j │BOINC │ GDC  │FASTQ │ BLAST/Variant  │
+│Graph │Client│ API  │  QC  │    Calling     │
+└──────┴──────┴──────┴──────┴────────────────┘
+```
+
+## 📦 Installation
+
+### Prerequisites
+- Python 3.8+
+- Docker Desktop
+- 8GB RAM (16GB recommended)
+
+### Quick Start
+
+**Windows:**
+```powershell
+git clone https://huggingface.co/OpenPeerAI/CancerAtHomeV2
+cd CancerAtHomeV2
+.\setup.ps1
+python run.py
+```
+
+**Linux/Mac:**
+```bash
+git clone https://huggingface.co/OpenPeerAI/CancerAtHomeV2
+cd CancerAtHomeV2
+chmod +x setup.sh
+./setup.sh
+python run.py
+```
+
+Then open: **http://localhost:5000**
+
+## 🚀 Usage
+
+### Web Dashboard
+Access the interactive dashboard at http://localhost:5000 with:
+- **Dashboard Tab**: Overview statistics and mutation charts
+- **Neo4j Visualization**: Interactive graph of cancer relationships
+- **BOINC Tasks**: Submit and monitor distributed computing tasks
+- **GDC Data**: Browse and download cancer datasets
+- **Pipeline Tools**: Run FASTQ QC, BLAST, and variant calling
+
+### GraphQL API
+
+Query cancer data at http://localhost:5000/graphql
+
+**Example: Get mutations in TP53 gene**
+```graphql
+query {
+  mutations(gene: "TP53") {
+    mutation_id
+    chromosome
+    position
+    consequence
+  }
+}
+```
+
+**Example: Get patient statistics**
+```graphql
+query {
+  cancerStatistics(cancer_type_id: "BRCA") {
+    total_patients
+    total_mutations
+    avg_mutations_per_patient
+  }
+}
+```
+
+### REST API
+
+**Database Summary:**
+```bash
+curl http://localhost:5000/api/neo4j/summary
+```
+
+**Submit BOINC Task:**
+```bash
+curl -X POST http://localhost:5000/api/boinc/submit \
+  -H "Content-Type: application/json" \
+  -d '{"workunit_type": "variant_calling", "input_file": "sample.fastq"}'
+```
+
+### Python API
+
+**FASTQ Processing:**
+```python
+from backend.pipeline import FASTQProcessor
+
+processor = FASTQProcessor()
+stats = processor.calculate_statistics("input.fastq")
+filtered = processor.quality_filter("input.fastq")
+```
+
+**Variant Calling:**
+```python
+from backend.pipeline import VariantCaller, VariantAnalyzer
+
+caller = VariantCaller()
+vcf_file = caller.call_variants("alignment.bam", "reference.fa")
+variants = caller.filter_variants(vcf_file)
+
+analyzer = VariantAnalyzer()
+cancer_variants = analyzer.identify_cancer_variants(variants)
+tmb = analyzer.calculate_mutation_burden(variants)
+```
+
+**Neo4j Queries:**
+```python
+from backend.neo4j import DatabaseManager
+
+db = DatabaseManager()
+query = """
+MATCH (g:Gene {symbol: 'TP53'})<-[:AFFECTS]-(m:Mutation)
+RETURN m.position, m.consequence
+"""
+results = db.execute_query(query)
+db.close()
+```
+
+## 📊 Data Model
+
+### Neo4j Graph Schema
+
+**Nodes:**
+- **Gene**: Genes with mutations (TP53, BRCA1, KRAS, etc.)
+- **Mutation**: Genetic variants with position and consequence
+- **Patient**: Individual cases with demographics
+- **CancerType**: Cancer classifications (BRCA, LUAD, COAD, GBM)
+
+**Relationships:**
+- `Gene ← AFFECTS ← Mutation`
+- `Patient → HAS_MUTATION → Mutation`
+- `Patient → DIAGNOSED_WITH → CancerType`
+
+### Sample Data Included
+
+- **7 Genes**: TP53, BRAF, BRCA1, BRCA2, PIK3CA, KRAS, EGFR
+- **5 Mutations**: Cancer-associated variants
+- **5 Patients**: Representative TCGA cases
+- **4 Cancer Types**: BRCA, LUAD, COAD, GBM
+
+## 🔧 Technology Stack
+
+- **Backend**: FastAPI, Python 3.8+
+- **Database**: Neo4j 5.13 (Graph Database)
+- **API**: GraphQL (Strawberry), REST
+- **Frontend**: HTML5, CSS3, JavaScript, D3.js, Chart.js
+- **Bioinformatics**: Biopython, BLAST+
+- **Data Source**: GDC Portal API (TCGA/TARGET)
+- **Infrastructure**: Docker, Docker Compose
+- **Distributed Computing**: BOINC Framework
+
+## 📚 Documentation
+
+- [README.md](README.md) - Complete project overview
+- [QUICKSTART.md](QUICKSTART.md) - 5-minute setup guide
+- [USER_GUIDE.md](USER_GUIDE.md) - Detailed usage documentation
+- [GRAPHQL_EXAMPLES.md](GRAPHQL_EXAMPLES.md) - Query examples
+- [ARCHITECTURE.md](ARCHITECTURE.md) - System architecture
+- [PROJECT_SUMMARY.md](PROJECT_SUMMARY.md) - Feature overview
+
+## 🎓 Use Cases
+
+1. **Cancer Research**: Analyze genomics data with distributed computing
+2. **Education**: Learn cancer genetics and bioinformatics
+3. **Data Visualization**: Explore gene-mutation-patient relationships
+4. **Pipeline Development**: Test bioinformatics workflows
+5. **Graph Analytics**: Query complex biological networks
+
+## 🔬 Supported Cancer Projects
+
+- **TCGA-BRCA**: Breast Cancer (1,098 cases)
+- **TCGA-LUAD**: Lung Adenocarcinoma (585 cases)
+- **TCGA-COAD**: Colon Adenocarcinoma (461 cases)
+- **TCGA-GBM**: Glioblastoma (617 cases)
+- **TARGET-AML**: Acute Myeloid Leukemia (238 cases)
+
+## 📈 Bioinformatics Pipeline
+
+### FASTQ Processing
+- Quality control and filtering
+- Adapter trimming
+- Statistics calculation
+- QC report generation
+
+### BLAST Alignment
+- BLASTN for nucleotide sequences
+- BLASTP for protein sequences
+- Hit filtering by identity/e-value
+- Homology detection
+
+### Variant Calling
+- VCF generation from alignments
+- Quality filtering
+- Cancer variant identification
+- Tumor mutation burden (TMB) calculation
+
+## 🌐 Access Points
+
+- **Application**: http://localhost:5000
+- **API Docs**: http://localhost:5000/docs (Swagger UI)
+- **GraphQL**: http://localhost:5000/graphql
+- **Neo4j Browser**: http://localhost:7474 (neo4j/cancer123)
+
+## 🛠️ Configuration
+
+Edit `config.yml` to customize:
+
+```yaml
+neo4j:
+  uri: "bolt://localhost:7687"
+  password: "cancer123"
+
+gdc:
+  download_dir: "./data/gdc"
+  projects: ["TCGA-BRCA", "TCGA-LUAD", "TCGA-COAD"]
+
+pipeline:
+  fastq:
+    quality_threshold: 20
+    min_length: 50
+  blast:
+    evalue: 0.001
+    num_threads: 4
+```
+
+## 🤝 Contributing
+
+Contributions are welcome! This project is open source under the MIT License.
+
+### Development Setup
+```bash
+python -m venv venv
+source venv/bin/activate  # or venv\Scripts\activate on Windows
+pip install -r requirements.txt
+pytest test_cancer_at_home.py
+```
+
+## 📄 License
+
+MIT License - See [LICENSE](LICENSE) file
+
+Copyright (c) 2025 OpenPeer AI, Riemann Computing Inc., Bleunomics, Andrew Magdy Kamal
+
+## 🙏 Acknowledgments
+
+### Inspiration
+- [Cancer@Home v1](https://www.herox.com/DCx/round/516/entry/23285) - HeroX DCx Challenge
+- [Andrew Kamal's Neo4j Cancer Visualization](https://medium.com/neo4j/visualize-cancer-1c80a95f5bb4)
+
+### Data Sources
+- [Genomic Data Commons (GDC) Portal](https://portal.gdc.cancer.gov/)
+- The Cancer Genome Atlas (TCGA) Program
+- Therapeutically Applicable Research to Generate Effective Treatments (TARGET)
+
+### Technologies
+- Neo4j Graph Database
+- BOINC Distributed Computing Project
+- Biopython Community
+- FastAPI Framework
+
+## 👥 Authors
+
+- **OpenPeer AI** - Core development and architecture
+- **Riemann Computing Inc.** - Distributed computing integration
+- **Bleunomics** - Bioinformatics pipeline and genomics expertise
+- **Andrew Magdy Kamal** - Graph database design and visualization
+
+## 📞 Support
+
+- **Documentation**: See project documentation files
+- **Issues**: Check logs in `logs/cancer_at_home.log`
+- **Configuration**: Review `config.yml`
+- **Health Check**: http://localhost:5000/api/health
+
+## 🔮 Roadmap
+
+### Planned Features
+- Machine learning for mutation prediction
+- Multi-omics data integration (RNA-seq, proteomics)
+- Survival analysis and clinical outcomes
+- Advanced graph algorithms (PageRank, community detection)
+- Cloud deployment support (AWS, Azure, GCP)
+- Mobile-responsive design
+- User authentication and authorization
+
+## 📊 Statistics
+
+- **Lines of Code**: ~5,000+
+- **Modules**: 9 Python modules
+- **API Endpoints**: 15+ REST + GraphQL
+- **Documentation**: 2,500+ lines
+- **Setup Time**: < 5 minutes
+- **Sample Data**: 7 genes, 5 mutations, 5 patients
+
+## 🎯 Citation
+
+If you use Cancer@Home v2 in your research, please cite:
+
+```bibtex
+@software{cancer_at_home_v2,
+  title = {Cancer@Home v2: Distributed Cancer Genomics Research Platform},
+  author = {OpenPeer AI and Riemann Computing Inc. and Bleunomics and Andrew Magdy Kamal},
+  year = {2025},
+  url = {https://huggingface.co/OpenPeerAI/CancerAtHomeV2},
+  license = {MIT}
+}
+```
+
+## 🏷️ Tags
+
+`cancer-genomics` `bioinformatics` `neo4j` `graph-database` `distributed-computing` `boinc` `fastq` `blast` `variant-calling` `gdc-portal` `tcga` `target` `graphql` `fastapi` `python` `docker` `healthcare` `precision-medicine` `computational-biology`
+
+---
+
+**Made with ❤️ by OpenPeer AI, Riemann Computing Inc., Bleunomics, and Andrew Magdy Kamal**
+
+**For cancer research, by researchers, accessible to all.**

PROJECT_SUMMARY.md

@@ -0,0 +1,234 @@
+# Cancer@Home v2 - Project Summary
+
+## 🎯 Project Overview
+
+Cancer@Home v2 is a comprehensive distributed computing platform for cancer genomics research that successfully integrates:
+
+1. **Distributed Computing (BOINC)** - Submit and manage computationally intensive cancer research tasks
+2. **Cancer Data Portal (GDC)** - Access and download cancer genomics datasets from TCGA and TARGET
+3. **Graph Database (Neo4j)** - Model complex relationships between genes, mutations, patients, and cancer types
+4. **Bioinformatics Pipeline** - Process FASTQ files, run BLAST searches, and call genetic variants
+5. **Interactive Dashboard** - Web-based GUI with real-time visualizations and data exploration
+
+## 📁 Project Structure
+
+```
+CancerAtHome2/
+├── backend/
+│   ├── api/
+│   │   └── main.py                 # FastAPI application with REST & GraphQL
+│   ├── boinc/
+│   │   └── client.py               # BOINC distributed computing client
+│   ├── gdc/
+│   │   └── client.py               # GDC Portal API integration
+│   ├── neo4j/
+│   │   ├── db_manager.py          # Neo4j database operations
+│   │   ├── graphql_schema.py      # GraphQL schema definitions
+│   │   └── data_importer.py       # Sample data initialization
+│   └── pipeline/
+│       ├── fastq_processor.py     # FASTQ quality control
+│       ├── blast_runner.py        # BLAST sequence alignment
+│       └── variant_caller.py      # Genetic variant identification
+├── frontend/
+│   └── index.html                 # Interactive web dashboard
+├── config.yml                     # Configuration file
+├── docker-compose.yml             # Neo4j container setup
+├── requirements.txt               # Python dependencies
+├── run.py                         # Main application launcher
+├── setup.ps1                      # Windows setup script
+├── setup.sh                       # Linux/Mac setup script
+├── README.md                      # Comprehensive documentation
+├── QUICKSTART.md                  # Quick start guide
+├── USER_GUIDE.md                  # Detailed user guide
+├── GRAPHQL_EXAMPLES.md            # GraphQL query examples
+└── LICENSE                        # MIT License
+
+```
+
+## 🚀 Key Features Implemented
+
+### 1. Web Dashboard
+- **Modern UI**: Clean, gradient-based design with responsive layout
+- **5 Main Tabs**: Dashboard, Neo4j Visualization, BOINC Tasks, GDC Data, Pipeline
+- **Real-time Statistics**: Live data from Neo4j showing genes, mutations, patients
+- **Interactive Charts**: Chart.js visualizations for mutation distributions
+- **D3.js Graph**: Interactive network visualization of cancer genomics relationships
+
+### 2. Neo4j Graph Database
+- **Node Types**: Gene, Mutation, Patient, CancerType
+- **Relationships**: 
+  - Gene ← AFFECTS ← Mutation
+  - Patient → HAS_MUTATION → Mutation
+  - Patient → DIAGNOSED_WITH → CancerType
+- **Sample Data**: Pre-loaded with 7 genes, 5 mutations, 5 patients, 4 cancer types
+- **Optimized**: Constraints and indexes for fast queries
+
+### 3. GraphQL API
+- **Flexible Queries**: Get genes, mutations, patients, cancer types
+- **Filtering**: Query by gene symbol, chromosome, project ID, cancer type
+- **Aggregations**: Mutation frequency, cancer statistics
+- **Playground**: Interactive GraphQL explorer at /graphql
+
+### 4. REST API Endpoints
+- `/api/health` - System health check
+- `/api/neo4j/summary` - Database statistics
+- `/api/neo4j/genes/{symbol}` - Gene information
+- `/api/boinc/tasks` - List BOINC tasks
+- `/api/boinc/submit` - Submit new task
+- `/api/boinc/statistics` - Task statistics
+- `/api/gdc/projects` - Available cancer projects
+- `/api/gdc/files/{project_id}` - Search GDC files
+- `/api/gdc/download` - Download GDC data
+- `/api/pipeline/*` - Bioinformatics pipeline endpoints
+
+### 5. BOINC Integration
+- **Task Submission**: Support for variant calling, BLAST, alignment tasks
+- **Status Tracking**: Monitor pending, running, completed, failed tasks
+- **Statistics**: Total tasks, completion rates, average times
+- **Task Manager**: High-level interface for common workflows
+
+### 6. GDC Data Integration
+- **Search API**: Query files by project, data type, experimental strategy
+- **Download**: Retrieve cancer genomics datasets
+- **Projects Supported**: TCGA-BRCA, TCGA-LUAD, TCGA-COAD, TCGA-GBM, TARGET-AML
+- **Parsers**: MAF, VCF, and clinical data parsing utilities
+
+### 7. Bioinformatics Pipeline
+- **FASTQ Processing**:
+  - Quality filtering
+  - Adapter trimming
+  - Statistics calculation
+  - Quality control reports
+  
+- **BLAST Integration**:
+  - BLASTN and BLASTP support
+  - XML output parsing
+  - Hit filtering by identity/e-value
+  
+- **Variant Calling**:
+  - VCF generation
+  - Quality filtering
+  - Variant annotation
+  - Cancer variant identification
+  - Tumor mutation burden calculation
+
+## 🛠️ Technology Stack
+
+- **Backend**: FastAPI (Python 3.8+)
+- **Database**: Neo4j 5.13 (Graph Database)
+- **API**: GraphQL (Strawberry), REST
+- **Frontend**: HTML5, CSS3, JavaScript
+- **Visualization**: D3.js, Chart.js
+- **Bioinformatics**: Biopython
+- **Data Source**: GDC Portal API
+- **Containerization**: Docker, Docker Compose
+- **Distributed Computing**: BOINC framework
+
+## 📊 Sample Data Included
+
+### Genes (7)
+- TP53 (Tumor protein p53)
+- BRAF (B-Raf proto-oncogene)
+- BRCA1, BRCA2 (Breast cancer genes)
+- PIK3CA, KRAS, EGFR (Oncogenes)
+
+### Mutations (5)
+- Various missense mutations in cancer-associated genes
+- Includes position, reference/alternate alleles, quality scores
+
+### Patients (5)
+- Representative cases from TCGA-BRCA, TCGA-LUAD, TCGA-COAD
+- Demographic data, vital status
+
+### Cancer Types (4)
+- Breast Cancer (BRCA)
+- Lung Adenocarcinoma (LUAD)
+- Colon Adenocarcinoma (COAD)
+- Glioblastoma (GBM)
+
+## 🎨 Design Principles
+
+1. **Simplicity**: One-command setup, intuitive interface
+2. **Speed**: Fast to install and get started (< 5 minutes)
+3. **Modularity**: Clean separation of concerns
+4. **Extensibility**: Easy to add new data sources and analyses
+5. **Visual**: Rich visualizations for data exploration
+6. **Professional**: Production-quality code with error handling
+
+## 🔧 Configuration Options
+
+All configurable via `config.yml`:
+- Neo4j connection settings
+- GDC API parameters
+- BOINC server configuration
+- Pipeline quality thresholds
+- Output directories
+- Logging levels
+
+## 📖 Documentation Provided
+
+1. **README.md** - Complete project overview and installation
+2. **QUICKSTART.md** - Fast setup and first steps
+3. **USER_GUIDE.md** - Comprehensive usage documentation
+4. **GRAPHQL_EXAMPLES.md** - GraphQL query examples
+5. **Inline Code Comments** - Well-documented Python modules
+6. **API Documentation** - Auto-generated Swagger UI at /docs
+
+## 🌟 Unique Features
+
+1. **All-in-One Solution**: Complete stack from data acquisition to visualization
+2. **Graph-Based**: Leverages Neo4j's power for complex relationship queries
+3. **Real-Time**: Live dashboard updates and task monitoring
+4. **Research-Ready**: Built for actual cancer genomics research workflows
+5. **Extensible**: Easy to integrate additional data sources and tools
+6. **Educational**: Great for learning cancer genomics and graph databases
+
+## 🚦 Getting Started (Quick)
+
+```bash
+# Windows
+.\setup.ps1
+python run.py
+
+# Linux/Mac
+./setup.sh
+python run.py
+
+# Open browser
+http://localhost:5000
+```
+
+## 🎯 Use Cases
+
+1. **Research**: Analyze cancer genomics data with distributed computing
+2. **Education**: Learn about cancer genetics and bioinformatics
+3. **Visualization**: Explore gene-mutation-patient relationships
+4. **Data Integration**: Combine multiple cancer data sources
+5. **Pipeline Development**: Test bioinformatics workflows
+
+## 🔮 Future Enhancements (Optional)
+
+- Machine learning for mutation prediction
+- Multi-omics data integration (RNA-seq, proteomics)
+- Survival analysis and clinical outcomes
+- Drug response prediction
+- Advanced graph algorithms (PageRank, community detection)
+- Real-time collaboration features
+- Mobile responsive design
+- Export/report generation
+
+## 📝 License
+
+MIT License - Free for academic and commercial use
+
+## 🙏 Acknowledgments
+
+Inspired by:
+- Cancer@Home v1 (HeroX DCx Challenge)
+- Andrew Kamal's Neo4j Cancer Visualization
+- GDC Portal and TCGA Project
+- BOINC Distributed Computing Framework
+
+---
+
+**Cancer@Home v2** successfully combines modern web technologies, graph databases, distributed computing, and bioinformatics tools into a cohesive platform that is both powerful and easy to use. The system is production-ready, well-documented, and designed for real-world cancer genomics research.

QUICKSTART.md

@@ -0,0 +1,183 @@
+# Quick Start Guide
+
+## Prerequisites
+- Python 3.8 or higher
+- Docker Desktop
+- 8GB RAM minimum (16GB recommended)
+- Windows, macOS, or Linux
+
+## Installation
+
+### Windows
+```powershell
+# Run in PowerShell as Administrator
+.\setup.ps1
+```
+
+### Linux/Mac
+```bash
+chmod +x setup.sh
+./setup.sh
+```
+
+## Manual Installation
+
+1. **Create virtual environment**
+```bash
+python -m venv venv
+
+# Windows
+venv\Scripts\activate
+
+# Linux/Mac
+source venv/bin/activate
+```
+
+2. **Install dependencies**
+```bash
+pip install -r requirements.txt
+```
+
+3. **Start Neo4j**
+```bash
+docker-compose up -d
+```
+
+4. **Run application**
+```bash
+python run.py
+```
+
+## First Time Usage
+
+1. Open browser to http://localhost:5000
+2. The database will auto-initialize with sample data
+3. Explore the dashboard tabs:
+   - **Dashboard**: Overview statistics
+   - **Neo4j Visualization**: Interactive graph
+   - **BOINC Tasks**: Distributed computing
+   - **GDC Data**: Cancer genomics data
+   - **Analysis Pipeline**: Bioinformatics tools
+
+## GraphQL Queries
+
+Access GraphQL playground at: http://localhost:5000/graphql
+
+Example queries:
+
+```graphql
+# Get all genes
+query {
+  genes(limit: 10) {
+    symbol
+    name
+    chromosome
+  }
+}
+
+# Get mutations for a gene
+query {
+  mutations(gene: "TP53") {
+    chromosome
+    position
+    consequence
+  }
+}
+
+# Get patients with cancer type
+query {
+  patients(project_id: "TCGA-BRCA") {
+    patient_id
+    age
+    gender
+  }
+}
+```
+
+## API Examples
+
+### Submit BOINC Task
+```bash
+curl -X POST http://localhost:5000/api/boinc/submit \
+  -H "Content-Type: application/json" \
+  -d '{"workunit_type": "variant_calling", "input_file": "sample.fastq"}'
+```
+
+### Get Database Summary
+```bash
+curl http://localhost:5000/api/neo4j/summary
+```
+
+### Search GDC Files
+```bash
+curl http://localhost:5000/api/gdc/files/TCGA-BRCA?limit=10
+```
+
+## Troubleshooting
+
+### Docker not starting
+```bash
+# Check Docker status
+docker ps
+
+# Restart Docker containers
+docker-compose down
+docker-compose up -d
+```
+
+### Neo4j connection error
+1. Wait 30 seconds for Neo4j to fully start
+2. Check Neo4j Browser: http://localhost:7474
+3. Login: username=neo4j, password=cancer123
+
+### Python module errors
+```bash
+# Reinstall dependencies
+pip install --upgrade -r requirements.txt
+```
+
+## Configuration
+
+Edit `config.yml` to customize:
+- Neo4j connection
+- GDC API settings
+- BOINC configuration
+- Pipeline parameters
+
+## Data Sources
+
+### GDC Portal Projects
+- TCGA-BRCA: Breast Cancer
+- TCGA-LUAD: Lung Adenocarcinoma
+- TCGA-COAD: Colon Adenocarcinoma
+- TCGA-GBM: Glioblastoma
+- TARGET-AML: Acute Myeloid Leukemia
+
+### Sample Data
+The system includes sample data for demonstration:
+- 7 cancer-associated genes (TP53, BRAF, BRCA1, BRCA2, etc.)
+- 5 mutation records
+- 5 patient cases
+- 4 cancer types
+
+## Development
+
+### Run tests
+```bash
+pytest
+```
+
+### Format code
+```bash
+black backend/
+```
+
+### API Documentation
+http://localhost:5000/docs (Swagger UI)
+
+## Support
+
+For issues or questions:
+- Check logs: `logs/cancer_at_home.log`
+- Review configuration: `config.yml`
+- Consult README.md for detailed information

README.md

@@ -1,3 +1,172 @@
----
-license: mit
----
+# Cancer@Home v2
+
+A distributed computing platform for cancer genomics research, combining BOINC distributed computing, GDC cancer data analysis, sequence processing (FASTQ/BLAST), and Neo4j graph visualization.
+
+## 🚀 Quick Start (5 minutes)
+
+### Prerequisites
+- Python 3.8+
+- Docker Desktop
+- 8GB RAM minimum
+
+### Installation
+
+1. **Clone and setup**
+```bash
+cd CancerAtHome2
+python -m venv venv
+venv\Scripts\activate  # Windows
+pip install -r requirements.txt
+```
+
+2. **Start Neo4j Database**
+```bash
+docker-compose up -d
+```
+
+3. **Run the application**
+```bash
+python run.py
+```
+
+4. **Open your browser**
+- Application: http://localhost:5000
+- Neo4j Browser: http://localhost:7474 (username: neo4j, password: cancer123)
+
+## 🎯 Features
+
+### 1. **Distributed Computing (BOINC Integration)**
+- Submit cancer research computational tasks
+- Monitor distributed workload processing
+- Real-time task status tracking
+
+### 2. **GDC Data Integration**
+- Download cancer genomics data from GDC Portal
+- Support for various cancer types (TCGA, TARGET projects)
+- Automatic data parsing and normalization
+
+### 3. **Sequence Analysis Pipeline**
+- FASTQ file processing
+- BLAST sequence alignment
+- Variant calling and annotation
+
+### 4. **Neo4j Graph Database**
+- Graph-based cancer data modeling
+- Relationships: Gene → Mutation → Patient → Cancer Type
+- Interactive graph visualization
+
+### 5. **GraphQL API**
+- Query cancer data flexibly
+- Filter by gene, mutation, patient cohort
+- Aggregate statistics
+
+### 6. **Interactive Dashboard**
+- Real-time data visualization
+- Network graphs for gene interactions
+- Mutation frequency charts
+- Patient cohort analysis
+
+## 📊 Architecture
+
+```
+Cancer@Home v2
+│
+├── Frontend (React + D3.js)
+│   ├── Dashboard
+│   ├── Neo4j Visualization
+│   └── Task Monitor
+│
+├── Backend (FastAPI)
+│   ├── REST API
+│   ├── GraphQL Endpoint
+│   └── WebSocket (real-time updates)
+│
+├── Data Layer
+│   ├── Neo4j (Graph Database)
+│   ├── BOINC Client
+│   └── GDC API Client
+│
+└── Analysis Pipeline
+    ├── FASTQ Parser
+    ├── BLAST Wrapper
+    └── Variant Annotator
+```
+
+## 🗂️ Project Structure
+
+```
+CancerAtHome2/
+├── backend/
+│   ├── api/              # FastAPI routes
+│   ├── boinc/            # BOINC integration
+│   ├── gdc/              # GDC data fetcher
+│   ├── neo4j/            # Neo4j database layer
+│   ├── pipeline/         # Bioinformatics pipeline
+│   └── graphql/          # GraphQL schema
+├── frontend/
+│   ├── public/
+│   └── src/
+│       ├── components/   # React components
+│       ├── views/        # Page views
+│       └── api/          # API client
+├── data/                 # Downloaded datasets
+├── docker-compose.yml    # Neo4j container
+├── requirements.txt      # Python dependencies
+└── run.py               # Main entry point
+```
+
+## 🧬 Data Flow
+
+1. **Data Ingestion**: Download cancer genomics data from GDC Portal
+2. **Processing**: Run FASTQ/BLAST analysis on distributed BOINC network
+3. **Storage**: Store results in Neo4j graph database
+4. **Visualization**: Query and visualize via web dashboard
+
+## 🔧 Configuration
+
+Edit `config.yml` to customize:
+- Neo4j connection settings
+- GDC API parameters
+- BOINC project URL
+- Analysis pipeline options
+
+## 📖 Usage Examples
+
+### Query Mutations by Gene
+```graphql
+query {
+  mutations(gene: "TP53") {
+    id
+    position
+    consequence
+    patients {
+      cancerType
+      stage
+    }
+  }
+}
+```
+
+### Submit Analysis Task
+```python
+from backend.boinc import BOINCClient
+
+client = BOINCClient()
+task_id = client.submit_task(
+    workunit_type="variant_calling",
+    input_file="sample.fastq"
+)
+```
+
+## 🤝 Inspired By
+
+- [Cancer@Home v1](https://www.herox.com/DCx/round/516/entry/23285) - Distributed cancer research
+- [Neo4j Cancer Visualization](https://medium.com/neo4j/visualize-cancer-1c80a95f5bb4) - Graph-based cancer data modeling
+
+## 📄 License
+
+MIT License
+
+## 🛟 Support
+
+For issues or questions, please open a GitHub issue.

USER_GUIDE.md

@@ -0,0 +1,419 @@
+# Cancer@Home v2 - User Guide
+
+## Table of Contents
+1. [Introduction](#introduction)
+2. [System Architecture](#system-architecture)
+3. [Getting Started](#getting-started)
+4. [Dashboard Guide](#dashboard-guide)
+5. [Working with Data](#working-with-data)
+6. [Analysis Pipeline](#analysis-pipeline)
+7. [Advanced Usage](#advanced-usage)
+
+---
+
+## Introduction
+
+Cancer@Home v2 is a distributed computing platform for cancer genomics research that combines:
+- **BOINC**: Distributed computing for computationally intensive tasks
+- **GDC Portal**: Access to comprehensive cancer genomics datasets
+- **Neo4j**: Graph database for modeling complex relationships
+- **Bioinformatics Pipeline**: FASTQ processing, BLAST alignment, and variant calling
+
+### Key Features
+✓ Interactive web dashboard  
+✓ Real-time graph visualization  
+✓ GraphQL API for flexible data queries  
+✓ Distributed task processing  
+✓ Cancer genomics data integration  
+
+---
+
+## System Architecture
+
+```
+┌─────────────────────────────────────────────────┐
+│              Web Dashboard (Port 5000)          │
+│  Dashboard | Neo4j Viz | BOINC | GDC | Pipeline│
+└────────────────────┬────────────────────────────┘
+                     │
+┌────────────────────┴────────────────────────────┐
+│           FastAPI Backend (REST + GraphQL)      │
+└─────┬──────┬──────┬──────┬──────┬──────────────┘
+      │      │      │      │      │
+   ┌──┴─┐ ┌──┴─┐ ┌──┴─┐ ┌──┴─┐ ┌──┴──────┐
+   │Neo4j│ │BOINC│ │GDC │ │FASTQ│ │BLAST/VCF│
+   │7687 │ │Client│ │API │ │Proc │ │ Caller  │
+   └─────┘ └─────┘ └────┘ └─────┘ └─────────┘
+```
+
+---
+
+## Getting Started
+
+### Quick Installation (5 minutes)
+
+**Windows:**
+```powershell
+.\setup.ps1
+python run.py
+```
+
+**Linux/Mac:**
+```bash
+./setup.sh
+python run.py
+```
+
+### Access Points
+- **Main Application**: http://localhost:5000
+- **API Documentation**: http://localhost:5000/docs
+- **GraphQL Playground**: http://localhost:5000/graphql
+- **Neo4j Browser**: http://localhost:7474 (neo4j/cancer123)
+
+---
+
+## Dashboard Guide
+
+### 1. Overview Tab
+Shows key statistics:
+- Total genes in database
+- Total mutations identified
+- Number of patients
+- Cancer types catalogued
+
+**Chart**: Mutation distribution across cancer types
+
+### 2. Neo4j Visualization Tab
+Interactive graph showing:
+- **Blue nodes**: Genes (TP53, BRCA1, KRAS, etc.)
+- **Purple nodes**: Patients
+- **Pink nodes**: Cancer types
+- **Lines**: Relationships between entities
+
+**Navigation**:
+- Click and drag nodes to rearrange
+- Hover over nodes for details
+- Zoom in/out with mouse wheel
+
+### 3. BOINC Tasks Tab
+Manage distributed computing workloads:
+
+**Submit Task**:
+1. Select task type (Variant Calling, BLAST, Alignment)
+2. Enter input file path
+3. Click "Submit Task"
+
+**Monitor Tasks**:
+- View all tasks with status (Pending, Running, Completed)
+- See task creation time and type
+- Check overall statistics
+
+### 4. GDC Data Tab
+Browse available cancer projects:
+- TCGA-BRCA: Breast Cancer (1,098 cases)
+- TCGA-LUAD: Lung Adenocarcinoma (585 cases)
+- TCGA-COAD: Colon Adenocarcinoma (461 cases)
+- TCGA-GBM: Glioblastoma (617 cases)
+- TARGET-AML: Acute Myeloid Leukemia (238 cases)
+
+Click on a project to explore available datasets.
+
+### 5. Pipeline Tab
+Quick access to bioinformatics tools:
+- **FASTQ QC**: Quality control for sequencing data
+- **BLAST Search**: Sequence alignment and homology
+- **Variant Calling**: Identify genetic variants
+
+---
+
+## Working with Data
+
+### Querying with GraphQL
+
+Access the GraphQL playground at http://localhost:5000/graphql
+
+**Example 1: Find mutations in TP53 gene**
+```graphql
+query {
+  mutations(gene: "TP53") {
+    mutation_id
+    chromosome
+    position
+    consequence
+  }
+}
+```
+
+**Example 2: Get patient information**
+```graphql
+query {
+  patients(project_id: "TCGA-BRCA", limit: 10) {
+    patient_id
+    age
+    gender
+    vital_status
+  }
+}
+```
+
+**Example 3: Cancer statistics**
+```graphql
+query {
+  cancerStatistics(cancer_type_id: "BRCA") {
+    total_patients
+    total_mutations
+    avg_mutations_per_patient
+  }
+}
+```
+
+### Using the REST API
+
+**Get database summary:**
+```bash
+curl http://localhost:5000/api/neo4j/summary
+```
+
+**Search GDC files:**
+```bash
+curl "http://localhost:5000/api/gdc/files/TCGA-BRCA?limit=10"
+```
+
+**Submit BOINC task:**
+```bash
+curl -X POST http://localhost:5000/api/boinc/submit \
+  -H "Content-Type: application/json" \
+  -d '{"workunit_type": "variant_calling", "input_file": "data/sample.fastq"}'
+```
+
+---
+
+## Analysis Pipeline
+
+### 1. FASTQ Processing
+
+**Quality Control:**
+```python
+from backend.pipeline import FASTQProcessor
+
+processor = FASTQProcessor()
+stats = processor.calculate_statistics("input.fastq")
+print(f"Total reads: {stats['total_reads']}")
+print(f"Average quality: {stats['avg_quality']}")
+```
+
+**Filter by quality:**
+```python
+filtered = processor.quality_filter("input.fastq", "filtered.fastq")
+print(f"Pass rate: {filtered['pass_rate']:.2%}")
+```
+
+### 2. BLAST Alignment
+
+**Run BLAST search:**
+```python
+from backend.pipeline import BLASTRunner
+
+blast = BLASTRunner()
+results = blast.run_blastn("query.fasta")
+hits = blast.parse_results(results)
+
+print(f"Found {len(hits)} alignments")
+```
+
+**Filter high-quality hits:**
+```python
+filtered_hits = blast.filter_hits(hits, min_identity=0.95)
+```
+
+### 3. Variant Calling
+
+**Identify variants:**
+```python
+from backend.pipeline import VariantCaller
+
+caller = VariantCaller()
+vcf_file = caller.call_variants("alignment.bam", "reference.fa")
+variants = caller.filter_variants(vcf_file, min_quality=30)
+
+print(f"Identified {len(variants)} high-quality variants")
+```
+
+**Find cancer-associated variants:**
+```python
+from backend.pipeline import VariantAnalyzer
+
+analyzer = VariantAnalyzer()
+cancer_variants = analyzer.identify_cancer_variants(variants)
+tmb = analyzer.calculate_mutation_burden(variants)
+
+print(f"Cancer variants: {len(cancer_variants)}")
+print(f"Tumor Mutation Burden: {tmb:.2f} mutations/Mb")
+```
+
+---
+
+## Advanced Usage
+
+### Custom Neo4j Queries
+
+**Direct Cypher queries:**
+```python
+from backend.neo4j import DatabaseManager
+
+db = DatabaseManager()
+
+# Find patients with TP53 mutations
+query = """
+MATCH (p:Patient)-[:HAS_MUTATION]->(m:Mutation)-[:AFFECTS]->(g:Gene {symbol: 'TP53'})
+RETURN p.patient_id, m.position, m.consequence
+"""
+
+results = db.execute_query(query)
+for result in results:
+    print(result)
+
+db.close()
+```
+
+### Batch Data Import
+
+**Import GDC data:**
+```python
+from backend.gdc import GDCClient
+from backend.neo4j import DataImporter
+
+# Download mutation data
+gdc = GDCClient()
+files = gdc.get_mutation_data("TCGA-BRCA", limit=10)
+
+for file in files:
+    gdc.download_file(file.file_id)
+
+# Import to Neo4j
+importer = DataImporter()
+importer.import_gdc_data(files)
+```
+
+### Custom BOINC Tasks
+
+**Submit custom analysis:**
+```python
+from backend.boinc import BOINCClient
+
+client = BOINCClient()
+
+# Submit multiple tasks
+input_files = ["sample1.fastq", "sample2.fastq", "sample3.fastq"]
+task_ids = []
+
+for file in input_files:
+    task_id = client.submit_task("variant_calling", file)
+    task_ids.append(task_id)
+
+# Monitor progress
+for task_id in task_ids:
+    status = client.get_task_status(task_id)
+    print(f"Task {task_id}: {status.status}")
+```
+
+### Configuration Customization
+
+Edit `config.yml`:
+
+```yaml
+neo4j:
+  uri: "bolt://localhost:7687"
+  password: "your_password"
+
+gdc:
+  download_dir: "./data/gdc"
+  max_retries: 3
+
+pipeline:
+  fastq:
+    quality_threshold: 25  # Increase quality threshold
+    min_length: 75         # Increase minimum read length
+  
+  blast:
+    evalue: 0.0001         # More stringent e-value
+    num_threads: 8         # Use more CPU cores
+```
+
+---
+
+## Troubleshooting
+
+### Neo4j Connection Issues
+```bash
+# Check Neo4j status
+docker ps | grep neo4j
+
+# Restart Neo4j
+docker-compose restart neo4j
+
+# View Neo4j logs
+docker-compose logs neo4j
+```
+
+### Memory Issues
+Increase Docker memory allocation:
+1. Open Docker Desktop Settings
+2. Resources → Memory
+3. Increase to at least 8GB
+4. Click "Apply & Restart"
+
+### API Errors
+Check logs:
+```bash
+# View application logs
+cat logs/cancer_at_home.log
+
+# Follow logs in real-time
+tail -f logs/cancer_at_home.log
+```
+
+---
+
+## Best Practices
+
+1. **Data Management**: Regularly clean up downloaded data to free space
+2. **Task Monitoring**: Check BOINC tasks periodically for failures
+3. **Database Backup**: Backup Neo4j data volume regularly
+4. **Resource Limits**: Monitor system resources when running large analyses
+5. **API Rate Limits**: Be mindful of GDC API rate limits for bulk downloads
+
+---
+
+## Support & Resources
+
+- **Documentation**: See README.md and QUICKSTART.md
+- **API Reference**: http://localhost:5000/docs
+- **GraphQL Examples**: See GRAPHQL_EXAMPLES.md
+- **Logs**: Check `logs/cancer_at_home.log`
+
+### Useful Cypher Queries
+
+**Most common mutations:**
+```cypher
+MATCH (m:Mutation)<-[:HAS_MUTATION]-(p:Patient)
+WITH m, count(p) as patient_count
+RETURN m.mutation_id, patient_count
+ORDER BY patient_count DESC
+LIMIT 10
+```
+
+**Genes with most mutations:**
+```cypher
+MATCH (g:Gene)<-[:AFFECTS]-(m:Mutation)
+WITH g, count(m) as mutation_count
+RETURN g.symbol, mutation_count
+ORDER BY mutation_count DESC
+LIMIT 10
+```
+
+**Patient mutation profile:**
+```cypher
+MATCH (p:Patient {patient_id: 'TCGA-A1-001'})-[:HAS_MUTATION]->(m:Mutation)-[:AFFECTS]->(g:Gene)
+RETURN g.symbol, m.consequence, m.position
+```

backend/__init__.py

@@ -0,0 +1,5 @@
+"""
+Backend Module
+"""
+
+__version__ = "2.0.0"

backend/api/__init__.py

@@ -0,0 +1,7 @@
+"""
+Backend API Module
+"""
+
+from .main import app
+
+__all__ = ['app']

backend/api/main.py

@@ -0,0 +1,317 @@
+"""
+FastAPI Main Application
+Backend API for Cancer@Home
+"""
+
+from fastapi import FastAPI, HTTPException
+from fastapi.middleware.cors import CORSMiddleware
+from fastapi.staticfiles import StaticFiles
+from fastapi.responses import HTMLResponse
+from strawberry.fastapi import GraphQLRouter
+from pathlib import Path
+import uvicorn
+
+from backend.neo4j.graphql_schema import schema
+from backend.neo4j.db_manager import DatabaseManager
+from backend.boinc.client import BOINCClient, BOINCTaskManager
+from backend.gdc.client import GDCClient
+from backend.pipeline import (
+    FASTQProcessor,
+    BLASTRunner,
+    VariantCaller
+)
+
+# Initialize FastAPI
+app = FastAPI(
+    title="Cancer@Home v2",
+    description="Distributed cancer genomics research platform",
+    version="2.0.0"
+)
+
+# CORS middleware
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+# GraphQL endpoint
+graphql_app = GraphQLRouter(schema)
+app.include_router(graphql_app, prefix="/graphql")
+
+# Serve frontend static files
+frontend_path = Path("frontend/dist")
+if frontend_path.exists():
+    app.mount("/static", StaticFiles(directory=str(frontend_path)), name="static")
+
+
+@app.get("/", response_class=HTMLResponse)
+async def root():
+    """Serve main dashboard"""
+    html_file = Path("frontend/index.html")
+    if html_file.exists():
+        with open(html_file, 'r') as f:
+            return f.read()
+    
+    # Fallback HTML
+    return """
+    <!DOCTYPE html>
+    <html>
+    <head>
+        <title>Cancer@Home v2</title>
+        <style>
+            body {
+                font-family: 'Segoe UI', Tahoma, Geneva, Verdana, sans-serif;
+                margin: 0;
+                padding: 0;
+                background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
+                color: white;
+            }
+            .container {
+                max-width: 1200px;
+                margin: 0 auto;
+                padding: 40px 20px;
+            }
+            h1 {
+                font-size: 3em;
+                margin-bottom: 20px;
+            }
+            .card {
+                background: rgba(255, 255, 255, 0.1);
+                border-radius: 10px;
+                padding: 30px;
+                margin: 20px 0;
+                backdrop-filter: blur(10px);
+            }
+            .links {
+                display: grid;
+                grid-template-columns: repeat(auto-fit, minmax(250px, 1fr));
+                gap: 20px;
+                margin-top: 30px;
+            }
+            .link-card {
+                background: rgba(255, 255, 255, 0.15);
+                border-radius: 8px;
+                padding: 20px;
+                text-decoration: none;
+                color: white;
+                transition: transform 0.2s;
+            }
+            .link-card:hover {
+                transform: translateY(-5px);
+                background: rgba(255, 255, 255, 0.25);
+            }
+            .link-card h3 {
+                margin-top: 0;
+            }
+        </style>
+    </head>
+    <body>
+        <div class="container">
+            <h1>🧬 Cancer@Home v2</h1>
+            <div class="card">
+                <h2>Welcome to Cancer@Home</h2>
+                <p>A distributed computing platform for cancer genomics research</p>
+            </div>
+            
+            <div class="links">
+                <a href="/api/docs" class="link-card">
+                    <h3>📚 API Documentation</h3>
+                    <p>Interactive API docs with Swagger UI</p>
+                </a>
+                <a href="/graphql" class="link-card">
+                    <h3>🔍 GraphQL Playground</h3>
+                    <p>Query cancer data with GraphQL</p>
+                </a>
+                <a href="http://localhost:7474" class="link-card">
+                    <h3>📊 Neo4j Browser</h3>
+                    <p>Visualize graph database</p>
+                </a>
+                <a href="/api/health" class="link-card">
+                    <h3>💚 Health Check</h3>
+                    <p>Check system status</p>
+                </a>
+            </div>
+        </div>
+    </body>
+    </html>
+    """
+
+
+@app.get("/api/health")
+async def health_check():
+    """Health check endpoint"""
+    db = DatabaseManager()
+    try:
+        db.execute_query("RETURN 1")
+        neo4j_status = "healthy"
+    except Exception as e:
+        neo4j_status = f"unhealthy: {str(e)}"
+    finally:
+        db.close()
+    
+    return {
+        "status": "healthy",
+        "neo4j": neo4j_status,
+        "version": "2.0.0"
+    }
+
+
+# BOINC API Endpoints
+@app.get("/api/boinc/tasks")
+async def get_boinc_tasks(status: str = None):
+    """Get BOINC tasks"""
+    client = BOINCClient()
+    tasks = client.list_tasks(status=status)
+    return {"tasks": [vars(t) for t in tasks]}
+
+
+@app.post("/api/boinc/submit")
+async def submit_boinc_task(workunit_type: str, input_file: str):
+    """Submit new BOINC task"""
+    manager = BOINCTaskManager()
+    
+    if workunit_type == "variant_calling":
+        task_id = manager.submit_variant_calling(input_file)
+    elif workunit_type == "blast_search":
+        task_id = manager.submit_blast_search(input_file)
+    else:
+        task_id = manager.client.submit_task(workunit_type, input_file)
+    
+    return {"task_id": task_id, "status": "submitted"}
+
+
+@app.get("/api/boinc/statistics")
+async def get_boinc_statistics():
+    """Get BOINC statistics"""
+    client = BOINCClient()
+    stats = client.get_statistics()
+    return stats
+
+
+# GDC API Endpoints
+@app.get("/api/gdc/projects")
+async def get_gdc_projects():
+    """Get available GDC projects"""
+    projects = [
+        {"id": "TCGA-BRCA", "name": "Breast Cancer", "cases": 1098},
+        {"id": "TCGA-LUAD", "name": "Lung Adenocarcinoma", "cases": 585},
+        {"id": "TCGA-COAD", "name": "Colon Adenocarcinoma", "cases": 461},
+        {"id": "TCGA-GBM", "name": "Glioblastoma", "cases": 617},
+        {"id": "TARGET-AML", "name": "Acute Myeloid Leukemia", "cases": 238},
+    ]
+    return {"projects": projects}
+
+
+@app.get("/api/gdc/files/{project_id}")
+async def search_gdc_files(project_id: str, limit: int = 10):
+    """Search GDC files for a project"""
+    client = GDCClient()
+    files = client.get_project_files(project_id, limit=limit)
+    return {"files": [vars(f) for f in files]}
+
+
+@app.post("/api/gdc/download")
+async def download_gdc_file(file_id: str):
+    """Download a file from GDC"""
+    client = GDCClient()
+    file_path = client.download_file(file_id)
+    
+    if file_path:
+        return {"status": "success", "file_path": str(file_path)}
+    else:
+        raise HTTPException(status_code=500, detail="Download failed")
+
+
+# Pipeline API Endpoints
+@app.post("/api/pipeline/fastq/qc")
+async def run_fastq_qc(file_path: str):
+    """Run FASTQ quality control"""
+    processor = FASTQProcessor()
+    stats = processor.calculate_statistics(Path(file_path))
+    return {"statistics": stats}
+
+
+@app.post("/api/pipeline/blast")
+async def run_blast(query_file: str):
+    """Run BLAST search"""
+    runner = BLASTRunner()
+    output_file = runner.run_blastn(Path(query_file))
+    
+    if output_file:
+        hits = runner.parse_results(output_file)
+        return {
+            "status": "success",
+            "output_file": str(output_file),
+            "total_hits": len(hits),
+            "hits": hits[:10]  # Return first 10 hits
+        }
+    else:
+        raise HTTPException(status_code=500, detail="BLAST search failed")
+
+
+@app.post("/api/pipeline/variants")
+async def call_variants(alignment_file: str, reference_genome: str):
+    """Call variants from alignment"""
+    caller = VariantCaller()
+    vcf_file = caller.call_variants(
+        Path(alignment_file),
+        Path(reference_genome)
+    )
+    
+    variants = caller.filter_variants(vcf_file)
+    
+    return {
+        "status": "success",
+        "vcf_file": str(vcf_file),
+        "total_variants": len(variants),
+        "variants": [vars(v) for v in variants]
+    }
+
+
+# Neo4j Query Endpoints
+@app.get("/api/neo4j/summary")
+async def get_database_summary():
+    """Get database summary statistics"""
+    db = DatabaseManager()
+    
+    query = """
+    MATCH (g:Gene) WITH count(g) as genes
+    MATCH (m:Mutation) WITH genes, count(m) as mutations
+    MATCH (p:Patient) WITH genes, mutations, count(p) as patients
+    MATCH (c:CancerType) WITH genes, mutations, patients, count(c) as cancer_types
+    RETURN genes, mutations, patients, cancer_types
+    """
+    
+    result = db.execute_query(query)
+    db.close()
+    
+    return result[0] if result else {}
+
+
+@app.get("/api/neo4j/genes/{symbol}")
+async def get_gene_info(symbol: str):
+    """Get gene information"""
+    db = DatabaseManager()
+    from backend.neo4j.db_manager import GeneRepository
+    
+    repo = GeneRepository(db)
+    gene = repo.get_gene_by_symbol(symbol)
+    
+    if gene:
+        mutations = repo.get_gene_mutations(gene['gene_id'])
+        db.close()
+        return {
+            "gene": gene,
+            "mutations": mutations,
+            "mutation_count": len(mutations)
+        }
+    
+    db.close()
+    raise HTTPException(status_code=404, detail="Gene not found")
+
+
+if __name__ == "__main__":
+    uvicorn.run(app, host="0.0.0.0", port=5000)

backend/boinc/__init__.py

@@ -0,0 +1,8 @@
+"""
+BOINC Module
+Distributed computing integration for Cancer@Home
+"""
+
+from .client import BOINCClient, BOINCTaskManager, WorkUnit
+
+__all__ = ['BOINCClient', 'BOINCTaskManager', 'WorkUnit']

backend/boinc/client.py

@@ -0,0 +1,262 @@
+"""
+BOINC Client Integration
+Handles distributed computing task submission and monitoring
+"""
+
+import os
+import json
+import time
+import requests
+from typing import Dict, List, Optional
+from pathlib import Path
+from dataclasses import dataclass, asdict
+from datetime import datetime
+import yaml
+
+@dataclass
+class WorkUnit:
+    """Represents a BOINC work unit"""
+    id: str
+    name: str
+    workunit_type: str
+    input_file: str
+    status: str
+    created_at: str
+    completed_at: Optional[str] = None
+    result_file: Optional[str] = None
+    error: Optional[str] = None
+
+class BOINCClient:
+    """BOINC client for distributed computing integration"""
+    
+    def __init__(self, config_path: str = "config.yml"):
+        with open(config_path, 'r') as f:
+            self.config = yaml.safe_load(f)['boinc']
+        
+        self.project_url = self.config['project_url']
+        self.work_dir = Path(self.config['work_dir'])
+        self.work_dir.mkdir(parents=True, exist_ok=True)
+        
+        self.tasks_file = self.work_dir / "tasks.json"
+        self.tasks = self._load_tasks()
+    
+    def _load_tasks(self) -> Dict[str, WorkUnit]:
+        """Load existing tasks from disk"""
+        if self.tasks_file.exists():
+            with open(self.tasks_file, 'r') as f:
+                data = json.load(f)
+                return {k: WorkUnit(**v) for k, v in data.items()}
+        return {}
+    
+    def _save_tasks(self):
+        """Save tasks to disk"""
+        with open(self.tasks_file, 'w') as f:
+            data = {k: asdict(v) for k, v in self.tasks.items()}
+            json.dump(data, f, indent=2)
+    
+    def submit_task(
+        self,
+        workunit_type: str,
+        input_file: str,
+        name: Optional[str] = None
+    ) -> str:
+        """
+        Submit a new work unit to BOINC
+        
+        Args:
+            workunit_type: Type of analysis (variant_calling, blast_search, etc.)
+            input_file: Path to input data file
+            name: Optional custom name for the work unit
+        
+        Returns:
+            Work unit ID
+        """
+        task_id = f"wu_{int(time.time() * 1000)}"
+        
+        if name is None:
+            name = f"{workunit_type}_{task_id}"
+        
+        # Create work unit
+        work_unit = WorkUnit(
+            id=task_id,
+            name=name,
+            workunit_type=workunit_type,
+            input_file=input_file,
+            status="pending",
+            created_at=datetime.now().isoformat()
+        )
+        
+        # In a real implementation, this would submit to actual BOINC server
+        # For now, we simulate the submission
+        self._simulate_submission(work_unit)
+        
+        self.tasks[task_id] = work_unit
+        self._save_tasks()
+        
+        return task_id
+    
+    def _simulate_submission(self, work_unit: WorkUnit):
+        """
+        Simulate BOINC submission (for development/demo purposes)
+        In production, replace with actual BOINC API calls
+        """
+        # Create a work directory for this task
+        task_dir = self.work_dir / work_unit.id
+        task_dir.mkdir(exist_ok=True)
+        
+        # Copy input file
+        input_path = Path(work_unit.input_file)
+        if input_path.exists():
+            import shutil
+            shutil.copy(input_path, task_dir / input_path.name)
+        
+        # Create task metadata
+        metadata = {
+            "task_id": work_unit.id,
+            "type": work_unit.workunit_type,
+            "input": work_unit.input_file,
+            "submitted": work_unit.created_at
+        }
+        
+        with open(task_dir / "metadata.json", 'w') as f:
+            json.dump(metadata, f, indent=2)
+    
+    def get_task_status(self, task_id: str) -> Optional[WorkUnit]:
+        """Get status of a specific task"""
+        return self.tasks.get(task_id)
+    
+    def list_tasks(
+        self,
+        status: Optional[str] = None,
+        workunit_type: Optional[str] = None
+    ) -> List[WorkUnit]:
+        """
+        List all tasks with optional filtering
+        
+        Args:
+            status: Filter by status (pending, running, completed, failed)
+            workunit_type: Filter by work unit type
+        """
+        tasks = list(self.tasks.values())
+        
+        if status:
+            tasks = [t for t in tasks if t.status == status]
+        
+        if workunit_type:
+            tasks = [t for t in tasks if t.workunit_type == workunit_type]
+        
+        return sorted(tasks, key=lambda t: t.created_at, reverse=True)
+    
+    def update_task_status(self, task_id: str, status: str, **kwargs):
+        """Update task status and additional fields"""
+        if task_id in self.tasks:
+            self.tasks[task_id].status = status
+            
+            for key, value in kwargs.items():
+                if hasattr(self.tasks[task_id], key):
+                    setattr(self.tasks[task_id], key, value)
+            
+            if status == "completed":
+                self.tasks[task_id].completed_at = datetime.now().isoformat()
+            
+            self._save_tasks()
+    
+    def cancel_task(self, task_id: str) -> bool:
+        """Cancel a pending or running task"""
+        if task_id in self.tasks:
+            task = self.tasks[task_id]
+            if task.status in ["pending", "running"]:
+                task.status = "cancelled"
+                self._save_tasks()
+                return True
+        return False
+    
+    def get_results(self, task_id: str) -> Optional[Path]:
+        """Get results file for a completed task"""
+        if task_id in self.tasks:
+            task = self.tasks[task_id]
+            if task.status == "completed" and task.result_file:
+                result_path = Path(task.result_file)
+                if result_path.exists():
+                    return result_path
+        return None
+    
+    def get_statistics(self) -> Dict:
+        """Get overall statistics about BOINC tasks"""
+        total = len(self.tasks)
+        by_status = {}
+        by_type = {}
+        
+        for task in self.tasks.values():
+            by_status[task.status] = by_status.get(task.status, 0) + 1
+            by_type[task.workunit_type] = by_type.get(task.workunit_type, 0) + 1
+        
+        completed = [t for t in self.tasks.values() if t.completed_at]
+        
+        if completed:
+            avg_time = sum([
+                (datetime.fromisoformat(t.completed_at) - 
+                 datetime.fromisoformat(t.created_at)).total_seconds()
+                for t in completed
+            ]) / len(completed)
+        else:
+            avg_time = 0
+        
+        return {
+            "total_tasks": total,
+            "by_status": by_status,
+            "by_type": by_type,
+            "completed_tasks": len(completed),
+            "average_completion_time_seconds": avg_time
+        }
+
+
+class BOINCTaskManager:
+    """High-level task manager for common workflows"""
+    
+    def __init__(self):
+        self.client = BOINCClient()
+    
+    def submit_variant_calling(self, fastq_file: str) -> str:
+        """Submit variant calling task"""
+        return self.client.submit_task(
+            workunit_type="variant_calling",
+            input_file=fastq_file,
+            name=f"variant_calling_{Path(fastq_file).stem}"
+        )
+    
+    def submit_blast_search(self, sequence_file: str) -> str:
+        """Submit BLAST search task"""
+        return self.client.submit_task(
+            workunit_type="blast_search",
+            input_file=sequence_file,
+            name=f"blast_{Path(sequence_file).stem}"
+        )
+    
+    def submit_alignment(self, fastq_file: str) -> str:
+        """Submit sequence alignment task"""
+        return self.client.submit_task(
+            workunit_type="alignment",
+            input_file=fastq_file,
+            name=f"alignment_{Path(fastq_file).stem}"
+        )
+    
+    def submit_annotation(self, vcf_file: str) -> str:
+        """Submit variant annotation task"""
+        return self.client.submit_task(
+            workunit_type="annotation",
+            input_file=vcf_file,
+            name=f"annotation_{Path(vcf_file).stem}"
+        )
+    
+    def batch_submit(
+        self,
+        workunit_type: str,
+        input_files: List[str]
+    ) -> List[str]:
+        """Submit multiple tasks at once"""
+        task_ids = []
+        for input_file in input_files:
+            task_id = self.client.submit_task(workunit_type, input_file)
+            task_ids.append(task_id)
+        return task_ids

backend/gdc/__init__.py

@@ -0,0 +1,8 @@
+"""
+GDC Module
+Interface to GDC Cancer Data Portal
+"""
+
+from .client import GDCClient, GDCDataParser, GDCFile
+
+__all__ = ['GDCClient', 'GDCDataParser', 'GDCFile']

backend/gdc/client.py

@@ -0,0 +1,365 @@
+"""
+GDC Data Portal Client
+Download and parse cancer genomics data from GDC
+"""
+
+import os
+import json
+import requests
+from typing import Dict, List, Optional, Any
+from pathlib import Path
+import yaml
+from dataclasses import dataclass
+import logging
+
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+
+@dataclass
+class GDCFile:
+    """Represents a file from GDC Portal"""
+    file_id: str
+    file_name: str
+    file_size: int
+    data_type: str
+    data_format: str
+    experimental_strategy: str
+    case_id: str
+    project_id: str
+
+
+class GDCClient:
+    """Client for interacting with GDC Data Portal API"""
+    
+    def __init__(self, config_path: str = "config.yml"):
+        with open(config_path, 'r') as f:
+            self.config = yaml.safe_load(f)['gdc']
+        
+        self.api_url = self.config['api_url']
+        self.download_dir = Path(self.config['download_dir'])
+        self.download_dir.mkdir(parents=True, exist_ok=True)
+        
+        self.session = requests.Session()
+        self.session.headers.update({
+            'Content-Type': 'application/json'
+        })
+    
+    def search_files(
+        self,
+        filters: Optional[Dict] = None,
+        size: int = 100,
+        fields: Optional[List[str]] = None
+    ) -> List[GDCFile]:
+        """
+        Search for files in GDC
+        
+        Args:
+            filters: GDC filter query
+            size: Number of results to return
+            fields: Fields to include in response
+        """
+        endpoint = f"{self.api_url}/files"
+        
+        if fields is None:
+            fields = [
+                'file_id', 'file_name', 'file_size', 'data_type',
+                'data_format', 'experimental_strategy', 'cases.case_id',
+                'cases.project.project_id'
+            ]
+        
+        params = {
+            'size': size,
+            'fields': ','.join(fields)
+        }
+        
+        if filters:
+            params['filters'] = json.dumps(filters)
+        
+        try:
+            response = self.session.get(endpoint, params=params)
+            response.raise_for_status()
+            data = response.json()
+            
+            files = []
+            for hit in data.get('data', {}).get('hits', []):
+                gdc_file = GDCFile(
+                    file_id=hit.get('file_id'),
+                    file_name=hit.get('file_name'),
+                    file_size=hit.get('file_size', 0),
+                    data_type=hit.get('data_type'),
+                    data_format=hit.get('data_format'),
+                    experimental_strategy=hit.get('experimental_strategy'),
+                    case_id=hit.get('cases', [{}])[0].get('case_id') if hit.get('cases') else None,
+                    project_id=hit.get('cases', [{}])[0].get('project', {}).get('project_id') if hit.get('cases') else None
+                )
+                files.append(gdc_file)
+            
+            logger.info(f"Found {len(files)} files")
+            return files
+            
+        except Exception as e:
+            logger.error(f"Error searching files: {e}")
+            return []
+    
+    def download_file(
+        self,
+        file_id: str,
+        output_dir: Optional[Path] = None
+    ) -> Optional[Path]:
+        """
+        Download a file from GDC
+        
+        Args:
+            file_id: GDC file UUID
+            output_dir: Directory to save file (defaults to config download_dir)
+        
+        Returns:
+            Path to downloaded file or None if failed
+        """
+        if output_dir is None:
+            output_dir = self.download_dir
+        
+        output_dir = Path(output_dir)
+        output_dir.mkdir(parents=True, exist_ok=True)
+        
+        endpoint = f"{self.api_url}/data/{file_id}"
+        
+        try:
+            logger.info(f"Downloading file {file_id}")
+            response = self.session.get(endpoint, stream=True)
+            response.raise_for_status()
+            
+            # Get filename from headers
+            content_disposition = response.headers.get('content-disposition', '')
+            if 'filename=' in content_disposition:
+                filename = content_disposition.split('filename=')[1].strip('"')
+            else:
+                filename = file_id
+            
+            output_path = output_dir / filename
+            
+            with open(output_path, 'wb') as f:
+                for chunk in response.iter_content(chunk_size=8192):
+                    f.write(chunk)
+            
+            logger.info(f"Downloaded to {output_path}")
+            return output_path
+            
+        except Exception as e:
+            logger.error(f"Error downloading file {file_id}: {e}")
+            return None
+    
+    def get_project_files(
+        self,
+        project_id: str,
+        data_type: Optional[str] = None,
+        limit: int = 100
+    ) -> List[GDCFile]:
+        """
+        Get files for a specific project
+        
+        Args:
+            project_id: GDC project ID (e.g., TCGA-BRCA)
+            data_type: Filter by data type
+            limit: Maximum number of files
+        """
+        filters = {
+            "op": "and",
+            "content": [
+                {
+                    "op": "in",
+                    "content": {
+                        "field": "cases.project.project_id",
+                        "value": [project_id]
+                    }
+                }
+            ]
+        }
+        
+        if data_type:
+            filters["content"].append({
+                "op": "in",
+                "content": {
+                    "field": "data_type",
+                    "value": [data_type]
+                }
+            })
+        
+        return self.search_files(filters=filters, size=limit)
+    
+    def get_mutation_data(self, project_id: str, limit: int = 100) -> List[GDCFile]:
+        """Get mutation/variant calling files for a project"""
+        return self.get_project_files(
+            project_id=project_id,
+            data_type="Simple Nucleotide Variation",
+            limit=limit
+        )
+    
+    def get_gene_expression_data(self, project_id: str, limit: int = 100) -> List[GDCFile]:
+        """Get gene expression data for a project"""
+        return self.get_project_files(
+            project_id=project_id,
+            data_type="Gene Expression Quantification",
+            limit=limit
+        )
+    
+    def search_cases(
+        self,
+        project_id: str,
+        filters: Optional[Dict] = None,
+        size: int = 100
+    ) -> List[Dict]:
+        """
+        Search for cases (patients) in GDC
+        
+        Args:
+            project_id: GDC project ID
+            filters: Additional filter criteria
+            size: Number of results
+        """
+        endpoint = f"{self.api_url}/cases"
+        
+        base_filters = {
+            "op": "in",
+            "content": {
+                "field": "project.project_id",
+                "value": [project_id]
+            }
+        }
+        
+        if filters:
+            filter_query = {
+                "op": "and",
+                "content": [base_filters, filters]
+            }
+        else:
+            filter_query = base_filters
+        
+        params = {
+            'size': size,
+            'filters': json.dumps(filter_query),
+            'fields': 'case_id,project.project_id,demographic,diagnoses'
+        }
+        
+        try:
+            response = self.session.get(endpoint, params=params)
+            response.raise_for_status()
+            data = response.json()
+            
+            cases = data.get('data', {}).get('hits', [])
+            logger.info(f"Found {len(cases)} cases")
+            return cases
+            
+        except Exception as e:
+            logger.error(f"Error searching cases: {e}")
+            return []
+
+
+class GDCDataParser:
+    """Parse downloaded GDC data files"""
+    
+    @staticmethod
+    def parse_maf(file_path: Path) -> List[Dict]:
+        """
+        Parse MAF (Mutation Annotation Format) file
+        
+        Returns list of mutation records
+        """
+        mutations = []
+        
+        try:
+            with open(file_path, 'r') as f:
+                # Skip comment lines
+                for line in f:
+                    if not line.startswith('#'):
+                        header_line = line.strip()
+                        break
+                
+                headers = header_line.split('\t')
+                
+                for line in f:
+                    if line.startswith('#'):
+                        continue
+                    
+                    values = line.strip().split('\t')
+                    if len(values) == len(headers):
+                        mutation = dict(zip(headers, values))
+                        mutations.append(mutation)
+            
+            logger.info(f"Parsed {len(mutations)} mutations from {file_path}")
+            return mutations
+            
+        except Exception as e:
+            logger.error(f"Error parsing MAF file: {e}")
+            return []
+    
+    @staticmethod
+    def parse_vcf(file_path: Path) -> List[Dict]:
+        """
+        Parse VCF (Variant Call Format) file
+        
+        Returns list of variant records
+        """
+        variants = []
+        
+        try:
+            with open(file_path, 'r') as f:
+                for line in f:
+                    if line.startswith('##'):
+                        continue
+                    if line.startswith('#CHROM'):
+                        headers = line.strip().split('\t')
+                        continue
+                    
+                    values = line.strip().split('\t')
+                    variant = {
+                        'chrom': values[0],
+                        'pos': values[1],
+                        'id': values[2],
+                        'ref': values[3],
+                        'alt': values[4],
+                        'qual': values[5],
+                        'filter': values[6],
+                        'info': values[7]
+                    }
+                    variants.append(variant)
+            
+            logger.info(f"Parsed {len(variants)} variants from {file_path}")
+            return variants
+            
+        except Exception as e:
+            logger.error(f"Error parsing VCF file: {e}")
+            return []
+    
+    @staticmethod
+    def parse_clinical_data(data: Dict) -> Dict:
+        """Parse clinical data from GDC case"""
+        clinical = {
+            'case_id': data.get('case_id'),
+            'project_id': data.get('project', {}).get('project_id'),
+            'demographic': {},
+            'diagnoses': []
+        }
+        
+        # Parse demographic data
+        demo = data.get('demographic', {})
+        clinical['demographic'] = {
+            'age_at_index': demo.get('age_at_index'),
+            'gender': demo.get('gender'),
+            'race': demo.get('race'),
+            'ethnicity': demo.get('ethnicity')
+        }
+        
+        # Parse diagnosis data
+        for diag in data.get('diagnoses', []):
+            diagnosis = {
+                'diagnosis_id': diag.get('diagnosis_id'),
+                'primary_diagnosis': diag.get('primary_diagnosis'),
+                'tumor_stage': diag.get('tumor_stage'),
+                'age_at_diagnosis': diag.get('age_at_diagnosis'),
+                'vital_status': diag.get('vital_status')
+            }
+            clinical['diagnoses'].append(diagnosis)
+        
+        return clinical

backend/neo4j/__init__.py

@@ -0,0 +1,25 @@
+"""
+Neo4j Module
+Graph database integration for cancer genomics data
+"""
+
+from .db_manager import (
+    DatabaseManager,
+    GeneRepository,
+    MutationRepository,
+    PatientRepository,
+    CancerTypeRepository
+)
+from .graphql_schema import schema
+from .data_importer import DataImporter, initialize_database
+
+__all__ = [
+    'DatabaseManager',
+    'GeneRepository',
+    'MutationRepository',
+    'PatientRepository',
+    'CancerTypeRepository',
+    'schema',
+    'DataImporter',
+    'initialize_database'
+]

backend/neo4j/data_importer.py

@@ -0,0 +1,152 @@
+"""
+Data Importer for Neo4j
+Import cancer data from various sources into the graph database
+"""
+
+from pathlib import Path
+from typing import Dict, List
+import logging
+from .db_manager import (
+    DatabaseManager,
+    GeneRepository,
+    MutationRepository,
+    PatientRepository,
+    CancerTypeRepository
+)
+
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+
+class DataImporter:
+    """Import cancer genomics data into Neo4j"""
+    
+    def __init__(self):
+        self.db = DatabaseManager()
+        self.gene_repo = GeneRepository(self.db)
+        self.mutation_repo = MutationRepository(self.db)
+        self.patient_repo = PatientRepository(self.db)
+        self.cancer_repo = CancerTypeRepository(self.db)
+    
+    def close(self):
+        """Close database connection"""
+        self.db.close()
+    
+    def import_sample_data(self):
+        """Import sample cancer data for demonstration"""
+        logger.info("Importing sample cancer data...")
+        
+        # Create cancer types
+        cancer_types = [
+            {'cancer_type_id': 'BRCA', 'name': 'Breast Cancer', 'tissue': 'Breast', 'disease_type': 'Adenocarcinoma'},
+            {'cancer_type_id': 'LUAD', 'name': 'Lung Adenocarcinoma', 'tissue': 'Lung', 'disease_type': 'Adenocarcinoma'},
+            {'cancer_type_id': 'COAD', 'name': 'Colon Adenocarcinoma', 'tissue': 'Colon', 'disease_type': 'Adenocarcinoma'},
+            {'cancer_type_id': 'GBM', 'name': 'Glioblastoma', 'tissue': 'Brain', 'disease_type': 'Glioblastoma'},
+        ]
+        
+        for cancer_data in cancer_types:
+            self.cancer_repo.create_cancer_type(cancer_data)
+            logger.info(f"Created cancer type: {cancer_data['name']}")
+        
+        # Create genes
+        genes = [
+            {'gene_id': 'ENSG00000141510', 'symbol': 'TP53', 'name': 'Tumor protein p53', 'chromosome': 'chr17', 'gene_type': 'protein_coding'},
+            {'gene_id': 'ENSG00000157764', 'symbol': 'BRAF', 'name': 'B-Raf proto-oncogene', 'chromosome': 'chr7', 'gene_type': 'protein_coding'},
+            {'gene_id': 'ENSG00000139618', 'symbol': 'BRCA2', 'name': 'BRCA2 DNA repair associated', 'chromosome': 'chr13', 'gene_type': 'protein_coding'},
+            {'gene_id': 'ENSG00000012048', 'symbol': 'BRCA1', 'name': 'BRCA1 DNA repair associated', 'chromosome': 'chr17', 'gene_type': 'protein_coding'},
+            {'gene_id': 'ENSG00000121879', 'symbol': 'PIK3CA', 'name': 'Phosphatidylinositol-4,5-bisphosphate 3-kinase', 'chromosome': 'chr3', 'gene_type': 'protein_coding'},
+            {'gene_id': 'ENSG00000133703', 'symbol': 'KRAS', 'name': 'KRAS proto-oncogene', 'chromosome': 'chr12', 'gene_type': 'protein_coding'},
+            {'gene_id': 'ENSG00000146648', 'symbol': 'EGFR', 'name': 'Epidermal growth factor receptor', 'chromosome': 'chr7', 'gene_type': 'protein_coding'},
+        ]
+        
+        for gene_data in genes:
+            self.gene_repo.create_gene(gene_data)
+            logger.info(f"Created gene: {gene_data['symbol']}")
+        
+        # Create patients
+        patients = [
+            {'patient_id': 'TCGA-A1-001', 'project_id': 'TCGA-BRCA', 'age': 55, 'gender': 'female', 'race': 'white', 'vital_status': 'alive'},
+            {'patient_id': 'TCGA-A1-002', 'project_id': 'TCGA-BRCA', 'age': 62, 'gender': 'female', 'race': 'asian', 'vital_status': 'alive'},
+            {'patient_id': 'TCGA-L1-001', 'project_id': 'TCGA-LUAD', 'age': 68, 'gender': 'male', 'race': 'white', 'vital_status': 'deceased'},
+            {'patient_id': 'TCGA-L1-002', 'project_id': 'TCGA-LUAD', 'age': 71, 'gender': 'male', 'race': 'black', 'vital_status': 'alive'},
+            {'patient_id': 'TCGA-C1-001', 'project_id': 'TCGA-COAD', 'age': 58, 'gender': 'female', 'race': 'white', 'vital_status': 'alive'},
+        ]
+        
+        for patient_data in patients:
+            self.patient_repo.create_patient(patient_data)
+            logger.info(f"Created patient: {patient_data['patient_id']}")
+        
+        # Link patients to cancer types
+        diagnoses = [
+            {'patient_id': 'TCGA-A1-001', 'cancer_type_id': 'BRCA', 'properties': {'stage': 'Stage II', 'grade': 'G2'}},
+            {'patient_id': 'TCGA-A1-002', 'cancer_type_id': 'BRCA', 'properties': {'stage': 'Stage III', 'grade': 'G3'}},
+            {'patient_id': 'TCGA-L1-001', 'cancer_type_id': 'LUAD', 'properties': {'stage': 'Stage IV', 'grade': 'G3'}},
+            {'patient_id': 'TCGA-L1-002', 'cancer_type_id': 'LUAD', 'properties': {'stage': 'Stage II', 'grade': 'G2'}},
+            {'patient_id': 'TCGA-C1-001', 'cancer_type_id': 'COAD', 'properties': {'stage': 'Stage III', 'grade': 'G2'}},
+        ]
+        
+        for diagnosis in diagnoses:
+            self.patient_repo.link_patient_to_cancer_type(
+                diagnosis['patient_id'],
+                diagnosis['cancer_type_id'],
+                diagnosis['properties']
+            )
+        
+        # Create mutations
+        mutations = [
+            {'mutation_id': 'MUT-TP53-001', 'chromosome': 'chr17', 'position': 7577538, 'reference': 'C', 'alternate': 'T', 'consequence': 'missense', 'variant_type': 'SNP', 'quality': 35.2},
+            {'mutation_id': 'MUT-BRAF-001', 'chromosome': 'chr7', 'position': 140453136, 'reference': 'A', 'alternate': 'T', 'consequence': 'missense', 'variant_type': 'SNP', 'quality': 42.1},
+            {'mutation_id': 'MUT-BRCA2-001', 'chromosome': 'chr13', 'position': 32914438, 'reference': 'T', 'alternate': 'C', 'consequence': 'missense', 'variant_type': 'SNP', 'quality': 38.7},
+            {'mutation_id': 'MUT-PIK3CA-001', 'chromosome': 'chr3', 'position': 178936091, 'reference': 'G', 'alternate': 'A', 'consequence': 'missense', 'variant_type': 'SNP', 'quality': 33.5},
+            {'mutation_id': 'MUT-KRAS-001', 'chromosome': 'chr12', 'position': 25398284, 'reference': 'C', 'alternate': 'T', 'consequence': 'missense', 'variant_type': 'SNP', 'quality': 39.4},
+        ]
+        
+        gene_mutations = [
+            ('MUT-TP53-001', 'ENSG00000141510'),
+            ('MUT-BRAF-001', 'ENSG00000157764'),
+            ('MUT-BRCA2-001', 'ENSG00000139618'),
+            ('MUT-PIK3CA-001', 'ENSG00000121879'),
+            ('MUT-KRAS-001', 'ENSG00000133703'),
+        ]
+        
+        for mutation_data, (mut_id, gene_id) in zip(mutations, gene_mutations):
+            self.mutation_repo.create_mutation(mutation_data, gene_id)
+            logger.info(f"Created mutation: {mutation_data['mutation_id']}")
+        
+        # Link mutations to patients
+        patient_mutations = [
+            {'patient_id': 'TCGA-A1-001', 'mutation_id': 'MUT-TP53-001', 'properties': {'allele_frequency': 0.45, 'depth': 50}},
+            {'patient_id': 'TCGA-A1-001', 'mutation_id': 'MUT-PIK3CA-001', 'properties': {'allele_frequency': 0.38, 'depth': 48}},
+            {'patient_id': 'TCGA-A1-002', 'mutation_id': 'MUT-BRCA2-001', 'properties': {'allele_frequency': 0.52, 'depth': 55}},
+            {'patient_id': 'TCGA-L1-001', 'mutation_id': 'MUT-KRAS-001', 'properties': {'allele_frequency': 0.49, 'depth': 58}},
+            {'patient_id': 'TCGA-L1-001', 'mutation_id': 'MUT-TP53-001', 'properties': {'allele_frequency': 0.41, 'depth': 45}},
+            {'patient_id': 'TCGA-L1-002', 'mutation_id': 'MUT-BRAF-001', 'properties': {'allele_frequency': 0.47, 'depth': 52}},
+            {'patient_id': 'TCGA-C1-001', 'mutation_id': 'MUT-KRAS-001', 'properties': {'allele_frequency': 0.44, 'depth': 50}},
+        ]
+        
+        for pm in patient_mutations:
+            self.mutation_repo.link_mutation_to_patient(
+                pm['mutation_id'],
+                pm['patient_id'],
+                pm['properties']
+            )
+        
+        logger.info("Sample data import completed!")
+    
+    def import_gdc_data(self, gdc_files: List[Dict]):
+        """Import data from GDC portal"""
+        # Implementation for importing real GDC data
+        pass
+
+
+def initialize_database():
+    """Initialize database with sample data"""
+    importer = DataImporter()
+    try:
+        importer.import_sample_data()
+    finally:
+        importer.close()
+
+
+if __name__ == "__main__":
+    initialize_database()

backend/neo4j/db_manager.py

@@ -0,0 +1,277 @@
+"""
+Neo4j Database Manager
+Handle graph database connections and operations
+"""
+
+from neo4j import GraphDatabase
+from typing import Dict, List, Optional, Any
+import yaml
+import logging
+
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+
+class DatabaseManager:
+    """Manage Neo4j database connections and schema"""
+    
+    def __init__(self, config_path: str = "config.yml"):
+        with open(config_path, 'r') as f:
+            self.config = yaml.safe_load(f)['neo4j']
+        
+        self.driver = GraphDatabase.driver(
+            self.config['uri'],
+            auth=(self.config['username'], self.config['password'])
+        )
+        
+        logger.info(f"Connected to Neo4j at {self.config['uri']}")
+    
+    def close(self):
+        """Close database connection"""
+        self.driver.close()
+    
+    def __enter__(self):
+        return self
+    
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        self.close()
+    
+    def execute_query(self, query: str, parameters: Optional[Dict] = None) -> List[Dict]:
+        """Execute a Cypher query and return results"""
+        with self.driver.session() as session:
+            result = session.run(query, parameters or {})
+            return [record.data() for record in result]
+    
+    def initialize_schema(self):
+        """Initialize database schema with constraints and indexes"""
+        queries = [
+            # Constraints
+            "CREATE CONSTRAINT gene_id IF NOT EXISTS FOR (g:Gene) REQUIRE g.gene_id IS UNIQUE",
+            "CREATE CONSTRAINT mutation_id IF NOT EXISTS FOR (m:Mutation) REQUIRE m.mutation_id IS UNIQUE",
+            "CREATE CONSTRAINT patient_id IF NOT EXISTS FOR (p:Patient) REQUIRE p.patient_id IS UNIQUE",
+            "CREATE CONSTRAINT cancer_type_id IF NOT EXISTS FOR (c:CancerType) REQUIRE c.cancer_type_id IS UNIQUE",
+            
+            # Indexes
+            "CREATE INDEX gene_symbol IF NOT EXISTS FOR (g:Gene) ON (g.symbol)",
+            "CREATE INDEX mutation_position IF NOT EXISTS FOR (m:Mutation) ON (m.chromosome, m.position)",
+            "CREATE INDEX patient_project IF NOT EXISTS FOR (p:Patient) ON (p.project_id)",
+        ]
+        
+        with self.driver.session() as session:
+            for query in queries:
+                try:
+                    session.run(query)
+                    logger.info(f"Executed: {query[:50]}...")
+                except Exception as e:
+                    logger.warning(f"Schema query failed (may already exist): {e}")
+        
+        logger.info("Database schema initialized")
+    
+    def clear_database(self):
+        """Clear all nodes and relationships (use with caution!)"""
+        query = "MATCH (n) DETACH DELETE n"
+        with self.driver.session() as session:
+            session.run(query)
+        logger.info("Database cleared")
+
+
+class GeneRepository:
+    """Repository for Gene nodes"""
+    
+    def __init__(self, db_manager: DatabaseManager):
+        self.db = db_manager
+    
+    def create_gene(self, gene_data: Dict) -> Dict:
+        """Create a Gene node"""
+        query = """
+        MERGE (g:Gene {gene_id: $gene_id})
+        SET g.symbol = $symbol,
+            g.name = $name,
+            g.chromosome = $chromosome,
+            g.start_position = $start_position,
+            g.end_position = $end_position,
+            g.strand = $strand,
+            g.gene_type = $gene_type
+        RETURN g
+        """
+        result = self.db.execute_query(query, gene_data)
+        return result[0]['g'] if result else {}
+    
+    def get_gene_by_symbol(self, symbol: str) -> Optional[Dict]:
+        """Find gene by symbol"""
+        query = """
+        MATCH (g:Gene {symbol: $symbol})
+        RETURN g
+        """
+        result = self.db.execute_query(query, {'symbol': symbol})
+        return result[0]['g'] if result else None
+    
+    def get_gene_mutations(self, gene_id: str) -> List[Dict]:
+        """Get all mutations for a gene"""
+        query = """
+        MATCH (g:Gene {gene_id: $gene_id})<-[:AFFECTS]-(m:Mutation)
+        RETURN m
+        ORDER BY m.position
+        """
+        result = self.db.execute_query(query, {'gene_id': gene_id})
+        return [r['m'] for r in result]
+
+
+class MutationRepository:
+    """Repository for Mutation nodes"""
+    
+    def __init__(self, db_manager: DatabaseManager):
+        self.db = db_manager
+    
+    def create_mutation(self, mutation_data: Dict, gene_id: str) -> Dict:
+        """Create a Mutation node and link to Gene"""
+        query = """
+        MATCH (g:Gene {gene_id: $gene_id})
+        MERGE (m:Mutation {mutation_id: $mutation_id})
+        SET m.chromosome = $chromosome,
+            m.position = $position,
+            m.reference = $reference,
+            m.alternate = $alternate,
+            m.consequence = $consequence,
+            m.variant_type = $variant_type,
+            m.quality = $quality
+        MERGE (m)-[:AFFECTS]->(g)
+        RETURN m
+        """
+        params = {**mutation_data, 'gene_id': gene_id}
+        result = self.db.execute_query(query, params)
+        return result[0]['m'] if result else {}
+    
+    def link_mutation_to_patient(self, mutation_id: str, patient_id: str, properties: Optional[Dict] = None):
+        """Create HAS_MUTATION relationship"""
+        query = """
+        MATCH (p:Patient {patient_id: $patient_id})
+        MATCH (m:Mutation {mutation_id: $mutation_id})
+        MERGE (p)-[r:HAS_MUTATION]->(m)
+        SET r.allele_frequency = $allele_frequency,
+            r.depth = $depth
+        RETURN r
+        """
+        params = {
+            'patient_id': patient_id,
+            'mutation_id': mutation_id,
+            'allele_frequency': properties.get('allele_frequency', 0) if properties else 0,
+            'depth': properties.get('depth', 0) if properties else 0
+        }
+        self.db.execute_query(query, params)
+    
+    def get_mutation_frequency(self, mutation_id: str) -> Dict:
+        """Calculate mutation frequency across patients"""
+        query = """
+        MATCH (m:Mutation {mutation_id: $mutation_id})
+        MATCH (p:Patient)-[:HAS_MUTATION]->(m)
+        OPTIONAL MATCH (all:Patient)
+        WITH m, count(DISTINCT p) as patients_with_mutation, count(DISTINCT all) as total_patients
+        RETURN m.mutation_id as mutation_id,
+               patients_with_mutation,
+               total_patients,
+               toFloat(patients_with_mutation) / total_patients as frequency
+        """
+        result = self.db.execute_query(query, {'mutation_id': mutation_id})
+        return result[0] if result else {}
+
+
+class PatientRepository:
+    """Repository for Patient nodes"""
+    
+    def __init__(self, db_manager: DatabaseManager):
+        self.db = db_manager
+    
+    def create_patient(self, patient_data: Dict) -> Dict:
+        """Create a Patient node"""
+        query = """
+        MERGE (p:Patient {patient_id: $patient_id})
+        SET p.project_id = $project_id,
+            p.age = $age,
+            p.gender = $gender,
+            p.race = $race,
+            p.ethnicity = $ethnicity,
+            p.vital_status = $vital_status
+        RETURN p
+        """
+        result = self.db.execute_query(query, patient_data)
+        return result[0]['p'] if result else {}
+    
+    def link_patient_to_cancer_type(self, patient_id: str, cancer_type_id: str, properties: Optional[Dict] = None):
+        """Create DIAGNOSED_WITH relationship"""
+        query = """
+        MATCH (p:Patient {patient_id: $patient_id})
+        MATCH (c:CancerType {cancer_type_id: $cancer_type_id})
+        MERGE (p)-[r:DIAGNOSED_WITH]->(c)
+        SET r.stage = $stage,
+            r.grade = $grade,
+            r.diagnosis_date = $diagnosis_date
+        RETURN r
+        """
+        params = {
+            'patient_id': patient_id,
+            'cancer_type_id': cancer_type_id,
+            'stage': properties.get('stage') if properties else None,
+            'grade': properties.get('grade') if properties else None,
+            'diagnosis_date': properties.get('diagnosis_date') if properties else None
+        }
+        self.db.execute_query(query, params)
+    
+    def get_patient_mutations(self, patient_id: str) -> List[Dict]:
+        """Get all mutations for a patient"""
+        query = """
+        MATCH (p:Patient {patient_id: $patient_id})-[r:HAS_MUTATION]->(m:Mutation)-[:AFFECTS]->(g:Gene)
+        RETURN m, g, r.allele_frequency as allele_frequency, r.depth as depth
+        ORDER BY g.symbol
+        """
+        result = self.db.execute_query(query, {'patient_id': patient_id})
+        return result
+
+
+class CancerTypeRepository:
+    """Repository for CancerType nodes"""
+    
+    def __init__(self, db_manager: DatabaseManager):
+        self.db = db_manager
+    
+    def create_cancer_type(self, cancer_data: Dict) -> Dict:
+        """Create a CancerType node"""
+        query = """
+        MERGE (c:CancerType {cancer_type_id: $cancer_type_id})
+        SET c.name = $name,
+            c.tissue = $tissue,
+            c.disease_type = $disease_type
+        RETURN c
+        """
+        result = self.db.execute_query(query, cancer_data)
+        return result[0]['c'] if result else {}
+    
+    def get_common_mutations(self, cancer_type_id: str, limit: int = 10) -> List[Dict]:
+        """Get most common mutations for a cancer type"""
+        query = """
+        MATCH (c:CancerType {cancer_type_id: $cancer_type_id})<-[:DIAGNOSED_WITH]-(p:Patient)
+        MATCH (p)-[:HAS_MUTATION]->(m:Mutation)-[:AFFECTS]->(g:Gene)
+        WITH m, g, count(DISTINCT p) as patient_count
+        RETURN m, g, patient_count
+        ORDER BY patient_count DESC
+        LIMIT $limit
+        """
+        result = self.db.execute_query(query, {'cancer_type_id': cancer_type_id, 'limit': limit})
+        return result
+    
+    def get_statistics(self, cancer_type_id: str) -> Dict:
+        """Get statistics for a cancer type"""
+        query = """
+        MATCH (c:CancerType {cancer_type_id: $cancer_type_id})<-[:DIAGNOSED_WITH]-(p:Patient)
+        OPTIONAL MATCH (p)-[:HAS_MUTATION]->(m:Mutation)
+        WITH c, count(DISTINCT p) as total_patients, count(DISTINCT m) as total_mutations
+        RETURN c.name as cancer_type,
+               total_patients,
+               total_mutations,
+               CASE WHEN total_patients > 0 
+                    THEN toFloat(total_mutations) / total_patients 
+                    ELSE 0 
+               END as avg_mutations_per_patient
+        """
+        result = self.db.execute_query(query, {'cancer_type_id': cancer_type_id})
+        return result[0] if result else {}

backend/neo4j/graphql_schema.py

@@ -0,0 +1,198 @@
+"""
+GraphQL Schema for Cancer Data
+"""
+
+import strawberry
+from typing import List, Optional
+from .db_manager import DatabaseManager
+import logging
+
+logger = logging.getLogger(__name__)
+
+
+@strawberry.type
+class Gene:
+    gene_id: str
+    symbol: str
+    name: Optional[str] = None
+    chromosome: Optional[str] = None
+    start_position: Optional[int] = None
+    end_position: Optional[int] = None
+    gene_type: Optional[str] = None
+
+
+@strawberry.type
+class Mutation:
+    mutation_id: str
+    chromosome: str
+    position: int
+    reference: str
+    alternate: str
+    consequence: Optional[str] = None
+    variant_type: Optional[str] = None
+    quality: Optional[float] = None
+
+
+@strawberry.type
+class Patient:
+    patient_id: str
+    project_id: str
+    age: Optional[int] = None
+    gender: Optional[str] = None
+    race: Optional[str] = None
+    vital_status: Optional[str] = None
+
+
+@strawberry.type
+class CancerType:
+    cancer_type_id: str
+    name: str
+    tissue: Optional[str] = None
+    disease_type: Optional[str] = None
+
+
+@strawberry.type
+class MutationFrequency:
+    mutation_id: str
+    patients_with_mutation: int
+    total_patients: int
+    frequency: float
+
+
+@strawberry.type
+class CancerStatistics:
+    cancer_type: str
+    total_patients: int
+    total_mutations: int
+    avg_mutations_per_patient: float
+
+
+@strawberry.type
+class Query:
+    @strawberry.field
+    def gene(self, symbol: str) -> Optional[Gene]:
+        """Get gene by symbol"""
+        db = DatabaseManager()
+        from .db_manager import GeneRepository
+        repo = GeneRepository(db)
+        gene_data = repo.get_gene_by_symbol(symbol)
+        db.close()
+        
+        if gene_data:
+            return Gene(**gene_data)
+        return None
+    
+    @strawberry.field
+    def genes(self, limit: int = 100) -> List[Gene]:
+        """Get all genes"""
+        db = DatabaseManager()
+        query = "MATCH (g:Gene) RETURN g LIMIT $limit"
+        results = db.execute_query(query, {'limit': limit})
+        db.close()
+        
+        return [Gene(**r['g']) for r in results]
+    
+    @strawberry.field
+    def mutations(
+        self,
+        gene: Optional[str] = None,
+        chromosome: Optional[str] = None,
+        limit: int = 100
+    ) -> List[Mutation]:
+        """Get mutations, optionally filtered by gene or chromosome"""
+        db = DatabaseManager()
+        
+        if gene:
+            query = """
+            MATCH (g:Gene {symbol: $gene})<-[:AFFECTS]-(m:Mutation)
+            RETURN m
+            LIMIT $limit
+            """
+            params = {'gene': gene, 'limit': limit}
+        elif chromosome:
+            query = """
+            MATCH (m:Mutation {chromosome: $chromosome})
+            RETURN m
+            LIMIT $limit
+            """
+            params = {'chromosome': chromosome, 'limit': limit}
+        else:
+            query = "MATCH (m:Mutation) RETURN m LIMIT $limit"
+            params = {'limit': limit}
+        
+        results = db.execute_query(query, params)
+        db.close()
+        
+        return [Mutation(**r['m']) for r in results]
+    
+    @strawberry.field
+    def patients(
+        self,
+        project_id: Optional[str] = None,
+        cancer_type: Optional[str] = None,
+        limit: int = 100
+    ) -> List[Patient]:
+        """Get patients, optionally filtered"""
+        db = DatabaseManager()
+        
+        if project_id:
+            query = """
+            MATCH (p:Patient {project_id: $project_id})
+            RETURN p
+            LIMIT $limit
+            """
+            params = {'project_id': project_id, 'limit': limit}
+        elif cancer_type:
+            query = """
+            MATCH (p:Patient)-[:DIAGNOSED_WITH]->(c:CancerType {cancer_type_id: $cancer_type})
+            RETURN p
+            LIMIT $limit
+            """
+            params = {'cancer_type': cancer_type, 'limit': limit}
+        else:
+            query = "MATCH (p:Patient) RETURN p LIMIT $limit"
+            params = {'limit': limit}
+        
+        results = db.execute_query(query, params)
+        db.close()
+        
+        return [Patient(**r['p']) for r in results]
+    
+    @strawberry.field
+    def cancer_types(self) -> List[CancerType]:
+        """Get all cancer types"""
+        db = DatabaseManager()
+        query = "MATCH (c:CancerType) RETURN c"
+        results = db.execute_query(query)
+        db.close()
+        
+        return [CancerType(**r['c']) for r in results]
+    
+    @strawberry.field
+    def mutation_frequency(self, mutation_id: str) -> Optional[MutationFrequency]:
+        """Get frequency of a mutation across all patients"""
+        db = DatabaseManager()
+        from .db_manager import MutationRepository
+        repo = MutationRepository(db)
+        freq_data = repo.get_mutation_frequency(mutation_id)
+        db.close()
+        
+        if freq_data:
+            return MutationFrequency(**freq_data)
+        return None
+    
+    @strawberry.field
+    def cancer_statistics(self, cancer_type_id: str) -> Optional[CancerStatistics]:
+        """Get statistics for a cancer type"""
+        db = DatabaseManager()
+        from .db_manager import CancerTypeRepository
+        repo = CancerTypeRepository(db)
+        stats = repo.get_statistics(cancer_type_id)
+        db.close()
+        
+        if stats:
+            return CancerStatistics(**stats)
+        return None
+
+
+schema = strawberry.Schema(query=Query)

backend/pipeline/__init__.py

@@ -0,0 +1,18 @@
+"""
+Pipeline Module
+Bioinformatics analysis pipeline for sequencing data
+"""
+
+from .fastq_processor import FASTQProcessor, FASTQQualityControl
+from .blast_runner import BLASTRunner, SequenceAligner
+from .variant_caller import VariantCaller, VariantAnalyzer, Variant
+
+__all__ = [
+    'FASTQProcessor',
+    'FASTQQualityControl',
+    'BLASTRunner',
+    'SequenceAligner',
+    'VariantCaller',
+    'VariantAnalyzer',
+    'Variant'
+]

backend/pipeline/blast_runner.py

@@ -0,0 +1,274 @@
+"""
+BLAST Integration
+Sequence alignment and homology searching
+"""
+
+from pathlib import Path
+from typing import Dict, List, Optional
+import subprocess
+import yaml
+import logging
+from Bio import SeqIO
+from Bio.Blast import NCBIXML
+
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+
+class BLASTRunner:
+    """Run BLAST searches for sequence alignment"""
+    
+    def __init__(self, config_path: str = "config.yml"):
+        with open(config_path, 'r') as f:
+            self.config = yaml.safe_load(f)['pipeline']['blast']
+        
+        self.database = self.config.get('database', 'nt')
+        self.evalue = self.config.get('evalue', 0.001)
+        self.num_threads = self.config.get('num_threads', 4)
+        self.output_dir = Path(self.config['output_dir'])
+        self.output_dir.mkdir(parents=True, exist_ok=True)
+    
+    def run_blastn(
+        self,
+        query_file: Path,
+        output_file: Optional[Path] = None,
+        max_targets: int = 10
+    ) -> Optional[Path]:
+        """
+        Run BLASTN for nucleotide sequences
+        
+        Args:
+            query_file: Input FASTA file with query sequences
+            output_file: Output XML file
+            max_targets: Maximum number of target sequences
+        
+        Returns:
+            Path to output file or None if failed
+        """
+        if output_file is None:
+            output_file = self.output_dir / f"{query_file.stem}_blastn.xml"
+        
+        cmd = [
+            'blastn',
+            '-query', str(query_file),
+            '-db', self.database,
+            '-out', str(output_file),
+            '-evalue', str(self.evalue),
+            '-num_threads', str(self.num_threads),
+            '-max_target_seqs', str(max_targets),
+            '-outfmt', '5'  # XML format
+        ]
+        
+        try:
+            logger.info(f"Running BLASTN on {query_file.name}")
+            result = subprocess.run(cmd, capture_output=True, text=True, check=True)
+            logger.info(f"BLASTN completed: {output_file}")
+            return output_file
+            
+        except subprocess.CalledProcessError as e:
+            logger.error(f"BLASTN failed: {e.stderr}")
+            return None
+        except FileNotFoundError:
+            logger.warning("BLASTN not found - creating simulated results")
+            return self._simulate_blast_results(query_file, output_file)
+    
+    def run_blastp(
+        self,
+        query_file: Path,
+        output_file: Optional[Path] = None,
+        max_targets: int = 10
+    ) -> Optional[Path]:
+        """
+        Run BLASTP for protein sequences
+        
+        Args:
+            query_file: Input FASTA file with protein sequences
+            output_file: Output XML file
+            max_targets: Maximum number of target sequences
+        """
+        if output_file is None:
+            output_file = self.output_dir / f"{query_file.stem}_blastp.xml"
+        
+        cmd = [
+            'blastp',
+            '-query', str(query_file),
+            '-db', 'nr',  # Non-redundant protein database
+            '-out', str(output_file),
+            '-evalue', str(self.evalue),
+            '-num_threads', str(self.num_threads),
+            '-max_target_seqs', str(max_targets),
+            '-outfmt', '5'
+        ]
+        
+        try:
+            logger.info(f"Running BLASTP on {query_file.name}")
+            subprocess.run(cmd, capture_output=True, text=True, check=True)
+            logger.info(f"BLASTP completed: {output_file}")
+            return output_file
+            
+        except subprocess.CalledProcessError as e:
+            logger.error(f"BLASTP failed: {e.stderr}")
+            return None
+        except FileNotFoundError:
+            logger.warning("BLASTP not found - creating simulated results")
+            return self._simulate_blast_results(query_file, output_file)
+    
+    def _simulate_blast_results(self, query_file: Path, output_file: Path) -> Path:
+        """Create simulated BLAST results for demo purposes"""
+        with open(output_file, 'w') as f:
+            f.write("""<?xml version="1.0"?>
+<!DOCTYPE BlastOutput PUBLIC "-//NCBI//NCBI BlastOutput/EN" "http://www.ncbi.nlm.nih.gov/dtd/NCBI_BlastOutput.dtd">
+<BlastOutput>
+  <BlastOutput_program>blastn</BlastOutput_program>
+  <BlastOutput_version>BLASTN 2.14.0+</BlastOutput_version>
+  <BlastOutput_reference>Simulated results for demo</BlastOutput_reference>
+  <BlastOutput_db>nt</BlastOutput_db>
+  <BlastOutput_query-ID>Query_1</BlastOutput_query-ID>
+  <BlastOutput_query-def>Sample sequence</BlastOutput_query-def>
+  <BlastOutput_query-len>100</BlastOutput_query-len>
+  <BlastOutput_iterations>
+    <Iteration>
+      <Iteration_iter-num>1</Iteration_iter-num>
+      <Iteration_query-ID>Query_1</Iteration_query-ID>
+      <Iteration_query-def>Sample sequence</Iteration_query-def>
+      <Iteration_query-len>100</Iteration_query-len>
+      <Iteration_hits>
+      </Iteration_hits>
+    </Iteration>
+  </BlastOutput_iterations>
+</BlastOutput>
+""")
+        return output_file
+    
+    def parse_results(self, blast_output: Path) -> List[Dict]:
+        """
+        Parse BLAST XML output
+        
+        Returns:
+            List of hit dictionaries
+        """
+        hits = []
+        
+        try:
+            with open(blast_output, 'r') as f:
+                blast_records = NCBIXML.parse(f)
+                
+                for blast_record in blast_records:
+                    for alignment in blast_record.alignments:
+                        for hsp in alignment.hsps:
+                            hit = {
+                                'query': blast_record.query,
+                                'hit_id': alignment.hit_id,
+                                'hit_def': alignment.hit_def,
+                                'length': alignment.length,
+                                'e_value': hsp.expect,
+                                'score': hsp.score,
+                                'identities': hsp.identities,
+                                'positives': hsp.positives,
+                                'gaps': hsp.gaps,
+                                'query_start': hsp.query_start,
+                                'query_end': hsp.query_end,
+                                'hit_start': hsp.sbjct_start,
+                                'hit_end': hsp.sbjct_end,
+                                'alignment_length': hsp.align_length
+                            }
+                            hits.append(hit)
+            
+            logger.info(f"Parsed {len(hits)} BLAST hits")
+            return hits
+            
+        except Exception as e:
+            logger.error(f"Error parsing BLAST results: {e}")
+            return []
+    
+    def filter_hits(
+        self,
+        hits: List[Dict],
+        min_identity: float = 0.9,
+        max_evalue: float = 0.001
+    ) -> List[Dict]:
+        """
+        Filter BLAST hits by identity and e-value
+        
+        Args:
+            hits: List of hit dictionaries
+            min_identity: Minimum identity percentage (0-1)
+            max_evalue: Maximum e-value threshold
+        """
+        filtered = []
+        
+        for hit in hits:
+            identity_pct = hit['identities'] / hit['alignment_length']
+            
+            if identity_pct >= min_identity and hit['e_value'] <= max_evalue:
+                hit['identity_pct'] = identity_pct
+                filtered.append(hit)
+        
+        logger.info(f"Filtered to {len(filtered)} high-quality hits")
+        return filtered
+
+
+class SequenceAligner:
+    """Sequence alignment utilities"""
+    
+    def __init__(self):
+        self.blast_runner = BLASTRunner()
+    
+    def align_to_reference(
+        self,
+        query_sequences: Path,
+        reference_db: str = 'nt'
+    ) -> Dict:
+        """
+        Align query sequences to reference database
+        
+        Returns:
+            Alignment results and statistics
+        """
+        # Run BLAST
+        blast_output = self.blast_runner.run_blastn(query_sequences)
+        
+        if blast_output is None:
+            return {'error': 'BLAST search failed'}
+        
+        # Parse results
+        hits = self.blast_runner.parse_results(blast_output)
+        
+        # Calculate statistics
+        stats = {
+            'total_queries': 0,
+            'queries_with_hits': 0,
+            'total_hits': len(hits),
+            'avg_identity': 0,
+            'avg_evalue': 0
+        }
+        
+        if hits:
+            stats['avg_identity'] = sum(h.get('identity_pct', 0) for h in hits) / len(hits)
+            stats['avg_evalue'] = sum(h['e_value'] for h in hits) / len(hits)
+        
+        return {
+            'statistics': stats,
+            'hits': hits,
+            'output_file': str(blast_output)
+        }
+    
+    def find_homologs(
+        self,
+        sequence_file: Path,
+        min_identity: float = 0.8
+    ) -> List[Dict]:
+        """
+        Find homologous sequences
+        
+        Args:
+            sequence_file: Input FASTA file
+            min_identity: Minimum identity threshold
+        """
+        blast_output = self.blast_runner.run_blastn(sequence_file)
+        
+        if blast_output:
+            hits = self.blast_runner.parse_results(blast_output)
+            return self.blast_runner.filter_hits(hits, min_identity=min_identity)
+        
+        return []

backend/pipeline/fastq_processor.py

@@ -0,0 +1,249 @@
+"""
+FASTQ Processing Pipeline
+Quality control and preprocessing of sequencing data
+"""
+
+from pathlib import Path
+from typing import Dict, List, Optional
+import yaml
+import logging
+from Bio import SeqIO
+from Bio.SeqIO.QualityIO import FastqGeneralIterator
+
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+
+class FASTQProcessor:
+    """Process FASTQ sequencing files"""
+    
+    def __init__(self, config_path: str = "config.yml"):
+        with open(config_path, 'r') as f:
+            self.config = yaml.safe_load(f)['pipeline']['fastq']
+        
+        self.quality_threshold = self.config['quality_threshold']
+        self.min_length = self.config['min_length']
+        self.output_dir = Path(self.config['output_dir'])
+        self.output_dir.mkdir(parents=True, exist_ok=True)
+    
+    def quality_filter(
+        self,
+        input_file: Path,
+        output_file: Optional[Path] = None
+    ) -> Dict:
+        """
+        Filter FASTQ reads by quality score
+        
+        Args:
+            input_file: Input FASTQ file
+            output_file: Output filtered FASTQ file
+        
+        Returns:
+            Statistics dictionary
+        """
+        if output_file is None:
+            output_file = self.output_dir / f"{input_file.stem}_filtered.fastq"
+        
+        stats = {
+            'total_reads': 0,
+            'passed_reads': 0,
+            'failed_reads': 0,
+            'total_bases': 0,
+            'passed_bases': 0
+        }
+        
+        try:
+            with open(input_file, 'r') as in_f, open(output_file, 'w') as out_f:
+                for title, sequence, quality in FastqGeneralIterator(in_f):
+                    stats['total_reads'] += 1
+                    stats['total_bases'] += len(sequence)
+                    
+                    # Calculate average quality score
+                    quality_scores = [ord(q) - 33 for q in quality]
+                    avg_quality = sum(quality_scores) / len(quality_scores)
+                    
+                    # Check filters
+                    if avg_quality >= self.quality_threshold and len(sequence) >= self.min_length:
+                        out_f.write(f"@{title}\n{sequence}\n+\n{quality}\n")
+                        stats['passed_reads'] += 1
+                        stats['passed_bases'] += len(sequence)
+                    else:
+                        stats['failed_reads'] += 1
+            
+            stats['pass_rate'] = stats['passed_reads'] / stats['total_reads'] if stats['total_reads'] > 0 else 0
+            
+            logger.info(f"Filtered {input_file.name}: {stats['passed_reads']}/{stats['total_reads']} reads passed")
+            return stats
+            
+        except Exception as e:
+            logger.error(f"Error filtering FASTQ: {e}")
+            return stats
+    
+    def trim_adapters(
+        self,
+        input_file: Path,
+        adapter_sequence: str,
+        output_file: Optional[Path] = None
+    ) -> Path:
+        """
+        Trim adapter sequences from reads
+        
+        Args:
+            input_file: Input FASTQ file
+            adapter_sequence: Adapter sequence to trim
+            output_file: Output trimmed file
+        """
+        if output_file is None:
+            output_file = self.output_dir / f"{input_file.stem}_trimmed.fastq"
+        
+        trimmed_count = 0
+        
+        try:
+            with open(input_file, 'r') as in_f, open(output_file, 'w') as out_f:
+                for title, sequence, quality in FastqGeneralIterator(in_f):
+                    # Find adapter
+                    adapter_pos = sequence.find(adapter_sequence)
+                    
+                    if adapter_pos != -1:
+                        # Trim at adapter position
+                        sequence = sequence[:adapter_pos]
+                        quality = quality[:adapter_pos]
+                        trimmed_count += 1
+                    
+                    if len(sequence) >= self.min_length:
+                        out_f.write(f"@{title}\n{sequence}\n+\n{quality}\n")
+            
+            logger.info(f"Trimmed adapters from {trimmed_count} reads")
+            return output_file
+            
+        except Exception as e:
+            logger.error(f"Error trimming adapters: {e}")
+            return input_file
+    
+    def calculate_statistics(self, fastq_file: Path) -> Dict:
+        """
+        Calculate statistics for FASTQ file
+        
+        Returns:
+            Dictionary with read count, length distribution, quality scores
+        """
+        stats = {
+            'total_reads': 0,
+            'total_bases': 0,
+            'min_length': float('inf'),
+            'max_length': 0,
+            'avg_length': 0,
+            'avg_quality': 0,
+            'gc_content': 0
+        }
+        
+        lengths = []
+        qualities = []
+        gc_count = 0
+        
+        try:
+            with open(fastq_file, 'r') as f:
+                for title, sequence, quality in FastqGeneralIterator(f):
+                    stats['total_reads'] += 1
+                    seq_len = len(sequence)
+                    stats['total_bases'] += seq_len
+                    
+                    lengths.append(seq_len)
+                    stats['min_length'] = min(stats['min_length'], seq_len)
+                    stats['max_length'] = max(stats['max_length'], seq_len)
+                    
+                    # Quality scores
+                    quality_scores = [ord(q) - 33 for q in quality]
+                    qualities.extend(quality_scores)
+                    
+                    # GC content
+                    gc_count += sequence.count('G') + sequence.count('C')
+            
+            if stats['total_reads'] > 0:
+                stats['avg_length'] = sum(lengths) / len(lengths)
+                stats['avg_quality'] = sum(qualities) / len(qualities)
+                stats['gc_content'] = (gc_count / stats['total_bases']) * 100
+            
+            return stats
+            
+        except Exception as e:
+            logger.error(f"Error calculating statistics: {e}")
+            return stats
+    
+    def convert_to_fasta(
+        self,
+        input_file: Path,
+        output_file: Optional[Path] = None
+    ) -> Path:
+        """Convert FASTQ to FASTA format"""
+        if output_file is None:
+            output_file = self.output_dir / f"{input_file.stem}.fasta"
+        
+        try:
+            count = SeqIO.convert(str(input_file), "fastq", str(output_file), "fasta")
+            logger.info(f"Converted {count} sequences to FASTA")
+            return output_file
+            
+        except Exception as e:
+            logger.error(f"Error converting to FASTA: {e}")
+            return input_file
+
+
+class FASTQQualityControl:
+    """Quality control analysis for FASTQ files"""
+    
+    def __init__(self):
+        self.processor = FASTQProcessor()
+    
+    def run_qc(self, fastq_file: Path) -> Dict:
+        """
+        Run comprehensive QC on FASTQ file
+        
+        Returns:
+            QC report dictionary
+        """
+        report = {
+            'file': str(fastq_file),
+            'statistics': {},
+            'quality_check': 'PASS',
+            'warnings': []
+        }
+        
+        # Calculate statistics
+        stats = self.processor.calculate_statistics(fastq_file)
+        report['statistics'] = stats
+        
+        # Check for issues
+        if stats['avg_quality'] < 20:
+            report['warnings'].append('Low average quality score')
+            report['quality_check'] = 'WARN'
+        
+        if stats['avg_length'] < 50:
+            report['warnings'].append('Short average read length')
+            report['quality_check'] = 'WARN'
+        
+        if stats['gc_content'] < 30 or stats['gc_content'] > 70:
+            report['warnings'].append(f'Unusual GC content: {stats["gc_content"]:.1f}%')
+        
+        return report
+    
+    def generate_qc_report(self, fastq_files: List[Path]) -> Dict:
+        """Generate QC report for multiple FASTQ files"""
+        reports = {}
+        
+        for fastq_file in fastq_files:
+            report = self.run_qc(fastq_file)
+            reports[fastq_file.name] = report
+        
+        # Summary statistics
+        summary = {
+            'total_files': len(fastq_files),
+            'passed': sum(1 for r in reports.values() if r['quality_check'] == 'PASS'),
+            'warnings': sum(1 for r in reports.values() if r['quality_check'] == 'WARN'),
+            'failed': sum(1 for r in reports.values() if r['quality_check'] == 'FAIL')
+        }
+        
+        return {
+            'summary': summary,
+            'file_reports': reports
+        }

backend/pipeline/variant_caller.py

@@ -0,0 +1,208 @@
+"""
+Variant Calling Pipeline
+Process sequencing data to identify genetic variants
+"""
+
+from pathlib import Path
+from typing import Dict, List, Optional
+import yaml
+import logging
+from dataclasses import dataclass
+
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+
+@dataclass
+class Variant:
+    """Represents a genetic variant"""
+    chromosome: str
+    position: int
+    reference: str
+    alternate: str
+    quality: float
+    depth: int
+    allele_frequency: float
+    gene: Optional[str] = None
+    consequence: Optional[str] = None
+
+
+class VariantCaller:
+    """Call variants from sequencing data"""
+    
+    def __init__(self, config_path: str = "config.yml"):
+        with open(config_path, 'r') as f:
+            self.config = yaml.safe_load(f)['pipeline']['variant_calling']
+        
+        self.min_coverage = self.config['min_coverage']
+        self.min_allele_frequency = self.config['min_allele_frequency']
+        self.output_dir = Path(self.config['output_dir'])
+        self.output_dir.mkdir(parents=True, exist_ok=True)
+    
+    def call_variants(
+        self,
+        alignment_file: Path,
+        reference_genome: Path,
+        output_vcf: Optional[Path] = None
+    ) -> Path:
+        """
+        Call variants from aligned sequencing data
+        
+        Args:
+            alignment_file: BAM/SAM alignment file
+            reference_genome: Reference genome FASTA
+            output_vcf: Output VCF file
+        
+        Returns:
+            Path to VCF file
+        """
+        if output_vcf is None:
+            output_vcf = self.output_dir / f"{alignment_file.stem}_variants.vcf"
+        
+        logger.info(f"Calling variants from {alignment_file.name}")
+        
+        # Simulate variant calling for demo
+        # In production, use tools like GATK, FreeBayes, or BCFtools
+        variants = self._simulate_variant_calling()
+        
+        # Write VCF
+        self._write_vcf(variants, output_vcf)
+        
+        logger.info(f"Identified {len(variants)} variants")
+        return output_vcf
+    
+    def _simulate_variant_calling(self) -> List[Variant]:
+        """Simulate variant calling for demo purposes"""
+        # Common cancer-associated variants
+        variants = [
+            Variant('chr17', 7577538, 'C', 'T', 35.2, 50, 0.45, 'TP53', 'missense'),
+            Variant('chr7', 140453136, 'A', 'T', 42.1, 65, 0.52, 'BRAF', 'missense'),
+            Variant('chr13', 32914438, 'T', 'C', 38.7, 55, 0.48, 'BRCA2', 'missense'),
+            Variant('chr17', 41244936, 'G', 'A', 40.3, 60, 0.50, 'BRCA1', 'missense'),
+            Variant('chr3', 178936091, 'G', 'A', 33.5, 48, 0.43, 'PIK3CA', 'missense'),
+            Variant('chr9', 133748283, 'T', 'G', 37.9, 52, 0.46, 'ABL1', 'missense'),
+            Variant('chr12', 25398284, 'C', 'T', 39.4, 58, 0.49, 'KRAS', 'missense'),
+        ]
+        return variants
+    
+    def _write_vcf(self, variants: List[Variant], output_file: Path):
+        """Write variants to VCF format"""
+        with open(output_file, 'w') as f:
+            # VCF header
+            f.write("##fileformat=VCFv4.2\n")
+            f.write("##source=CancerAtHomeVariantCaller\n")
+            f.write("##INFO=<ID=DP,Number=1,Type=Integer,Description=\"Total Depth\">\n")
+            f.write("##INFO=<ID=AF,Number=A,Type=Float,Description=\"Allele Frequency\">\n")
+            f.write("##INFO=<ID=GENE,Number=1,Type=String,Description=\"Gene Name\">\n")
+            f.write("##INFO=<ID=CONS,Number=1,Type=String,Description=\"Consequence\">\n")
+            f.write("#CHROM\tPOS\tID\tREF\tALT\tQUAL\tFILTER\tINFO\n")
+            
+            # Variant records
+            for v in variants:
+                info = f"DP={v.depth};AF={v.allele_frequency:.3f}"
+                if v.gene:
+                    info += f";GENE={v.gene}"
+                if v.consequence:
+                    info += f";CONS={v.consequence}"
+                
+                filter_status = "PASS" if v.depth >= self.min_coverage and v.allele_frequency >= self.min_allele_frequency else "LowQual"
+                
+                f.write(f"{v.chromosome}\t{v.position}\t.\t{v.reference}\t{v.alternate}\t{v.quality:.1f}\t{filter_status}\t{info}\n")
+    
+    def filter_variants(
+        self,
+        vcf_file: Path,
+        min_quality: float = 30.0
+    ) -> List[Variant]:
+        """Filter variants by quality metrics"""
+        variants = []
+        
+        try:
+            with open(vcf_file, 'r') as f:
+                for line in f:
+                    if line.startswith('#'):
+                        continue
+                    
+                    fields = line.strip().split('\t')
+                    if len(fields) < 8:
+                        continue
+                    
+                    quality = float(fields[5])
+                    if quality < min_quality:
+                        continue
+                    
+                    # Parse INFO field
+                    info = dict(item.split('=') for item in fields[7].split(';') if '=' in item)
+                    
+                    variant = Variant(
+                        chromosome=fields[0],
+                        position=int(fields[1]),
+                        reference=fields[3],
+                        alternate=fields[4],
+                        quality=quality,
+                        depth=int(info.get('DP', 0)),
+                        allele_frequency=float(info.get('AF', 0)),
+                        gene=info.get('GENE'),
+                        consequence=info.get('CONS')
+                    )
+                    variants.append(variant)
+            
+            logger.info(f"Filtered to {len(variants)} high-quality variants")
+            return variants
+            
+        except Exception as e:
+            logger.error(f"Error filtering variants: {e}")
+            return []
+    
+    def annotate_variants(self, variants: List[Variant]) -> List[Variant]:
+        """
+        Annotate variants with functional information
+        
+        In production, integrate with tools like:
+        - ANNOVAR
+        - VEP (Variant Effect Predictor)
+        - SnpEff
+        """
+        # Simulated annotation
+        for variant in variants:
+            if not variant.gene:
+                variant.gene = "UNKNOWN"
+            if not variant.consequence:
+                variant.consequence = "unknown"
+        
+        return variants
+
+
+class VariantAnalyzer:
+    """Analyze and interpret variants"""
+    
+    def __init__(self):
+        self.caller = VariantCaller()
+    
+    def identify_cancer_variants(self, variants: List[Variant]) -> List[Variant]:
+        """Identify known cancer-associated variants"""
+        # Common cancer genes
+        cancer_genes = {
+            'TP53', 'BRCA1', 'BRCA2', 'KRAS', 'EGFR', 'BRAF',
+            'PIK3CA', 'APC', 'PTEN', 'MYC', 'RB1', 'CDKN2A'
+        }
+        
+        cancer_variants = [
+            v for v in variants
+            if v.gene and v.gene in cancer_genes
+        ]
+        
+        logger.info(f"Found {len(cancer_variants)} cancer-associated variants")
+        return cancer_variants
+    
+    def calculate_mutation_burden(self, variants: List[Variant]) -> float:
+        """Calculate tumor mutation burden (TMB)"""
+        # TMB = number of somatic mutations per megabase
+        coding_variants = [v for v in variants if v.consequence in ['missense', 'nonsense', 'frameshift']]
+        
+        # Assume exome size of ~30 Mb
+        exome_size_mb = 30
+        tmb = len(coding_variants) / exome_size_mb
+        
+        logger.info(f"Tumor Mutation Burden: {tmb:.2f} mutations/Mb")
+        return tmb

config.yml

@@ -0,0 +1,66 @@
+# Cancer@Home Configuration
+
+app:
+  name: "Cancer@Home v2"
+  version: "2.0.0"
+  host: "localhost"
+  port: 5000
+  debug: true
+
+neo4j:
+  uri: "bolt://localhost:7687"
+  username: "neo4j"
+  password: "cancer123"
+  database: "neo4j"
+  max_connection_lifetime: 3600
+  max_connection_pool_size: 50
+
+gdc:
+  api_url: "https://api.gdc.cancer.gov"
+  data_endpoint: "/data"
+  files_endpoint: "/files"
+  cases_endpoint: "/cases"
+  download_dir: "./data/gdc"
+  max_retries: 3
+  timeout: 300
+
+boinc:
+  project_url: "http://localhost:8000"  # Local BOINC server
+  username: "cancer_volunteer"
+  password: "volunteer123"
+  work_dir: "./data/boinc"
+  max_concurrent_tasks: 4
+
+pipeline:
+  fastq:
+    quality_threshold: 20
+    min_length: 50
+    output_dir: "./data/processed/fastq"
+  
+  blast:
+    database: "nt"
+    evalue: 0.001
+    num_threads: 4
+    output_dir: "./data/processed/blast"
+  
+  variant_calling:
+    min_coverage: 10
+    min_allele_frequency: 0.05
+    output_dir: "./data/processed/variants"
+
+data:
+  cache_dir: "./data/cache"
+  max_cache_size_gb: 10
+  projects:
+    - "TCGA-BRCA"  # Breast Cancer
+    - "TCGA-LUAD"  # Lung Adenocarcinoma
+    - "TCGA-COAD"  # Colon Adenocarcinoma
+    - "TCGA-GBM"   # Glioblastoma
+    - "TARGET-AML" # Acute Myeloid Leukemia
+
+logging:
+  level: "INFO"
+  format: "%(asctime)s - %(name)s - %(levelname)s - %(message)s"
+  file: "./logs/cancer_at_home.log"
+  max_bytes: 10485760  # 10MB
+  backup_count: 5

docker-compose.yml

@@ -0,0 +1,29 @@
+version: '3.8'
+
+services:
+  neo4j:
+    image: neo4j:5.13-community
+    container_name: cancer_neo4j
+    ports:
+      - "7474:7474"  # HTTP
+      - "7687:7687"  # Bolt
+    environment:
+      - NEO4J_AUTH=neo4j/cancer123
+      - NEO4J_PLUGINS=["apoc", "graph-data-science"]
+      - NEO4J_dbms_security_procedures_unrestricted=apoc.*,gds.*
+      - NEO4J_dbms_memory_heap_initial__size=512m
+      - NEO4J_dbms_memory_heap_max__size=2G
+    volumes:
+      - neo4j_data:/data
+      - neo4j_logs:/logs
+      - neo4j_import:/var/lib/neo4j/import
+    healthcheck:
+      test: ["CMD", "cypher-shell", "-u", "neo4j", "-p", "cancer123", "RETURN 1"]
+      interval: 10s
+      timeout: 5s
+      retries: 5
+
+volumes:
+  neo4j_data:
+  neo4j_logs:
+  neo4j_import:

frontend/index.html

@@ -0,0 +1,563 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>Cancer@Home v2 - Dashboard</title>
+    <script src="https://cdn.jsdelivr.net/npm/d3@7"></script>
+    <script src="https://cdn.jsdelivr.net/npm/chart.js@4.4.0"></script>
+    <style>
+        * {
+            margin: 0;
+            padding: 0;
+            box-sizing: border-box;
+        }
+
+        body {
+            font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, Oxygen, Ubuntu, Cantarell, sans-serif;
+            background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
+            color: #333;
+            min-height: 100vh;
+        }
+
+        .header {
+            background: rgba(0, 0, 0, 0.2);
+            color: white;
+            padding: 20px;
+            text-align: center;
+            backdrop-filter: blur(10px);
+        }
+
+        .header h1 {
+            font-size: 2.5em;
+            margin-bottom: 10px;
+        }
+
+        .header p {
+            opacity: 0.9;
+        }
+
+        .container {
+            max-width: 1400px;
+            margin: 20px auto;
+            padding: 0 20px;
+        }
+
+        .tabs {
+            display: flex;
+            gap: 10px;
+            margin-bottom: 20px;
+            flex-wrap: wrap;
+        }
+
+        .tab-button {
+            background: rgba(255, 255, 255, 0.9);
+            border: none;
+            padding: 15px 30px;
+            border-radius: 8px;
+            cursor: pointer;
+            font-size: 16px;
+            font-weight: 500;
+            transition: all 0.3s;
+        }
+
+        .tab-button:hover {
+            background: white;
+            transform: translateY(-2px);
+            box-shadow: 0 4px 12px rgba(0, 0, 0, 0.15);
+        }
+
+        .tab-button.active {
+            background: white;
+            box-shadow: 0 4px 12px rgba(0, 0, 0, 0.2);
+        }
+
+        .tab-content {
+            display: none;
+        }
+
+        .tab-content.active {
+            display: block;
+        }
+
+        .cards {
+            display: grid;
+            grid-template-columns: repeat(auto-fit, minmax(300px, 1fr));
+            gap: 20px;
+            margin-bottom: 30px;
+        }
+
+        .card {
+            background: white;
+            border-radius: 12px;
+            padding: 25px;
+            box-shadow: 0 4px 6px rgba(0, 0, 0, 0.1);
+        }
+
+        .card h3 {
+            color: #667eea;
+            margin-bottom: 15px;
+            font-size: 1.3em;
+        }
+
+        .stat {
+            font-size: 2.5em;
+            font-weight: bold;
+            color: #764ba2;
+            margin: 10px 0;
+        }
+
+        .graph-container {
+            background: white;
+            border-radius: 12px;
+            padding: 25px;
+            margin-bottom: 20px;
+            box-shadow: 0 4px 6px rgba(0, 0, 0, 0.1);
+        }
+
+        #neo4j-viz {
+            width: 100%;
+            height: 600px;
+            border: 2px solid #e0e0e0;
+            border-radius: 8px;
+        }
+
+        .button {
+            background: #667eea;
+            color: white;
+            border: none;
+            padding: 12px 24px;
+            border-radius: 6px;
+            cursor: pointer;
+            font-size: 16px;
+            transition: background 0.3s;
+        }
+
+        .button:hover {
+            background: #5568d3;
+        }
+
+        .task-list {
+            list-style: none;
+        }
+
+        .task-item {
+            background: #f5f5f5;
+            padding: 15px;
+            margin: 10px 0;
+            border-radius: 6px;
+            border-left: 4px solid #667eea;
+        }
+
+        .task-item.completed {
+            border-left-color: #4caf50;
+        }
+
+        .task-item.running {
+            border-left-color: #ff9800;
+        }
+
+        .status-badge {
+            display: inline-block;
+            padding: 4px 12px;
+            border-radius: 12px;
+            font-size: 12px;
+            font-weight: 600;
+            text-transform: uppercase;
+        }
+
+        .status-pending { background: #ffc107; color: #000; }
+        .status-running { background: #2196f3; color: white; }
+        .status-completed { background: #4caf50; color: white; }
+        .status-failed { background: #f44336; color: white; }
+
+        .input-group {
+            margin: 15px 0;
+        }
+
+        .input-group label {
+            display: block;
+            margin-bottom: 5px;
+            font-weight: 500;
+        }
+
+        .input-group input, .input-group select {
+            width: 100%;
+            padding: 10px;
+            border: 1px solid #ddd;
+            border-radius: 6px;
+            font-size: 14px;
+        }
+
+        .project-card {
+            background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
+            color: white;
+            padding: 20px;
+            border-radius: 8px;
+            margin: 10px 0;
+            cursor: pointer;
+            transition: transform 0.2s;
+        }
+
+        .project-card:hover {
+            transform: translateY(-3px);
+        }
+
+        .loading {
+            text-align: center;
+            padding: 40px;
+            color: #667eea;
+        }
+
+        @keyframes spin {
+            to { transform: rotate(360deg); }
+        }
+
+        .spinner {
+            border: 4px solid #f3f3f3;
+            border-top: 4px solid #667eea;
+            border-radius: 50%;
+            width: 40px;
+            height: 40px;
+            animation: spin 1s linear infinite;
+            margin: 20px auto;
+        }
+    </style>
+</head>
+<body>
+    <div class="header">
+        <h1>🧬 Cancer@Home v2</h1>
+        <p>Distributed Cancer Genomics Research Platform</p>
+    </div>
+
+    <div class="container">
+        <div class="tabs">
+            <button class="tab-button active" onclick="showTab('dashboard')">📊 Dashboard</button>
+            <button class="tab-button" onclick="showTab('neo4j')">🔍 Neo4j Visualization</button>
+            <button class="tab-button" onclick="showTab('boinc')">⚡ BOINC Tasks</button>
+            <button class="tab-button" onclick="showTab('gdc')">📚 GDC Data</button>
+            <button class="tab-button" onclick="showTab('pipeline')">🧪 Analysis Pipeline</button>
+        </div>
+
+        <!-- Dashboard Tab -->
+        <div id="dashboard" class="tab-content active">
+            <div class="cards" id="stats-cards">
+                <div class="card">
+                    <h3>Total Genes</h3>
+                    <div class="stat" id="total-genes">-</div>
+                </div>
+                <div class="card">
+                    <h3>Total Mutations</h3>
+                    <div class="stat" id="total-mutations">-</div>
+                </div>
+                <div class="card">
+                    <h3>Total Patients</h3>
+                    <div class="stat" id="total-patients">-</div>
+                </div>
+                <div class="card">
+                    <h3>Cancer Types</h3>
+                    <div class="stat" id="total-cancer-types">-</div>
+                </div>
+            </div>
+
+            <div class="graph-container">
+                <h3>Mutation Distribution by Cancer Type</h3>
+                <canvas id="mutation-chart"></canvas>
+            </div>
+        </div>
+
+        <!-- Neo4j Visualization Tab -->
+        <div id="neo4j" class="tab-content">
+            <div class="graph-container">
+                <h3>Cancer Genomics Knowledge Graph</h3>
+                <div id="neo4j-viz"></div>
+            </div>
+        </div>
+
+        <!-- BOINC Tasks Tab -->
+        <div id="boinc" class="tab-content">
+            <div class="cards">
+                <div class="card">
+                    <h3>Submit New Task</h3>
+                    <div class="input-group">
+                        <label>Task Type</label>
+                        <select id="task-type">
+                            <option value="variant_calling">Variant Calling</option>
+                            <option value="blast_search">BLAST Search</option>
+                            <option value="alignment">Sequence Alignment</option>
+                        </select>
+                    </div>
+                    <div class="input-group">
+                        <label>Input File</label>
+                        <input type="text" id="input-file" placeholder="path/to/input.fastq">
+                    </div>
+                    <button class="button" onclick="submitBoincTask()">Submit Task</button>
+                </div>
+
+                <div class="card">
+                    <h3>BOINC Statistics</h3>
+                    <div id="boinc-stats"></div>
+                </div>
+            </div>
+
+            <div class="card">
+                <h3>Active Tasks</h3>
+                <ul class="task-list" id="task-list"></ul>
+            </div>
+        </div>
+
+        <!-- GDC Data Tab -->
+        <div id="gdc" class="tab-content">
+            <div class="card">
+                <h3>Available GDC Projects</h3>
+                <div id="gdc-projects"></div>
+            </div>
+        </div>
+
+        <!-- Pipeline Tab -->
+        <div id="pipeline" class="tab-content">
+            <div class="cards">
+                <div class="card">
+                    <h3>FASTQ Quality Control</h3>
+                    <p>Run quality control analysis on sequencing data</p>
+                    <button class="button" style="margin-top: 15px;">Run QC</button>
+                </div>
+                <div class="card">
+                    <h3>BLAST Search</h3>
+                    <p>Perform sequence alignment and homology search</p>
+                    <button class="button" style="margin-top: 15px;">Run BLAST</button>
+                </div>
+                <div class="card">
+                    <h3>Variant Calling</h3>
+                    <p>Identify genetic variants from sequencing data</p>
+                    <button class="button" style="margin-top: 15px;">Call Variants</button>
+                </div>
+            </div>
+        </div>
+    </div>
+
+    <script>
+        // Tab switching
+        function showTab(tabName) {
+            document.querySelectorAll('.tab-content').forEach(tab => {
+                tab.classList.remove('active');
+            });
+            document.querySelectorAll('.tab-button').forEach(btn => {
+                btn.classList.remove('active');
+            });
+
+            document.getElementById(tabName).classList.add('active');
+            event.target.classList.add('active');
+
+            if (tabName === 'dashboard') loadDashboard();
+            else if (tabName === 'neo4j') loadNeo4jViz();
+            else if (tabName === 'boinc') loadBoincTasks();
+            else if (tabName === 'gdc') loadGdcProjects();
+        }
+
+        // Load dashboard data
+        async function loadDashboard() {
+            try {
+                const response = await fetch('/api/neo4j/summary');
+                const data = await response.json();
+
+                document.getElementById('total-genes').textContent = data.genes || 0;
+                document.getElementById('total-mutations').textContent = data.mutations || 0;
+                document.getElementById('total-patients').textContent = data.patients || 0;
+                document.getElementById('total-cancer-types').textContent = data.cancer_types || 0;
+
+                createMutationChart();
+            } catch (error) {
+                console.error('Error loading dashboard:', error);
+            }
+        }
+
+        // Create mutation chart
+        function createMutationChart() {
+            const ctx = document.getElementById('mutation-chart').getContext('2d');
+            new Chart(ctx, {
+                type: 'bar',
+                data: {
+                    labels: ['Breast Cancer', 'Lung Adenocarcinoma', 'Colon Adenocarcinoma', 'Glioblastoma'],
+                    datasets: [{
+                        label: 'Mutations',
+                        data: [245, 189, 156, 203],
+                        backgroundColor: [
+                            'rgba(102, 126, 234, 0.8)',
+                            'rgba(118, 75, 162, 0.8)',
+                            'rgba(237, 100, 166, 0.8)',
+                            'rgba(255, 154, 158, 0.8)'
+                        ]
+                    }]
+                },
+                options: {
+                    responsive: true,
+                    maintainAspectRatio: true,
+                    plugins: {
+                        legend: { display: false }
+                    }
+                }
+            });
+        }
+
+        // Load Neo4j visualization
+        function loadNeo4jViz() {
+            const viz = document.getElementById('neo4j-viz');
+            viz.innerHTML = '<div class="loading"><div class="spinner"></div><p>Loading graph visualization...</p></div>';
+
+            // Simulate graph visualization with D3.js
+            setTimeout(() => {
+                const width = viz.clientWidth;
+                const height = 600;
+
+                viz.innerHTML = '';
+                const svg = d3.select('#neo4j-viz')
+                    .append('svg')
+                    .attr('width', width)
+                    .attr('height', height);
+
+                // Sample data
+                const nodes = [
+                    { id: 'TP53', type: 'gene', x: width/2, y: height/2 },
+                    { id: 'BRCA1', type: 'gene', x: width/3, y: height/3 },
+                    { id: 'KRAS', type: 'gene', x: 2*width/3, y: height/3 },
+                    { id: 'Patient 1', type: 'patient', x: width/4, y: 3*height/4 },
+                    { id: 'Patient 2', type: 'patient', x: 3*width/4, y: 3*height/4 },
+                    { id: 'Breast Cancer', type: 'cancer', x: width/2, y: height/4 }
+                ];
+
+                const links = [
+                    { source: 'Patient 1', target: 'TP53' },
+                    { source: 'Patient 1', target: 'Breast Cancer' },
+                    { source: 'Patient 2', target: 'KRAS' },
+                    { source: 'TP53', target: 'Breast Cancer' }
+                ];
+
+                // Draw links
+                svg.selectAll('line')
+                    .data(links)
+                    .enter()
+                    .append('line')
+                    .attr('x1', d => nodes.find(n => n.id === d.source).x)
+                    .attr('y1', d => nodes.find(n => n.id === d.source).y)
+                    .attr('x2', d => nodes.find(n => n.id === d.target).x)
+                    .attr('y2', d => nodes.find(n => n.id === d.target).y)
+                    .attr('stroke', '#999')
+                    .attr('stroke-width', 2);
+
+                // Draw nodes
+                svg.selectAll('circle')
+                    .data(nodes)
+                    .enter()
+                    .append('circle')
+                    .attr('cx', d => d.x)
+                    .attr('cy', d => d.y)
+                    .attr('r', 20)
+                    .attr('fill', d => {
+                        if (d.type === 'gene') return '#667eea';
+                        if (d.type === 'patient') return '#764ba2';
+                        return '#ed64a6';
+                    });
+
+                // Draw labels
+                svg.selectAll('text')
+                    .data(nodes)
+                    .enter()
+                    .append('text')
+                    .attr('x', d => d.x)
+                    .attr('y', d => d.y - 25)
+                    .attr('text-anchor', 'middle')
+                    .text(d => d.id)
+                    .attr('font-size', '12px')
+                    .attr('fill', '#333');
+            }, 500);
+        }
+
+        // Load BOINC tasks
+        async function loadBoincTasks() {
+            try {
+                const [tasksResponse, statsResponse] = await Promise.all([
+                    fetch('/api/boinc/tasks'),
+                    fetch('/api/boinc/statistics')
+                ]);
+
+                const tasksData = await tasksResponse.json();
+                const statsData = await statsResponse.json();
+
+                // Display tasks
+                const taskList = document.getElementById('task-list');
+                taskList.innerHTML = tasksData.tasks.map(task => `
+                    <li class="task-item ${task.status}">
+                        <strong>${task.name}</strong>
+                        <span class="status-badge status-${task.status}">${task.status}</span>
+                        <div style="margin-top: 8px; font-size: 14px; color: #666;">
+                            Type: ${task.workunit_type} | Created: ${new Date(task.created_at).toLocaleString()}
+                        </div>
+                    </li>
+                `).join('');
+
+                // Display statistics
+                const statsDiv = document.getElementById('boinc-stats');
+                statsDiv.innerHTML = `
+                    <p><strong>Total Tasks:</strong> ${statsData.total_tasks}</p>
+                    <p><strong>Completed:</strong> ${statsData.by_status?.completed || 0}</p>
+                    <p><strong>Running:</strong> ${statsData.by_status?.running || 0}</p>
+                    <p><strong>Pending:</strong> ${statsData.by_status?.pending || 0}</p>
+                `;
+            } catch (error) {
+                console.error('Error loading BOINC tasks:', error);
+            }
+        }
+
+        // Submit BOINC task
+        async function submitBoincTask() {
+            const taskType = document.getElementById('task-type').value;
+            const inputFile = document.getElementById('input-file').value;
+
+            if (!inputFile) {
+                alert('Please provide an input file path');
+                return;
+            }
+
+            try {
+                const response = await fetch('/api/boinc/submit', {
+                    method: 'POST',
+                    headers: { 'Content-Type': 'application/json' },
+                    body: JSON.stringify({ workunit_type: taskType, input_file: inputFile })
+                });
+
+                const data = await response.json();
+                alert(`Task submitted successfully! Task ID: ${data.task_id}`);
+                loadBoincTasks();
+            } catch (error) {
+                console.error('Error submitting task:', error);
+                alert('Failed to submit task');
+            }
+        }
+
+        // Load GDC projects
+        async function loadGdcProjects() {
+            try {
+                const response = await fetch('/api/gdc/projects');
+                const data = await response.json();
+
+                const projectsDiv = document.getElementById('gdc-projects');
+                projectsDiv.innerHTML = data.projects.map(project => `
+                    <div class="project-card">
+                        <h4>${project.name}</h4>
+                        <p>Project ID: ${project.id}</p>
+                        <p>Cases: ${project.cases}</p>
+                    </div>
+                `).join('');
+            } catch (error) {
+                console.error('Error loading GDC projects:', error);
+            }
+        }
+
+        // Initialize dashboard on load
+        window.onload = () => {
+            loadDashboard();
+        };
+    </script>
+</body>
+</html>

requirements.txt

@@ -0,0 +1,51 @@
+# Web Framework
+fastapi==0.104.1
+uvicorn[standard]==0.24.0
+python-multipart==0.0.6
+jinja2==3.1.2
+
+# Neo4j
+neo4j==5.14.1
+py2neo==2021.2.3
+neomodel==5.2.1
+
+# GraphQL
+strawberry-graphql[fastapi]==0.216.1
+graphene==3.3
+
+# HTTP Clients
+requests==2.31.0
+aiohttp==3.9.1
+httpx==0.25.2
+
+# Data Processing
+pandas==2.1.4
+numpy==1.26.2
+biopython==1.81
+
+# GDC API Client
+gdc-client==1.6.1
+
+# BLAST
+biopython==1.81
+
+# Configuration
+pyyaml==6.0.1
+python-dotenv==1.0.0
+
+# WebSocket
+websockets==12.0
+
+# Database
+sqlalchemy==2.0.23
+
+# Utilities
+click==8.1.7
+rich==13.7.0
+tqdm==4.66.1
+
+# Development
+pytest==7.4.3
+pytest-asyncio==0.21.1
+black==23.12.1
+flake8==6.1.0

run.py

@@ -0,0 +1,168 @@
+#!/usr/bin/env python3
+"""
+Cancer@Home v2 - Main Entry Point
+Quick start script for the entire application
+"""
+
+import sys
+import time
+import subprocess
+import webbrowser
+from pathlib import Path
+from rich.console import Console
+from rich.panel import Panel
+from rich.progress import Progress, SpinnerColumn, TextColumn
+import yaml
+
+console = Console()
+
+def load_config():
+    """Load configuration"""
+    with open('config.yml', 'r') as f:
+        return yaml.safe_load(f)
+
+def check_docker():
+    """Check if Docker is running"""
+    try:
+        subprocess.run(['docker', 'ps'], capture_output=True, check=True)
+        return True
+    except:
+        return False
+
+def setup_directories():
+    """Create necessary directories"""
+    dirs = [
+        'data/gdc',
+        'data/boinc',
+        'data/processed/fastq',
+        'data/processed/blast',
+        'data/processed/variants',
+        'data/cache',
+        'logs'
+    ]
+    for dir_path in dirs:
+        Path(dir_path).mkdir(parents=True, exist_ok=True)
+
+def start_neo4j():
+    """Start Neo4j container"""
+    console.print("[cyan]Starting Neo4j database...[/cyan]")
+    subprocess.run(['docker-compose', 'up', '-d'], check=True)
+    
+    # Wait for Neo4j to be ready
+    console.print("[yellow]Waiting for Neo4j to be ready...[/yellow]")
+    time.sleep(10)
+
+def initialize_database():
+    """Initialize Neo4j database schema"""
+    from backend.neo4j.db_manager import DatabaseManager
+    
+    console.print("[cyan]Initializing database schema...[/cyan]")
+    db = DatabaseManager()
+    db.initialize_schema()
+    console.print("[green]✓ Database initialized[/green]")
+
+def start_backend():
+    """Start FastAPI backend"""
+    console.print("[cyan]Starting backend server...[/cyan]")
+    import uvicorn
+    from backend.api.main import app
+    
+    config = load_config()
+    
+    # Run in background
+    import threading
+    def run_server():
+        uvicorn.run(
+            app,
+            host=config['app']['host'],
+            port=config['app']['port'],
+            log_level="info"
+        )
+    
+    thread = threading.Thread(target=run_server, daemon=True)
+    thread.start()
+    time.sleep(3)
+
+def open_browser():
+    """Open browser to application"""
+    config = load_config()
+    url = f"http://{config['app']['host']}:{config['app']['port']}"
+    console.print(f"[green]✓ Opening browser at {url}[/green]")
+    time.sleep(2)
+    webbrowser.open(url)
+
+def main():
+    """Main entry point"""
+    console.clear()
+    
+    # Display banner
+    banner = """
+    ╔═══════════════════════════════════════════╗
+    ║         Cancer@Home v2.0                  ║
+    ║  Distributed Cancer Genomics Research     ║
+    ╚═══════════════════════════════════════════╝
+    """
+    console.print(Panel(banner, style="bold blue"))
+    
+    try:
+        with Progress(
+            SpinnerColumn(),
+            TextColumn("[progress.description]{task.description}"),
+            console=console
+        ) as progress:
+            
+            # Setup
+            task = progress.add_task("[cyan]Setting up directories...", total=None)
+            setup_directories()
+            progress.update(task, completed=True)
+            
+            # Check Docker
+            task = progress.add_task("[cyan]Checking Docker...", total=None)
+            if not check_docker():
+                console.print("[red]✗ Docker is not running. Please start Docker Desktop.[/red]")
+                sys.exit(1)
+            progress.update(task, completed=True)
+            
+            # Start Neo4j
+            task = progress.add_task("[cyan]Starting Neo4j...", total=None)
+            start_neo4j()
+            progress.update(task, completed=True)
+            
+            # Initialize database
+            task = progress.add_task("[cyan]Initializing database...", total=None)
+            initialize_database()
+            progress.update(task, completed=True)
+            
+            # Start backend
+            task = progress.add_task("[cyan]Starting backend server...", total=None)
+            start_backend()
+            progress.update(task, completed=True)
+        
+        console.print("\n[bold green]✓ Cancer@Home is running![/bold green]\n")
+        
+        config = load_config()
+        console.print(f"[cyan]→ Application:[/cyan] http://{config['app']['host']}:{config['app']['port']}")
+        console.print(f"[cyan]→ Neo4j Browser:[/cyan] http://localhost:7474")
+        console.print(f"[cyan]→ API Docs:[/cyan] http://{config['app']['host']}:{config['app']['port']}/docs")
+        console.print(f"[cyan]→ GraphQL:[/cyan] http://{config['app']['host']}:{config['app']['port']}/graphql\n")
+        
+        console.print("[yellow]Press Ctrl+C to stop the server[/yellow]\n")
+        
+        # Open browser
+        open_browser()
+        
+        # Keep running
+        while True:
+            time.sleep(1)
+            
+    except KeyboardInterrupt:
+        console.print("\n[yellow]Shutting down...[/yellow]")
+        subprocess.run(['docker-compose', 'down'])
+        console.print("[green]✓ Goodbye![/green]")
+        sys.exit(0)
+    except Exception as e:
+        console.print(f"[red]✗ Error: {e}[/red]")
+        sys.exit(1)
+
+if __name__ == "__main__":
+    main()

setup.ps1

@@ -0,0 +1,81 @@
+# Windows Setup Script for Cancer@Home v2
+# Run this in PowerShell as Administrator
+
+Write-Host "==================================" -ForegroundColor Cyan
+Write-Host "Cancer@Home v2 - Windows Setup" -ForegroundColor Cyan
+Write-Host "==================================" -ForegroundColor Cyan
+Write-Host ""
+
+# Check Python
+Write-Host "Checking Python installation..." -ForegroundColor Yellow
+try {
+    $pythonVersion = python --version 2>&1
+    Write-Host "✓ Python found: $pythonVersion" -ForegroundColor Green
+} catch {
+    Write-Host "✗ Python not found. Please install Python 3.8+ from https://www.python.org/" -ForegroundColor Red
+    exit 1
+}
+
+# Check Docker
+Write-Host "Checking Docker installation..." -ForegroundColor Yellow
+try {
+    $dockerVersion = docker --version 2>&1
+    Write-Host "✓ Docker found: $dockerVersion" -ForegroundColor Green
+} catch {
+    Write-Host "✗ Docker not found. Please install Docker Desktop from https://www.docker.com/products/docker-desktop" -ForegroundColor Red
+    exit 1
+}
+
+# Create virtual environment
+Write-Host ""
+Write-Host "Creating Python virtual environment..." -ForegroundColor Yellow
+python -m venv venv
+Write-Host "✓ Virtual environment created" -ForegroundColor Green
+
+# Activate virtual environment and install dependencies
+Write-Host ""
+Write-Host "Installing Python dependencies..." -ForegroundColor Yellow
+& ".\venv\Scripts\Activate.ps1"
+pip install --upgrade pip
+pip install -r requirements.txt
+Write-Host "✓ Dependencies installed" -ForegroundColor Green
+
+# Create necessary directories
+Write-Host ""
+Write-Host "Creating directory structure..." -ForegroundColor Yellow
+$dirs = @(
+    "data\gdc",
+    "data\boinc",
+    "data\processed\fastq",
+    "data\processed\blast",
+    "data\processed\variants",
+    "data\cache",
+    "logs"
+)
+
+foreach ($dir in $dirs) {
+    New-Item -ItemType Directory -Force -Path $dir | Out-Null
+}
+Write-Host "✓ Directories created" -ForegroundColor Green
+
+# Start Docker containers
+Write-Host ""
+Write-Host "Starting Neo4j database..." -ForegroundColor Yellow
+docker-compose up -d
+Start-Sleep -Seconds 10
+Write-Host "✓ Neo4j started" -ForegroundColor Green
+
+Write-Host ""
+Write-Host "==================================" -ForegroundColor Cyan
+Write-Host "Setup Complete!" -ForegroundColor Green
+Write-Host "==================================" -ForegroundColor Cyan
+Write-Host ""
+Write-Host "To start the application:" -ForegroundColor Yellow
+Write-Host "  1. Activate virtual environment: .\venv\Scripts\Activate.ps1" -ForegroundColor White
+Write-Host "  2. Run the application: python run.py" -ForegroundColor White
+Write-Host ""
+Write-Host "Access points:" -ForegroundColor Yellow
+Write-Host "  - Application: http://localhost:5000" -ForegroundColor White
+Write-Host "  - Neo4j Browser: http://localhost:7474 (neo4j/cancer123)" -ForegroundColor White
+Write-Host "  - API Docs: http://localhost:5000/docs" -ForegroundColor White
+Write-Host ""

setup.sh

@@ -0,0 +1,75 @@
+#!/bin/bash
+# Linux/Mac Setup Script for Cancer@Home v2
+
+echo "=================================="
+echo "Cancer@Home v2 - Setup"
+echo "=================================="
+echo ""
+
+# Check Python
+echo "Checking Python installation..."
+if command -v python3 &> /dev/null; then
+    PYTHON_VERSION=$(python3 --version)
+    echo "✓ Python found: $PYTHON_VERSION"
+else
+    echo "✗ Python not found. Please install Python 3.8+"
+    exit 1
+fi
+
+# Check Docker
+echo "Checking Docker installation..."
+if command -v docker &> /dev/null; then
+    DOCKER_VERSION=$(docker --version)
+    echo "✓ Docker found: $DOCKER_VERSION"
+else
+    echo "✗ Docker not found. Please install Docker"
+    exit 1
+fi
+
+# Create virtual environment
+echo ""
+echo "Creating Python virtual environment..."
+python3 -m venv venv
+echo "✓ Virtual environment created"
+
+# Activate virtual environment and install dependencies
+echo ""
+echo "Installing Python dependencies..."
+source venv/bin/activate
+pip install --upgrade pip
+pip install -r requirements.txt
+echo "✓ Dependencies installed"
+
+# Create necessary directories
+echo ""
+echo "Creating directory structure..."
+mkdir -p data/gdc
+mkdir -p data/boinc
+mkdir -p data/processed/fastq
+mkdir -p data/processed/blast
+mkdir -p data/processed/variants
+mkdir -p data/cache
+mkdir -p logs
+echo "✓ Directories created"
+
+# Start Docker containers
+echo ""
+echo "Starting Neo4j database..."
+docker-compose up -d
+sleep 10
+echo "✓ Neo4j started"
+
+echo ""
+echo "=================================="
+echo "Setup Complete!"
+echo "=================================="
+echo ""
+echo "To start the application:"
+echo "  1. Activate virtual environment: source venv/bin/activate"
+echo "  2. Run the application: python run.py"
+echo ""
+echo "Access points:"
+echo "  - Application: http://localhost:5000"
+echo "  - Neo4j Browser: http://localhost:7474 (neo4j/cancer123)"
+echo "  - API Docs: http://localhost:5000/docs"
+echo ""

test_cancer_at_home.py

@@ -0,0 +1,178 @@
+"""
+Test Suite for Cancer@Home v2
+Run with: pytest test_cancer_at_home.py
+"""
+
+import pytest
+from pathlib import Path
+
+
+class TestConfiguration:
+    """Test configuration file"""
+    
+    def test_config_exists(self):
+        """Check if config file exists"""
+        assert Path("config.yml").exists()
+    
+    def test_requirements_exists(self):
+        """Check if requirements file exists"""
+        assert Path("requirements.txt").exists()
+
+
+class TestBOINC:
+    """Test BOINC integration"""
+    
+    def test_boinc_client_import(self):
+        """Test BOINC client can be imported"""
+        from backend.boinc import BOINCClient
+        assert BOINCClient is not None
+    
+    def test_boinc_task_submission(self):
+        """Test task submission"""
+        from backend.boinc import BOINCClient
+        
+        client = BOINCClient()
+        task_id = client.submit_task("test_task", "test_input.txt")
+        
+        assert task_id is not None
+        assert task_id.startswith("wu_")
+        
+        # Check task exists
+        task = client.get_task_status(task_id)
+        assert task is not None
+        assert task.status == "pending"
+
+
+class TestGDC:
+    """Test GDC integration"""
+    
+    def test_gdc_client_import(self):
+        """Test GDC client can be imported"""
+        from backend.gdc import GDCClient
+        assert GDCClient is not None
+    
+    def test_gdc_client_initialization(self):
+        """Test GDC client initialization"""
+        from backend.gdc import GDCClient
+        
+        client = GDCClient()
+        assert client.api_url == "https://api.gdc.cancer.gov"
+
+
+class TestPipeline:
+    """Test bioinformatics pipeline"""
+    
+    def test_fastq_processor_import(self):
+        """Test FASTQ processor import"""
+        from backend.pipeline import FASTQProcessor
+        assert FASTQProcessor is not None
+    
+    def test_blast_runner_import(self):
+        """Test BLAST runner import"""
+        from backend.pipeline import BLASTRunner
+        assert BLASTRunner is not None
+    
+    def test_variant_caller_import(self):
+        """Test variant caller import"""
+        from backend.pipeline import VariantCaller
+        assert VariantCaller is not None
+
+
+class TestNeo4j:
+    """Test Neo4j integration"""
+    
+    def test_db_manager_import(self):
+        """Test database manager import"""
+        from backend.neo4j import DatabaseManager
+        assert DatabaseManager is not None
+    
+    def test_repositories_import(self):
+        """Test repository imports"""
+        from backend.neo4j import (
+            GeneRepository,
+            MutationRepository,
+            PatientRepository,
+            CancerTypeRepository
+        )
+        
+        assert GeneRepository is not None
+        assert MutationRepository is not None
+        assert PatientRepository is not None
+        assert CancerTypeRepository is not None
+
+
+class TestAPI:
+    """Test API endpoints"""
+    
+    def test_api_import(self):
+        """Test API can be imported"""
+        from backend.api import app
+        assert app is not None
+    
+    def test_api_title(self):
+        """Test API metadata"""
+        from backend.api import app
+        assert app.title == "Cancer@Home v2"
+        assert app.version == "2.0.0"
+
+
+class TestDirectoryStructure:
+    """Test directory structure"""
+    
+    def test_backend_exists(self):
+        """Check backend directory"""
+        assert Path("backend").exists()
+        assert Path("backend/__init__.py").exists()
+    
+    def test_modules_exist(self):
+        """Check all modules exist"""
+        modules = [
+            "backend/api",
+            "backend/boinc",
+            "backend/gdc",
+            "backend/neo4j",
+            "backend/pipeline"
+        ]
+        
+        for module in modules:
+            assert Path(module).exists()
+            assert Path(f"{module}/__init__.py").exists()
+    
+    def test_frontend_exists(self):
+        """Check frontend files"""
+        assert Path("frontend").exists()
+        assert Path("frontend/index.html").exists()
+    
+    def test_documentation_exists(self):
+        """Check documentation files"""
+        docs = [
+            "README.md",
+            "QUICKSTART.md",
+            "USER_GUIDE.md",
+            "GRAPHQL_EXAMPLES.md",
+            "PROJECT_SUMMARY.md"
+        ]
+        
+        for doc in docs:
+            assert Path(doc).exists()
+
+
+class TestSetupScripts:
+    """Test setup scripts"""
+    
+    def test_setup_scripts_exist(self):
+        """Check setup scripts"""
+        assert Path("setup.ps1").exists()
+        assert Path("setup.sh").exists()
+    
+    def test_run_script_exists(self):
+        """Check run script"""
+        assert Path("run.py").exists()
+    
+    def test_docker_compose_exists(self):
+        """Check Docker compose file"""
+        assert Path("docker-compose.yml").exists()
+
+
+if __name__ == "__main__":
+    pytest.main([__file__, "-v"])