ara-api-web 1.1.0__py3-none-any.whl

ara_api_web/__init__.py

@@ -0,0 +1,5 @@
+__version__ = "1.1.0"
+# from .server import app, run_server  # ❌ пока закомментируй
+
+# __all__ = ["app", "run_server"]
+__all__ = []

ara_api_web/__main__.py

@@ -0,0 +1,26 @@
+from email.policy import default
+
+import click
+
+from ara_api_web._core.server import run_server
+
+
+@click.command
+@click.option(
+    "--host",
+    default="0.0.0.0",
+    help="Адрес хоста для сервера",
+    show_default=True,
+)
+@click.option(
+    "--port",
+    default=8080,
+    help="Порт для сервера",
+    show_default=True,
+)
+def main(host: str, port: int):
+    run_server(host=host, port=port)
+
+
+if __name__ == "__main__":
+    main()

ara_api_web/_core/__init__.py

@@ -0,0 +1,6 @@
+__version__ = "1.0.0"
+
+from ara_api_web._core.app import create_app
+from ara_api_web._core.server import run_server
+
+__all__ = ["create_app", "run_server"]

ara_api_web/_core/app.py

@@ -0,0 +1,34 @@
+from fastapi import FastAPI
+from fastapi.middleware.cors import CORSMiddleware
+from fastapi.staticfiles import StaticFiles
+
+from ara_api_web._core.routers import health
+from ara_api_web._core.routers.api import msp, navigation, vision
+from ara_api_web._utils.config import STATIC_DIR
+
+
+def create_app() -> FastAPI:
+    app = FastAPI(
+        title="ARA API Web Interface",
+        description="REST API wrapper for ARA drone control system",
+        version="1.1.0",  # ! HARD VERSION
+        docs_url=None,
+    )
+
+    app.add_middleware(
+        CORSMiddleware,
+        allow_origins=["*"],
+        allow_credentials=True,
+        allow_methods=["*"],
+        allow_headers=["*"],
+    )
+
+    app.include_router(router=health.router)
+    app.include_router(router=msp.router)
+    app.include_router(router=navigation.router)
+    app.include_router(router=vision.router)
+
+    if STATIC_DIR.exists():
+        app.mount("/", StaticFiles(directory=str(STATIC_DIR), html=True), name="static")
+
+    return app

ara_api_web/_core/models/__init__.py

@@ -0,0 +1,45 @@
+from ara_api_web._core.models.requests import (
+    LandRequest,
+    MoveRequest,
+    TakeoffRequest,
+    VelocityRequest,
+)
+from ara_api_web._core.models.responses import (
+    AltitudeResponse,
+    ArucoResponse,
+    AttitudeResponse,
+    BatteryResponse,
+    BlobResponse,
+    ImageResponse,
+    IMUResponse,
+    MotorResponse,
+    OpticalFlowResponse,
+    PositionResponse,
+    QRResponse,
+    SonarResponse,
+    StatusResponse,
+    VelocityResponse,
+)
+
+__all__ = [
+    # Requests
+    "TakeoffRequest",
+    "LandRequest",
+    "MoveRequest",
+    "VelocityRequest",
+    # Responses
+    "StatusResponse",
+    "IMUResponse",
+    "MotorResponse",
+    "AttitudeResponse",
+    "AltitudeResponse",
+    "SonarResponse",
+    "OpticalFlowResponse",
+    "PositionResponse",
+    "VelocityResponse",
+    "BatteryResponse",
+    "ImageResponse",
+    "ArucoResponse",
+    "BlobResponse",
+    "QRResponse",
+]

ara_api_web/_core/models/requests.py

@@ -0,0 +1,29 @@
+from typing import Optional
+
+from pydantic import BaseModel, Field
+
+
+# =====================================================================
+# NAVIGATION REST SERVICE MODELS
+# =====================================================================
+class TakeoffRequest(BaseModel):
+    altitude: float = Field(..., gt=0, description="Takeoff altitude in meters")
+
+
+class LandRequest(BaseModel):
+    pass
+
+
+class MoveRequest(BaseModel):
+    x: float = Field(..., description="X coordinate in meters")
+    y: float = Field(..., description="Y coordinate in meters")
+    z: float = Field(..., description="Z coordinate in meters")
+
+
+class VelocityRequest(BaseModel):
+    vx: float = Field(..., description="X velocity in m/s")
+    vy: float = Field(..., description="Y velocity in m/s")
+
+
+class AltitudeRequest(BaseModel):
+    altitude: float = Field(..., gt=0, description="Target altitude in meters")

