fastapi-calf 0.1.1__tar.gz

fastapi_calf-0.1.1/PKG-INFO

@@ -0,0 +1,106 @@
+Metadata-Version: 2.4
+Name: fastapi-calf
+Version: 0.1.1
+Summary: A lightweight real-time terminal monitor for FastAPI servers
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Requires-Dist: rich
+Requires-Dist: psutil
+
+# 🐮 fastapi-calf
+
+**A lightweight, real-time observability for FastAPI.**
+
+`fastapi-calf` watches decorated API routes and presents request activity,
+latency, throughput, failures, CPU, memory, and worker information in a compact
+terminal UI. Monitoring is intentionally best-effort: if the dashboard is not
+available, your API continues serving requests normally.
+
+## Highlights
+
+- ⚡ Live requests-per-second and latency sparklines
+- 🧭 Per-route request, failure, status, and response-time statistics
+- 🖥️ CPU and memory usage across multiple application workers
+- 🎮 `CUDA_VISIBLE_DEVICES` reporting for GPU-aware deployments
+- 🛡️ Short-timeout event delivery that never takes down the application
+
+## Quick start
+
+Install the runtime dependencies from the repository root:
+
+```powershell
+python -m pip install fastapi uvicorn rich psutil
+```
+
+Start the monitoring dashboard on port `8005`:
+
+```powershell
+python -m fastapi_calf.daemon --port 8005
+```
+
+In another terminal, start the included example API with four workers:
+
+```powershell
+python -m uvicorn server.app:app --port 8000 --workers 4
+```
+
+Visit `http://127.0.0.1:8000/docs` to explore the API while the terminal
+dashboard updates in real time.
+
+## Instrumenting an API
+
+Configure the monitor once, then decorate the routes you want to observe:
+
+```python
+from fastapi import FastAPI, Request
+from fastapi_calf import Calf, lookout
+
+app = FastAPI()
+Calf.listen(port=8005)
+
+
+@app.get("/health")
+@lookout
+def health(request: Request):
+    return {"status": "healthy"}
+
+
+@app.post("/jobs")
+@lookout
+async def create_job(request: Request):
+    payload = await request.json()
+    return {"accepted": True, "job": payload}
+```
+
+The `Request` parameter allows `@lookout` to capture the method, path, query
+parameters, request size, status, and timing without changing the response.
+
+## Tests and traffic simulation
+
+Install the testing tools and run the correctness suite:
+
+```powershell
+python -m pip install -r requirements-test.txt
+python -m pytest tests/test_api.py -q
+```
+
+The load runner starts four Uvicorn workers, verifies every sample endpoint,
+and pushes **100 concurrent API calls** in a short burst:
+
+```powershell
+python -m tests.load_test
+```
+
+Customize a run with `--requests`, `--concurrency`, and `--workers`. See
+[TESTING.md](TESTING.md) for additional examples.
+
+## Project layout
+
+```text
+fastapi_calf/   monitoring library and terminal dashboard
+server/         instrumented example FastAPI application
+tests/          endpoint and concurrent load tests
+```
+
+> **Status:** This is an early-stage project intended for experimentations with ML pipelines and POCs.
+

fastapi_calf-0.1.1/README.md

