feat: init

Author: dreulavelle

.gitignore

@@ -1,3 +1,65 @@
+#######################################################
+# Python
+#######################################################
+
+data/
+logs/
+settings.json
+ignore.txt
+.vscode
+.git
+makefile
+.ruff_cache/
+*.dat
+
+# Python bytecode / Byte-compiled / optimized / DLL files
+__pycache__/
+__pypackages__/
+*.pyc
+*.pyo
+*.pyd
+/.venv/
+*.py[cod]
+*$py.class
+
+# Local Poetry artifact cache
+/.cache/pypoetry/
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+*.py,cover
+.hypothesis/
+.pytest_cache/
+cover/
+
+# Environments
+*.env
+*.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# Rider IDE
+**/.idea/
+
+# MacOs
+**/.DS_Store
+
+
+#######################################################
+# Node.js
+#######################################################
+
 # Logs
 logs
 *.log
@@ -102,7 +164,6 @@ dist
 
 # vuepress v2.x temp and cache directory
 .temp
-.cache
 
 # Docusaurus cache and generated files
 .docusaurus

poetry.lock

@@ -0,0 +1,27 @@
+[tool.poetry]
+name = "thresh"
+version = "0.1.0"
+description = "WIP"
+authors = ["RivenMedia"]
+readme = "README.md"
+
+[tool.poetry.dependencies]
+python = "^3.11"
+scalar-fastapi = "^1.0.3"
+fastapi = "^0.115.0"
+requests = "^2.32.3"
+asyncio = "^3.4.3"
+rank-torrent-name = "^1.2.1"
+parsett = "^1.3.1"
+pydantic = "^2.9.2"
+pydantic-settings = "^2.5.2"
+uvicorn = "^0.30.6"
+loguru = "^0.7.2"
+rich = "^13.8.1"
+
+[tool.poetry.group.dev.dependencies]
+isort = "^5.13.2"
+
+[build-system]
+requires = ["poetry-core"]
+build-backend = "poetry.core.masonry.api"

pyproject.toml

@@ -0,0 +1,26 @@
+from fastapi import APIRouter, HTTPException, Request, UploadFile
+from RTN import parse
+from PTT import parse_title
+
+router = APIRouter(
+    prefix="",
+    tags=["default"],
+)
+
+
+@router.get(
+        "/",
+        summary="Root endpoint",
+        description="This endpoint is the root of the API. It is used to check if the API is running.",
+        include_in_schema=False,
+)
+async def read_root():
+    return {"message": "Welcome to Thresh!"}
+
+
+@router.post("/parse")
+async def parse_post(request: Request, filename: str, raw: bool = False):
+    """
+    Parse a file and return the parsed content.
+    """
+    return parse_title(filename) if raw else parse(filename, translate_langs=True)

src/__init__.py

@@ -0,0 +1,105 @@
+from fastapi import APIRouter, HTTPException, Request
+from pydantic import BaseModel
+from typing import List, Dict, Any
+
+router = APIRouter(
+    prefix="/flow",
+    tags=["flow"],
+)
+
+class Node(BaseModel):
+    id: str
+    type: str
+
+class Edge(BaseModel):
+    source: str
+    target: str
+
+class FlowData(BaseModel):
+    nodes: List[Node]
+    edges: List[Edge]
+
+class FlowRequest(BaseModel):
+    flow_data: FlowData
+    initial_input: Any
+
+class FlowResponse(BaseModel):
+    result: Any
+
+class ErrorResponse(BaseModel):
+    detail: str
+
+def execute_node(node_type, input_data):
+    # This function would contain the logic for each node type
+    if node_type == 'inputNode':
+        return input_data
+    elif node_type == 'multiplyNode':
+        return input_data * 2
+    elif node_type == 'addNode':
+        return input_data + 10
+    # Add more node types as needed
+
+def process_flow(flow_data, initial_input):
+    nodes = {node.id: node for node in flow_data.nodes}
+    edges = flow_data.edges
+    
+    # Create a dictionary to store the output of each node
+    node_outputs = {}
+    
+    # Process nodes in topological order (simplified for this example)
+    for node in flow_data.nodes:
+        node_id = node.id
+        node_type = node.type
+        
+        # Find input edges for this node
+        input_edges = [edge for edge in edges if edge.target == node_id]
+        
+        if not input_edges:
+            # This is an input node
+            node_outputs[node_id] = execute_node(node_type, initial_input)
+        else:
+            # Get the output from the source node of the first input edge
+            input_data = node_outputs[input_edges[0].source]
+            node_outputs[node_id] = execute_node(node_type, input_data)
+    
+    # Return the output of the last node (assuming it's the output node)
+    return node_outputs[flow_data.nodes[-1].id]
+
+@router.post("/process", response_model=FlowResponse, responses={400: {"model": ErrorResponse}, 500: {"model": ErrorResponse}})
+async def process_flow_endpoint(flow_request: FlowRequest):
+    """
+    Process a flow and return the result.
+
+    Example:
+    ```
+    curl -X 'POST' \
+      'http://localhost:8000/flow/process' \
+      -H 'accept: application/json' \
+      -H 'Content-Type: application/json' \
+      -d '{
+      "flow_data": {
+        "nodes": [
+          {"id": "1", "type": "inputNode"},
+          {"id": "2", "type": "multiplyNode"},
+          {"id": "3", "type": "addNode"}
+        ],
+        "edges": [
+          {"source": "1", "target": "2"},
+          {"source": "2", "target": "3"}
+        ]
+      },
+      "initial_input": 5
+    }'
+    ```
+    """
+    try:
+        flow_data = flow_request.flow_data
+        initial_input = flow_request.initial_input
+        
+        if not flow_data or initial_input is None:
+            raise HTTPException(status_code=400, detail="Invalid input data")
+        
+        result = process_flow(flow_data, initial_input)
+        return {"result": result}
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))