ara_api_web/_core/models/responses.py

@@ -0,0 +1,108 @@
+from typing import Optional
+
+from pydantic import BaseModel
+
+
+class StatusResponse(BaseModel):
+    status: str
+    details: Optional[str] = None
+
+
+# =====================================================================
+# MSP REST SERVICE MODELS
+# =====================================================================
+class IMUResponse(BaseModel):
+    gyro_x: Optional[float] = None
+    gyro_y: Optional[float] = None
+    gyro_z: Optional[float] = None
+    acc_x: Optional[float] = None
+    acc_y: Optional[float] = None
+    acc_z: Optional[float] = None
+    error: Optional[str] = None
+
+
+class MotorResponse(BaseModel):
+    data: Optional[list] = None
+    error: Optional[str] = None
+
+
+class AttitudeResponse(BaseModel):
+    roll: Optional[float] = None
+    pitch: Optional[float] = None
+    yaw: Optional[float] = None
+    error: Optional[str] = None
+
+
+class AltitudeResponse(BaseModel):
+    altitude: Optional[float] = None
+    error: Optional[str] = None
+
+
+class SonarResponse(BaseModel):
+    data: Optional[float] = None
+    error: Optional[str] = None
+
+
+class OpticalFlowResponse(BaseModel):
+    quitity: Optional[int] = None
+    flow_rate_x: Optional[float] = None
+    flow_rate_y: Optional[float] = None
+    body_rate_x: Optional[float] = None
+    body_rate_y: Optional[float] = None
+    error: Optional[str] = None
+
+
+class PositionResponse(BaseModel):
+    x: Optional[float] = None
+    y: Optional[float] = None
+    z: Optional[float] = None
+    error: Optional[str] = None
+
+
+class VelocityResponse(BaseModel):
+    x: Optional[float] = None
+    y: Optional[float] = None
+    z: Optional[float] = None
+    error: Optional[str] = None
+
+
+class BatteryResponse(BaseModel):
+    voltage: Optional[float] = None
+    cell_count: Optional[int] = None
+    capacity: Optional[int] = None
+    error: Optional[str] = None
+
+
+# =====================================================================
+# MSP REST SERVICE MODELS
+# =====================================================================
+class ImageResponse(BaseModel):
+    height: Optional[int] = None
+    weight: Optional[int] = None
+    data: Optional[bytes] = None
+    noise: Optional[float] = None
+    error: Optional[str] = None
+
+
+class ArucoResponse(BaseModel):
+    id: Optional[int] = None
+    pos_x: Optional[float] = None
+    pos_y: Optional[float] = None
+    pos_z: Optional[float] = None
+    orient_x: Optional[float] = None
+    orient_y: Optional[float] = None
+    orient_z: Optional[float] = None
+    error: Optional[str] = None
+
+
+class BlobResponse(BaseModel):
+    id: Optional[int] = None
+    pos_x: Optional[float] = None
+    pos_y: Optional[float] = None
+    size: Optional[float] = None
+
+
+class QRResponse(BaseModel):
+    data: Optional[int] = None
+    pos_x: Optional[float] = None
+    pos_y: Optional[float] = None

ara_api_web/_core/routers/__init__.py

@@ -0,0 +1 @@
+

ara_api_web/_core/routers/api/msp.py