@@ -0,0 +1,97 @@
+# 🐮 fastapi-calf
+
+**A lightweight, real-time observability for FastAPI.**
+
+`fastapi-calf` watches decorated API routes and presents request activity,
+latency, throughput, failures, CPU, memory, and worker information in a compact
+terminal UI. Monitoring is intentionally best-effort: if the dashboard is not
+available, your API continues serving requests normally.
+
+## Highlights
+
+- ⚡ Live requests-per-second and latency sparklines
+- 🧭 Per-route request, failure, status, and response-time statistics
+- 🖥️ CPU and memory usage across multiple application workers
+- 🎮 `CUDA_VISIBLE_DEVICES` reporting for GPU-aware deployments
+- 🛡️ Short-timeout event delivery that never takes down the application
+
+## Quick start
+
+Install the runtime dependencies from the repository root:
+
+```powershell
+python -m pip install fastapi uvicorn rich psutil
+```
+
+Start the monitoring dashboard on port `8005`:
+
+```powershell
+python -m fastapi_calf.daemon --port 8005
+```
+
+In another terminal, start the included example API with four workers:
+
+```powershell
+python -m uvicorn server.app:app --port 8000 --workers 4
+```
+
+Visit `http://127.0.0.1:8000/docs` to explore the API while the terminal
+dashboard updates in real time.
+
+## Instrumenting an API
+
+Configure the monitor once, then decorate the routes you want to observe:
+
+```python
+from fastapi import FastAPI, Request
+from fastapi_calf import Calf, lookout
+
+app = FastAPI()
+Calf.listen(port=8005)
+
+
+@app.get("/health")
+@lookout
+def health(request: Request):
+    return {"status": "healthy"}
+
+
+@app.post("/jobs")
+@lookout
+async def create_job(request: Request):
+    payload = await request.json()
+    return {"accepted": True, "job": payload}
+```
+
+The `Request` parameter allows `@lookout` to capture the method, path, query
+parameters, request size, status, and timing without changing the response.
+
+## Tests and traffic simulation
+
+Install the testing tools and run the correctness suite:
+
+```powershell
+python -m pip install -r requirements-test.txt
+python -m pytest tests/test_api.py -q
+```
+
+The load runner starts four Uvicorn workers, verifies every sample endpoint,
+and pushes **100 concurrent API calls** in a short burst:
+
+```powershell
+python -m tests.load_test
+```
+
+Customize a run with `--requests`, `--concurrency`, and `--workers`. See
+[TESTING.md](TESTING.md) for additional examples.
+
+## Project layout
+
+```text
+fastapi_calf/   monitoring library and terminal dashboard
+server/         instrumented example FastAPI application
+tests/          endpoint and concurrent load tests
+```
+
+> **Status:** This is an early-stage project intended for experimentations with ML pipelines and POCs.
+

fastapi_calf-0.1.1/fastapi_calf/__init__.py

@@ -0,0 +1,4 @@
+from .calf import Calf
+from .decorator import lookout
+
+__all__ = ["Calf", "lookout"]

fastapi_calf-0.1.1/fastapi_calf/calf.py

@@ -0,0 +1,45 @@
+import os
+import time
+
+from .config import config
+from .emitter import emit_event
+
+
+class Calf:
+    @staticmethod
+    def listen(app, port: int, host: str = "127.0.0.1"):
+        config.host = host
+        config.port = port
+
+        cuda_devices = os.getenv("CUDA_VISIBLE_DEVICES")
+
+        emit_event({
+            "pid": os.getpid(),
+            "cuda_visible_devices": cuda_devices,
+        })
+
+        @app.middleware("http")
+        async def calf_middleware(request, call_next):
+            start = time.perf_counter()
+
+            status = 500 # defaults to failure
+
+            try:
+                response = await call_next(request)
+
+                status = response.status_code
+
+                return response
+
+            finally:
+                latency_ms = (time.perf_counter() - start) * 1000
+
+                emit_event({
+                    "pid": os.getpid(),
+                    "cuda_visible_devices": cuda_devices,
+                    "method": request.method,
+                    "path": request.url.path,
+                    "status": status,
+                    "latency_ms": latency_ms,
+                    "last_called": time.time(),
+                })

fastapi_calf-0.1.1/fastapi_calf/cleanup.py

@@ -0,0 +1,11 @@
+import psutil
+
+def cleanup_workers(workers):
+    dead_pids = []
+
+    for pid in workers:
+        if not psutil.pid_exists(pid):
+            dead_pids.append(pid)
+
+    for pid in dead_pids:
+        workers.pop(pid, None)

fastapi_calf-0.1.1/fastapi_calf/config.py