src/controllers/__init__.py

@@ -0,0 +1,111 @@
+import contextlib
+import signal
+import sys
+import threading
+import time
+import traceback
+
+import uvicorn
+from fastapi import FastAPI
+from fastapi.middleware.cors import CORSMiddleware
+from scalar_fastapi import get_scalar_api_reference
+from starlette.middleware.base import BaseHTTPMiddleware
+from starlette.requests import Request
+
+from controllers.default import router as default_router
+from controllers.flow import router as flow_router
+from program.program import Program
+from utils.logger import logger
+
+
+class LoguruMiddleware(BaseHTTPMiddleware):
+    async def dispatch(self, request: Request, call_next):
+        start_time = time.time()
+        try:
+            response = await call_next(request)
+        except Exception as e:
+            logger.exception(f"Exception during request processing: {e}")
+            raise
+        finally:
+            process_time = time.time() - start_time
+            logger.log(
+                "API",
+                f"{request.method} {request.url.path} - {response.status_code if 'response' in locals() else '500'} - {process_time:.2f}s",
+            )
+        return response
+
+
+app = FastAPI(
+    title="Thresh",
+    summary="A node based UI for use with Riven.",
+    version="0.1.0",  # TODO: add get_version()
+    redoc_url=None,
+    license_info={
+        "name": "GPL-3.0",
+        "url": "https://www.gnu.org/licenses/gpl-3.0.en.html",
+    },
+)
+
+@app.get("/scalar", include_in_schema=False)
+async def scalar_html():
+    return get_scalar_api_reference(
+        openapi_url=app.openapi_url,
+        title=app.title,
+    )
+
+
+app.add_middleware(LoguruMiddleware)
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+app.include_router(default_router)
+app.include_router(flow_router)
+
+app.program = Program()
+
+class Server(uvicorn.Server):
+    def install_signal_handlers(self):
+        pass
+
+    @contextlib.contextmanager
+    def run_in_thread(self):
+        thread = threading.Thread(target=self.run, name="Riven")
+        thread.start()
+        try:
+            while not self.started:
+                time.sleep(1e-3)
+            yield
+        except Exception as e:
+            logger.error(f"Error in server thread: {e}")
+            logger.exception(traceback.format_exc())
+            raise e
+        finally:
+            self.should_exit = True
+            sys.exit(0)
+
+def signal_handler(signum, frame):
+    logger.log("PROGRAM","Exiting Gracefully.")
+    app.program.stop()
+    sys.exit(0)
+
+signal.signal(signal.SIGINT, signal_handler)
+signal.signal(signal.SIGTERM, signal_handler)
+
+config = uvicorn.Config(app, host="0.0.0.0", port=5359, log_config=None)
+server = Server(config=config)
+
+with server.run_in_thread():
+    try:
+        app.program.start()
+        app.program.run()
+    except Exception as e:
+        logger.error(f"Error in main thread: {e}")
+        logger.exception(traceback.format_exc())
+    finally:
+        logger.critical("Server has been stopped")
+        sys.exit(0)

src/controllers/default.py

@@ -0,0 +1,22 @@
+import time
+
+from loguru import logger
+
+
+class Program:
+    def __init__(self):
+        self.initialized = False
+        self.running = False
+
+    def start(self):
+        self.running = True
+        logger.log("API", "API available at http://localhost:5359")
+        logger.log("PROGRAM", "Program started")
+
+    def run(self):
+        while self.running:
+            time.sleep(1)
+
+    def stop(self):
+        self.running = False
+        logger.log("PROGRAM", "Program stopped")