@@ -0,0 +1,175 @@
+from fastapi import APIRouter, Depends
+
+from ara_api_web._core.models import (
+    AltitudeResponse,
+    AttitudeResponse,
+    BatteryResponse,
+    IMUResponse,
+    MotorResponse,
+    OpticalFlowResponse,
+    PositionResponse,
+    SonarResponse,
+    VelocityResponse,
+)
+from ara_api_web._utils import (
+    get_grpc_client,
+    get_logger,
+    handle_grpc_errors,
+)
+
+router: APIRouter = APIRouter(prefix="/api/msp", tags=["MSP"])
+
+
+@router.get("/imu", response_model=IMUResponse)
+@handle_grpc_errors
+async def get_imu(
+    grpc_client=Depends(get_grpc_client),
+    logger=Depends(get_logger),
+) -> IMUResponse:
+    imu_data = grpc_client.msp_get_raw_imu()
+
+    if imu_data is None:
+        return IMUResponse(error="Failed to retrieve IMU data")
+
+    return IMUResponse(
+        gyro_x=imu_data.gyro.x,
+        gyro_y=imu_data.gyro.y,
+        gyro_z=imu_data.gyro.z,
+        acc_x=imu_data.acc.x,
+        acc_y=imu_data.acc.y,
+        acc_z=imu_data.acc.z,
+    )
+
+
+@router.get("/altitude", response_model=AltitudeResponse)
+@handle_grpc_errors
+async def get_altitude(
+    grpc_client=Depends(get_grpc_client),
+    logger=Depends(get_logger),
+) -> AltitudeResponse:
+    altitude_data = grpc_client.msp_get_altitude()
+
+    if altitude_data is None:
+        return AltitudeResponse(error="Failed to retrieve altitude")
+
+    return AltitudeResponse(altitude=altitude_data.data)
+
+
+@router.get("/position", response_model=PositionResponse)
+@handle_grpc_errors
+async def get_position(
+    grpc_client=Depends(get_grpc_client),
+    logger=Depends(get_logger),
+) -> PositionResponse:
+    position_data = grpc_client.msp_get_position()
+
+    if position_data is None:
+        return PositionResponse(error="Failed to retrieve position")
+
+    return PositionResponse(
+        x=position_data.data.x,
+        y=position_data.data.y,
+        z=position_data.data.z,
+    )
+
+
+@router.get("/attitude", response_model=AttitudeResponse)
+@handle_grpc_errors
+async def get_attitude(
+    grpc_client=Depends(get_grpc_client),
+    logger=Depends(get_logger),
+) -> AttitudeResponse:
+    attitude_data = grpc_client.msp_get_attitude()
+
+    if attitude_data is None:
+        return AttitudeResponse(error="Failed to retrieve attitude")
+
+    return AttitudeResponse(
+        roll=attitude_data.data.x,
+        pitch=attitude_data.data.y,
+        yaw=attitude_data.data.z,
+    )
+
+
+@router.get("/analog", response_model=BatteryResponse)
+@handle_grpc_errors
+async def get_analog(
+    grpc_client=Depends(get_grpc_client),
+    logger=Depends(get_logger),
+) -> BatteryResponse:
+    analog_data = grpc_client.msp_get_analog()
+
+    if analog_data is None:
+        return BatteryResponse(error="Failed to retrieve analog data")
+
+    return BatteryResponse(
+        voltage=analog_data.voltage,
+        cell_count=None,
+        capacity=analog_data.mAhdrawn,
+    )
+
+
+@router.get("/motor", response_model=MotorResponse)
+@handle_grpc_errors
+async def get_motor(
+    grpc_client=Depends(get_grpc_client),
+    logger=Depends(get_logger),
+) -> MotorResponse:
+    motor_data = grpc_client.msp_get_motor()
+
+    if motor_data is None:
+        return MotorResponse(error="Failed to retrieve motor data")
+
+    return MotorResponse(data=motor_data.data)
+
+
+@router.get("/optical_flow", response_model=OpticalFlowResponse)
+@handle_grpc_errors
+async def get_optical_flow(
+    grpc_client=Depends(get_grpc_client),
+    logger=Depends(get_logger),
+) -> OpticalFlowResponse:
+    flow_data = grpc_client.msp_get_optical_flow()
+
+    if flow_data is None:
+        return OpticalFlowResponse(error="Failed to retrieve optical flow")
+
+    return OpticalFlowResponse(
+        quitity=flow_data.quality,
+        flow_rate_x=flow_data.flow_rate.x,
+        flow_rate_y=flow_data.flow_rate.y,
+        body_rate_x=flow_data.body_rate.x,
+        body_rate_y=flow_data.body_rate.y,
+    )
+
+
+@router.get("/sonar", response_model=SonarResponse)
+@handle_grpc_errors
+async def get_sonar(
+    grpc_client=Depends(get_grpc_client),
+    logger=Depends(get_logger),
+) -> SonarResponse:
+    sonar_data = grpc_client.msp_get_sonar()
+
+    if sonar_data is None:
+        return SonarResponse(error="Failed to retrieve sonar data")
+
+    return SonarResponse(data=sonar_data.data)
+
+
+@router.get("/velocity", response_model=VelocityResponse)
+@handle_grpc_errors
+async def get_velocity(
+    grpc_client=Depends(get_grpc_client),
+    logger=Depends(get_logger),
+) -> VelocityResponse:
+    position_data = grpc_client.msp_get_position()
+
+    if position_data is None:
+        return VelocityResponse(error="Failed to retrieve velocity")
+
+    return VelocityResponse(
+        x=position_data.data.x,
+        y=position_data.data.x,
+        z=position_data.data.x,
+    )