@@ -0,0 +1,6 @@
+class CalfConfig:
+    host = "127.0.0.1"
+    port = 8765
+
+
+config = CalfConfig()

fastapi_calf-0.1.1/fastapi_calf/daemon.py

@@ -0,0 +1,327 @@
+import json
+import time
+import asyncio
+import argparse
+
+from rich.live import Live
+from rich.table import Table
+from rich.text import Text
+from rich.align import Align
+from rich.console import Group
+
+from .system import register_process, get_process_stats
+from .history import cpu_history, latency_history, rps_history
+from .metrics import record_request, get_rps, get_window_latency
+from .sparkline import sparkline
+from .cleanup import cleanup_workers
+
+workers = {
+    # pid: {
+    #     "requests": 0,
+    #     "cuda_visible_devices": None,
+    # }
+}
+
+stats = {}
+
+start_time = time.time()
+
+last_history_sample = 0
+
+
+def process_event(event):
+    pid = event.get("pid")
+
+    if pid is not None:
+        if pid not in workers:
+            register_process(pid)
+
+            workers[pid] = {
+                "requests": 0,
+                "cuda_visible_devices": event.get("cuda_visible_devices"),
+            }
+
+        # Update metadata if supplied again
+        if "cuda_visible_devices" in event:
+            workers[pid]["cuda_visible_devices"] = event["cuda_visible_devices"]
+
+    # This was only a process/system event
+    if "method" not in event or "path" not in event:
+        return
+
+    if pid is not None:
+        workers[pid]["requests"] += 1
+
+    key = (event["method"], event["path"])
+
+    record_request(event["latency_ms"])
+
+    if key not in stats:
+        stats[key] = {
+            "method": event["method"],
+            "path": event["path"],
+            "requests": 0,
+            "failed": 0,
+            "total_latency": 0,
+            "last_latency": 0,
+            "total_bytes": 0,
+            "last_called": 0,
+            "last_status": 200,
+        }
+
+    item = stats[key]
+
+    item["requests"] += 1
+    item["total_latency"] += event["latency_ms"]
+    item["last_latency"] = event["latency_ms"]
+    item["last_called"] = time.time()
+    item["last_status"] = event["status"]
+    # 
+    # NOTE: Disabled due to future changes &
+    #       due to removal of `request: Request`
+    # item["total_bytes"] += event["request_size"]
+    # 
+    item["total_bytes"] += event.get("request_size", 0)
+
+    # Count failed requests
+    if event["status"] >= 400:
+        item["failed"] += 1
+
+
+def sample_history(process_stats):
+    global last_history_sample
+
+    now = time.time()
+
+    if now - last_history_sample < 1:
+        return
+
+    if process_stats:
+        cpu_history.append(process_stats["cpu"])
+
+    latency_history.append(get_window_latency())
+
+    rps_history.append(get_rps())
+
+    last_history_sample = now
+
+
+def latest(values, default=0):
+    return values[-1] if values else default
+
+
+def build_history_panel():
+    return Group(
+        Text(
+            f"CPU       "
+            f"{latest(cpu_history):5.1f}%  "
+            f"{sparkline(cpu_history, 0, 100)}"
+        ),
+        Text(
+            f"Latency   "
+            f"{latest(latency_history):5.1f}ms "
+            f"{sparkline(latency_history)}"
+        ),
+        Text(
+            f"RPS       "
+            f"{latest(rps_history):5.1f}   "
+            f"{sparkline(rps_history)}"
+        ),
+    )
+
+
+def get_total_process_stats():
+    total_cpu = 0
+    total_ram = 0
+    count = 0
+
+    for pid in workers:
+        process_stats = get_process_stats(pid)
+
+        if process_stats is None:
+            continue
+
+        total_cpu += process_stats["cpu"]
+        total_ram += process_stats["ram_mb"]
+        count += 1
+
+    if count == 0:
+        return None
+
+    return {
+        "cpu": total_cpu,
+        "ram_mb": total_ram,
+    }
+
+
+def create_table():
+    table = Table(expand=True)
+
+    table.add_column("Endpoint")
+    table.add_column("Method")
+    table.add_column("Activity")
+    table.add_column("Requests", justify="right")
+    table.add_column("Failed", justify="right")
+    table.add_column("Avg latency", justify="right")
+    table.add_column("Last", justify="right")
+    table.add_column("Status", justify="right")
+
+    now = time.time()
+
+    for item in stats.values():
+        avg_latency = (item["total_latency"] / item["requests"] if item["requests"] > 0 else 0)
+
+        active = ("● ● ●" if now - item["last_called"] < 0.5 else "")
+
+        failed_display = (f"[red]{item['failed']}[/red]" if item["failed"] > 0 else "0")
+
+        style = ("bold red" if item["last_status"] >= 400 else None)
+
+        table.add_row(
+            item["path"],
+            item["method"],
+            active,
+            str(item["requests"]),
+            failed_display,
+            f"{avg_latency:.2f} ms",
+            f"{item['last_latency']:.2f} ms",
+            str(item["last_status"]),
+            style=style,
+        )
+
+    process_stats = get_total_process_stats()
+
+    if process_stats:
+        system_text = (
+            f"CPU {process_stats['cpu']:.0f}%"
+            f"    Memory {process_stats['ram_mb']:.0f} MB"
+            f"    Workers {len(workers)}"
+        )
+    else:
+        system_text = "CPU --    Memory --    Workers --"
+
+    sample_history(process_stats)
+
+    workers_table = create_workers_table()
+
+    return Group(
+        Align.center(Text("🐮 fastapi-calf 🐮", style="bold")),
+        Align.center(Text(system_text)),
+        Text(""),
+        build_history_panel(),
+        Text(""),
+        workers_table,
+        Text(""),
+        table,
+    )
+
+
+def create_workers_table():
+    table = Table(title="Workers", expand=True)
+
+    table.add_column("PID")
+    table.add_column("CPU", justify="right")
+    table.add_column("Memory", justify="right")
+    table.add_column("Requests", justify="right")
+    table.add_column("GPU", justify="right")
+
+    dead_workers = []
+
+    now = time.time()
+    workers_to_remove = []
+
+
+    for pid, worker in workers.items():
+        process_stats = get_process_stats(pid)
+
+        if process_stats is None:
+            if worker["dead_since"] is None:
+                worker["dead_since"] = now
+
+            # Remove only after 5 seconds
+            if now - worker["dead_since"] >= 5:
+                workers_to_remove.append(pid)
+                continue
+
+            table.add_row(
+                str(pid),
+                "--",
+                "--",
+                str(worker["requests"]),
+                "none"
+                if worker["cuda_visible_devices"] is None
+                else str(worker["cuda_visible_devices"]),
+                style="dim",
+            )
+
+            continue
+
+        worker["dead_since"] = None
+
+        table.add_row(
+            str(pid),
+            f"{process_stats['cpu']:.1f}%",
+            f"{process_stats['ram_mb']:.1f} MB",
+            str(worker["requests"]),
+            "none"
+            if worker["cuda_visible_devices"] is None
+            else str(worker["cuda_visible_devices"]),
+        )
+
+    for pid in dead_workers:
+        workers.pop(pid, None)
+
+    return table
+
+
+async def handle_client(reader, writer):
+    data = await reader.readline()
+
+    if data:
+        try:
+            event = json.loads(data)
+            process_event(event)
+        except json.JSONDecodeError:
+            pass
+
+    writer.close()
+    await writer.wait_closed()
+
+
+async def run_server(port: int):
+    server = await asyncio.start_server(handle_client, "127.0.0.1", port)
+    async with server:
+        await server.serve_forever()
+
+
+async def run_ui():
+    with Live(create_table(), refresh_per_second=10, screen=True) as live:
+        while True:
+            # NOTE: ---------------------------------------------------------------------------------------
+            # When uncommented, cleanup_workers will instantly remove the dead workers off the table
+            # During testing if u wanna observe dead workers, comment below line `cleanup_workers(workers)`
+            cleanup_workers(workers)
+            # ---------------------------------------------------------------------------------------------
+
+            live.update(create_table())
+            await asyncio.sleep(0.1)
+
+
+async def run(port: int):
+    await asyncio.gather(run_server(port), run_ui())
+
+def main():
+    try:
+        parser = argparse.ArgumentParser()
+        parser.add_argument("-p", "--port", type=int, default=8765, help="Port for fastapi-calf")
+
+        args = parser.parse_args()
+
+        asyncio.run(run(args.port))
+
+    except KeyboardInterrupt:
+        print("fastapi-calf stopped.")
+
+
+if __name__ == "__main__":
+    main()

