Metadata-Version: 2.4
Name: comet-hunter
Version: 0.2.1
Summary: Astronomical image ingestion and processing system for Sungrazer project
Author: Anand Krishna
License-Expression: MIT
Project-URL: Repository, https://github.com/AnandKri/comet-hunter
Project-URL: Documentation, https://anandkri.github.io/comet-hunter/
Keywords: astronomy,comet,system-design,processing-pipeline
Requires-Python: >=3.11
Description-Content-Type: text/markdown
License-File: LICENSE
Requires-Dist: fastapi>=0.136
Requires-Dist: nicegui>=3.12
Requires-Dist: requests>=2.34
Requires-Dist: numpy>=2.4
Requires-Dist: scipy>=1.17
Requires-Dist: sunpy>=7.1
Requires-Dist: pydantic>=2.13
Requires-Dist: matplotlib>=3.10
Requires-Dist: starlette>=1.2
Requires-Dist: reproject>=0.19
Requires-Dist: mpl_animators>=1.2
Requires-Dist: tzdata>=2026.1
Dynamic: license-file

# Comet Hunter

Comet Hunter is an automated astronomical image ingestion and processing system designed to assist in the discovery of sungrazing comets from SOHO LASCO imagery.

## About The Project

NASA's [Sungrazer Project](https://sungrazer.nrl.navy.mil/) enables the discovery and reporting of comets visible from the SOHO and STEREO satellites. To date, over five thousand comets have been discovered using the SOHO satellite. On board SOHO is the LASCO coronagraph, which consists of two telescopes — C2 and C3. Images from these telescopes are primarily used for reporting new comets.

### Why This Exists?

For comet discovery, users rely on fragmented tools for downloading, processing, and reviewing imagery. There is no unified platform that automates the complete workflow from raw image availability to chronological playback of processed frames. **Comet Hunter aims to bridge this gap**.

### Present Challenges
- RAW images must be processed before becoming usable
- Sungrazer comets are often indistinguishable in single frames
- Chronological playback significantly improves detectability
- Most comets are reported within minutes of data availability.
- **Time is critical.**

The problem is not merely detection - it is **rapid** detection. 

This requires a **robust automation** of the complete workflow: from RAW image ingestion to chronological playback of processed frames.

## Current Capabilities

- Downlink slot synchronization
- Metadata ingestion from LASCO sources
- Parallel RAW image downloading
- Image processing pipelines for C2/C3
- Time-indexed frame retrieval
- REST API backend
- Scheduler-driven ingestion workflows
- Interactive frontend visualization

<h2>User Interface</h2>

<p align="center">
  <img src="docs/images/ui-dashboard.png" width="900">
</p>

## Getting Started

### End User Installation

#### Install Comet Hunter directly from PyPI:

```bash
pip install comet-hunter
```

#### End User Commands

Start the application

```bash
comet-hunter start
```

Check application status

```bash
comet-hunter status
```

Stop the application

```bash
comet-hunter stop
```

#### Note

When started, the application will be available at:

`http://localhost:8080`

Application data, logs, and database files are stored in:

```
Windows:
C:\Users\<username>\.comet_hunter

Linux/macOS:
~/.comet_hunter
```

### Development Setup

#### Clone Repository

```bash
git clone https://github.com/AnandKri/comet-hunter.git
cd comet-hunter
```

#### Create Virtual Environment

Linux/macOS

```bash
python -m venv .venv
source .venv/bin/activate
```

Windows
```bash
python -m venv .venv
.venv\Scripts\activate
```

#### Install Dependencies

```bash
pip install -r requirements.txt
```

#### Run Backend

```bash
uvicorn backend.main:app --reload
```

#### Run Frontend

```bash
python frontend/app.py
```

## Documentation

<a href="https://anandkri.github.io/comet-hunter/" target="_blank">
View full documentation here
</a>