ara_api_web/_core/routers/api/navigation.py

@@ -0,0 +1,113 @@
+from fastapi import APIRouter, Depends
+
+from ara_api_web._core.models import (
+    LandRequest,
+    MoveRequest,
+    StatusResponse,
+    TakeoffRequest,
+    VelocityRequest,
+)
+from ara_api_web._utils import (
+    altitude_data,
+    get_grpc_client,
+    get_logger,
+    get_request,
+    handle_grpc_errors,
+    vector2,
+    vector3,
+)
+
+router: APIRouter = APIRouter(prefix="/api/navigation", tags=["Navigation"])
+
+
+@router.post("/takeoff", response_model=StatusResponse)
+@handle_grpc_errors
+async def takeoff(
+    request: TakeoffRequest,
+    grpc_client=Depends(get_grpc_client),
+    logger=Depends(get_logger),
+) -> StatusResponse:
+    logger.debug(f"Takeoff command received: altitude={request.altitude}")
+
+    altitude_msg = altitude_data(data=request.altitude)
+    grpc_client.nav_cmd_takeoff(
+        altitude_msg,
+        [
+            ("client-id", "grpc-sync|REST"),
+        ],
+    )
+
+    return StatusResponse(
+        status="success",
+        details=f"Takeoff to {request.altitude}m initiated",
+    )
+
+
+@router.post("/land", response_model=StatusResponse)
+@handle_grpc_errors
+async def land(
+    request: LandRequest,
+    grpc_client=Depends(get_grpc_client),
+    logger=Depends(get_logger),
+) -> StatusResponse:
+    logger.debug("Landing command was called")
+
+    grpc_client.nav_cmd_land(
+        get_request(req="REST"),
+        [
+            ("client-id", "grpc-sync|REST"),
+        ],
+    )
+
+    return StatusResponse(
+        status="success",
+        details="Landing initiated",
+    )
+
+
+@router.post("/move", response_model=StatusResponse)
+@handle_grpc_errors
+async def move(
+    request: MoveRequest,
+    grpc_client=Depends(get_grpc_client),
+    logger=Depends(get_logger),
+) -> StatusResponse:
+    logger.info(f"Move command received: x={request.x}, y={request.y}, z={request.z}")
+
+    position_msg = vector3(x=request.x, y=request.y, z=request.z)
+    grpc_client.nav_cmd_move(
+        position_msg,
+        [
+            ("client-id", "grpc-sync|REST"),
+        ],
+    )
+
+    coords = f"({request.x}, {request.y})"
+    return StatusResponse(
+        status="success",
+        details=f"Move to {coords} initiated",
+    )
+
+
+@router.post("/speed", response_model=StatusResponse)
+@handle_grpc_errors
+async def speed(
+    request: VelocityRequest,
+    grpc_client=Depends(get_grpc_client),
+    logger=Depends(get_logger),
+) -> StatusResponse:
+    logger.debug(f"Speed command: vx={request.vx}, vy={request.vy}")
+
+    speed_msg = vector2(x=request.vx, y=request.vy)
+    grpc_client.nav_cmd_velocity(
+        speed_msg,
+        [
+            ("client-id", "grpc-sync|REST"),
+        ],
+    )
+
+    spd_str = f"({request.vx}, {request.vy})"
+    return StatusResponse(
+        status="success",
+        details=f"Velocity {spd_str} initiated",
+    )