fastapi_calf-0.1.1/fastapi_calf/decorator.py

@@ -0,0 +1,56 @@
+import inspect
+import time
+import os
+
+from datetime import datetime, timezone
+from functools import wraps
+
+from .emitter import emit_event
+
+
+def lookout(func):
+    @wraps(func)
+    async def wrapper(*args, **kwargs):
+        request = kwargs.get("request")
+
+        start_timestamp = datetime.now(timezone.utc)
+        start_timer = time.perf_counter()
+
+        status_code = 200
+        error = None
+
+        try:
+            if inspect.iscoroutinefunction(func):
+                response = await func(*args, **kwargs)
+            else:
+                response = func(*args, **kwargs)
+            return response
+
+        except Exception as exc:
+            status_code = 500
+            error = str(exc)
+            raise
+
+        finally:
+            end_timer = time.perf_counter()
+            latency_ms = (end_timer - start_timer) * 1000
+
+            if request:
+                body = await request.body()
+
+                event = {
+                    "timestamp": start_timestamp.isoformat(),
+                    "function": func.__name__,
+                    "method": request.method,
+                    "path": request.url.path,
+                    "query": dict(request.query_params),
+                    "request_size": len(body),
+                    "latency_ms": latency_ms,
+                    "status": status_code,
+                    "error": error,
+                    "pid": os.getpid(),
+                }
+
+                emit_event(event)
+
+    return wrapper

fastapi_calf-0.1.1/fastapi_calf/emitter.py

@@ -0,0 +1,21 @@
+import json
+import socket
+
+from .config import config
+
+
+def emit_event(event: dict):
+    try:
+        with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as sock:
+            sock.settimeout(0.05)
+
+            sock.connect((config.host, config.port))
+
+            payload = json.dumps(event).encode("utf-8") + b"\n"
+
+            sock.sendall(payload)
+
+    except (ConnectionRefusedError, TimeoutError, OSError) as error:
+        # Monitoring should NEVER crash the API
+        print("Calf emitter error:", error)
+        pass

fastapi_calf-0.1.1/fastapi_calf/history/__init__.py

@@ -0,0 +1 @@
+from .history import cpu_history, latency_history, rps_history

fastapi_calf-0.1.1/fastapi_calf/history/history.py

@@ -0,0 +1,10 @@
+from collections import deque
+
+
+HISTORY_SIZE = 60
+
+cpu_history = deque(maxlen=HISTORY_SIZE)
+latency_history = deque(maxlen=HISTORY_SIZE)
+rps_history = deque(maxlen=HISTORY_SIZE)
+
+request_times = deque()

fastapi_calf-0.1.1/fastapi_calf/metrics/__init__.py

@@ -0,0 +1 @@
+from .metrics import record_request, get_rps, get_window_latency

fastapi_calf-0.1.1/fastapi_calf/metrics/metrics.py