ara_api_web/_core/routers/api/vision.py

@@ -0,0 +1,52 @@
+from fastapi import APIRouter, Depends
+
+from ara_api_web._utils import (
+    get_grpc_client,
+    get_logger,
+    handle_grpc_errors,
+)
+
+router = APIRouter(prefix="/api/vision", tags=["Vision"])
+
+
+@router.get("/image")
+@handle_grpc_errors
+async def get_image(
+    grpc_client=Depends(get_grpc_client),
+    logger=Depends(get_logger),
+):
+    logger.debug("Image request received")
+    return {"status": "not_implemented", "message": "Image API coming soon"}
+
+
+@router.get("/aruco")
+@handle_grpc_errors
+async def get_aruco(
+    grpc_client=Depends(get_grpc_client),
+    logger=Depends(get_logger),
+):
+    logger.debug("Aruco request received")
+    return {"status": "not_implemented", "message": "Aruco API coming soon"}
+
+
+@router.get("/qr")
+@handle_grpc_errors
+async def get_qr(
+    grpc_client=Depends(get_grpc_client),
+    logger=Depends(get_logger),
+):
+    logger.debug("QR code request received")
+    return {
+        "status": "not_implemented",
+        "message": "QR code API coming soon",
+    }
+
+
+@router.get("/blob")
+@handle_grpc_errors
+async def get_blob(
+    grpc_client=Depends(get_grpc_client),
+    logger=Depends(get_logger),
+):
+    logger.debug("Blob request received")
+    return {"status": "not_implemented", "message": "Blob API coming soon"}

ara_api_web/_core/routers/health.py

@@ -0,0 +1,12 @@
+from fastapi import APIRouter
+
+router = APIRouter(tags=["Health"])
+
+
+@router.get("/health")
+async def health_check():
+    return {
+        "status": "healthy",
+        "service": "ara-api-web",
+        "version": "1.1.0",
+    }

ara_api_web/_core/server.py

@@ -0,0 +1,63 @@
+import signal
+import sys
+from typing import Optional
+
+import uvicorn
+
+from ara_api_web._core.app import create_app
+from ara_api_web._utils import Logger, gRPCSync, init_dependencies
+from ara_api_web._utils.config import LOGGER_CONFIG, REST_CONFIG
+from ara_api_web._utils.ui import UI
+
+
+def run_server(host: Optional[str] = None, port: Optional[int] = None):
+    host = host or REST_CONFIG.HOST
+    port = port or REST_CONFIG.PORT
+
+    logger = Logger(
+        log_level=LOGGER_CONFIG.LOG_LEVEL,
+        log_to_file=LOGGER_CONFIG.LOG_TO_FILE,
+        log_to_terminal=LOGGER_CONFIG.LOG_TO_TERMINAL,
+        log_dir=LOGGER_CONFIG.LOG_DIR,
+    )
+
+    logger.debug(f"Starting REST API server on {host}:{port}")
+
+    try:
+        grpc = gRPCSync()
+    except Exception as e:
+        logger.error(f"Failed to initialize gRPC client: {e}")
+        sys.exit(-1)
+
+    init_dependencies(grpc=grpc, logger=logger)
+
+    app = create_app()
+
+    grpc_address = "50051, 50052, 50053"
+    ui = UI()
+    ui.display_startup_banner(host=host, port=port, grpc_address=grpc_address)
+
+    def signal_handler(sig, frame):
+        logger.debug(f"Received signal {sig}, shutting down gracefully")
+        sys.exit(0)
+
+    signal.signal(signal.SIGINT, signal_handler)
+    signal.signal(signal.SIGTERM, signal_handler)
+
+    try:
+        uvicorn.run(
+            app,
+            host=host,
+            port=port,
+            log_level="error",
+            access_log=True,
+        )
+    except Exception as e:
+        logger.error(f"Server error: {e}")
+        raise
+    finally:
+        logger.warning("REST API server stopped")
+
+
+if __name__ == "__main__":
+    run_server()