@@ -0,0 +1,32 @@
+import time
+from collections import deque
+
+from ..history.history import request_times
+
+
+recent_latencies = []
+
+
+def record_request(latency_ms):
+    request_times.append(time.time())
+    recent_latencies.append(latency_ms)
+
+
+def get_rps():
+    now = time.time()
+
+    while request_times and request_times[0] < now - 1:
+        request_times.popleft()
+
+    return len(request_times)
+
+
+def get_window_latency():
+    if not recent_latencies:
+        return 0.0
+
+    avg = sum(recent_latencies) / len(recent_latencies)
+
+    recent_latencies.clear()
+
+    return avg

fastapi_calf-0.1.1/fastapi_calf/sparkline/__init__.py

@@ -0,0 +1 @@
+from .sparkline import sparkline

fastapi_calf-0.1.1/fastapi_calf/sparkline/sparkline.py

@@ -0,0 +1,26 @@
+SPARK_CHARS = "▁▂▃▄▅▆▇█"
+
+
+def sparkline(values, minimum=None, maximum=None):
+    if not values:
+        return ""
+    
+    min_value = minimum if minimum is not None else min(values)
+    max_value = maximum if maximum is not None else max(values)
+
+    if max_value == min_value:
+        return SPARK_CHARS[0] * len(values)
+
+    result = []
+
+    for value in values:
+        value = max(min_value, min(value, max_value))
+
+        normalized = (value - min_value) / (max_value - min_value)
+
+        index = int(normalized * (len(SPARK_CHARS) - 1))
+
+        result.append(SPARK_CHARS[index])
+    
+    return "".join(result)
+

fastapi_calf-0.1.1/fastapi_calf/system/__init__.py

@@ -0,0 +1 @@
+from .cpu import register_process, get_process_stats

fastapi_calf-0.1.1/fastapi_calf/system/cpu.py

@@ -0,0 +1,37 @@
+import psutil
+
+
+_processes = {}
+
+
+def register_process(pid: int):
+    if pid in _processes:
+        return
+
+    try:
+        process = psutil.Process(pid)
+
+        # Prime cpu_percent
+        process.cpu_percent(interval=None)
+
+        _processes[pid] = process
+
+    except psutil.NoSuchProcess:
+        pass
+
+
+def get_process_stats(pid: int):
+    process = _processes.get(pid)
+
+    if process is None:
+        return None
+
+    try:
+        return {
+            "cpu": process.cpu_percent(interval=None),
+            "ram_mb": process.memory_info().rss / 1024 / 1024,
+        }
+
+    except psutil.NoSuchProcess:
+        _processes.pop(pid, None)
+        return None

fastapi_calf-0.1.1/fastapi_calf.egg-info/PKG-INFO

@@ -0,0 +1,106 @@
+Metadata-Version: 2.4
+Name: fastapi-calf
+Version: 0.1.1
+Summary: A lightweight real-time terminal monitor for FastAPI servers
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Requires-Dist: rich
+Requires-Dist: psutil
+
+# 🐮 fastapi-calf
+
+**A lightweight, real-time observability for FastAPI.**
+
+`fastapi-calf` watches decorated API routes and presents request activity,
+latency, throughput, failures, CPU, memory, and worker information in a compact
+terminal UI. Monitoring is intentionally best-effort: if the dashboard is not
+available, your API continues serving requests normally.
+
+## Highlights
+
+- ⚡ Live requests-per-second and latency sparklines
+- 🧭 Per-route request, failure, status, and response-time statistics
+- 🖥️ CPU and memory usage across multiple application workers
+- 🎮 `CUDA_VISIBLE_DEVICES` reporting for GPU-aware deployments
+- 🛡️ Short-timeout event delivery that never takes down the application
+
+## Quick start
+
+Install the runtime dependencies from the repository root:
+
+```powershell
+python -m pip install fastapi uvicorn rich psutil
+```
+
+Start the monitoring dashboard on port `8005`:
+
+```powershell
+python -m fastapi_calf.daemon --port 8005
+```
+
+In another terminal, start the included example API with four workers:
+
+```powershell
+python -m uvicorn server.app:app --port 8000 --workers 4
+```
+
+Visit `http://127.0.0.1:8000/docs` to explore the API while the terminal
+dashboard updates in real time.
+
+## Instrumenting an API
+
+Configure the monitor once, then decorate the routes you want to observe:
+
+```python
+from fastapi import FastAPI, Request
+from fastapi_calf import Calf, lookout
+
+app = FastAPI()
+Calf.listen(port=8005)
+
+
+@app.get("/health")
+@lookout
+def health(request: Request):
+    return {"status": "healthy"}
+
+
+@app.post("/jobs")
+@lookout
+async def create_job(request: Request):
+    payload = await request.json()
+    return {"accepted": True, "job": payload}
+```
+
+The `Request` parameter allows `@lookout` to capture the method, path, query
+parameters, request size, status, and timing without changing the response.
+
+## Tests and traffic simulation
+
+Install the testing tools and run the correctness suite:
+
+```powershell
+python -m pip install -r requirements-test.txt
+python -m pytest tests/test_api.py -q
+```
+
+The load runner starts four Uvicorn workers, verifies every sample endpoint,
+and pushes **100 concurrent API calls** in a short burst:
+
+```powershell
+python -m tests.load_test
+```
+
+Customize a run with `--requests`, `--concurrency`, and `--workers`. See
+[TESTING.md](TESTING.md) for additional examples.
+
+## Project layout
+
+```text
+fastapi_calf/   monitoring library and terminal dashboard
+server/         instrumented example FastAPI application
+tests/          endpoint and concurrent load tests
+```
+
+> **Status:** This is an early-stage project intended for experimentations with ML pipelines and POCs.
+

fastapi_calf-0.1.1/fastapi_calf.egg-info/SOURCES.txt

@@ -0,0 +1,25 @@
+README.md
+pyproject.toml
+fastapi_calf/__init__.py
+fastapi_calf/calf.py
+fastapi_calf/cleanup.py
+fastapi_calf/config.py
+fastapi_calf/daemon.py
+fastapi_calf/decorator.py
+fastapi_calf/emitter.py
+fastapi_calf.egg-info/PKG-INFO
+fastapi_calf.egg-info/SOURCES.txt
+fastapi_calf.egg-info/dependency_links.txt
+fastapi_calf.egg-info/entry_points.txt
+fastapi_calf.egg-info/requires.txt
+fastapi_calf.egg-info/top_level.txt
+fastapi_calf/history/__init__.py
+fastapi_calf/history/history.py
+fastapi_calf/metrics/__init__.py
+fastapi_calf/metrics/metrics.py
+fastapi_calf/sparkline/__init__.py
+fastapi_calf/sparkline/sparkline.py
+fastapi_calf/system/__init__.py
+fastapi_calf/system/cpu.py
+fastapi_calf/system/gpu.py
+tests/test.py

fastapi_calf-0.1.1/fastapi_calf.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

fastapi_calf-0.1.1/fastapi_calf.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+calf = fastapi_calf.daemon:main

fastapi_calf-0.1.1/fastapi_calf.egg-info/requires.txt

@@ -0,0 +1,2 @@
+rich
+psutil

fastapi_calf-0.1.1/fastapi_calf.egg-info/top_level.txt

@@ -0,0 +1 @@
+fastapi_calf

fastapi_calf-0.1.1/pyproject.toml

@@ -0,0 +1,21 @@
+[build-system]
+requires = ["setuptools>=68"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "fastapi-calf"
+version = "0.1.1"
+description = "A lightweight real-time terminal monitor for FastAPI servers"
+readme = "README.md"
+requires-python = ">=3.10"
+
+dependencies = [
+    "rich",
+    "psutil",
+]
+
+[project.scripts]
+calf = "fastapi_calf.daemon:main"
+
+[tool.setuptools.packages.find]
+include = ["fastapi_calf*"]

fastapi_calf-0.1.1/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+