globe-server 0.0.30__py3-none-any.whl

globe_server/__init__.py

@@ -0,0 +1,5 @@
+"""Globe Server Backend Package"""
+
+__version__ = "0.1.0"
+__author__ = "Edward Catley"
+__description__ = "Globe Server Backend - Webserver control of Globe"

globe_server/api/__init__.py

@@ -0,0 +1,22 @@
+from fastapi import APIRouter
+from .status import router as status_router
+from .media import router as media_router
+from .motor import router as motor_router
+from .playlist import router as playlist_router
+from .playback import router as playback_router
+from .update import router as update_router
+from .settings import router as settings_router
+from .version import router as version_router
+
+
+api_router = APIRouter()
+
+api_router.include_router(status_router)
+api_router.include_router(media_router)
+api_router.include_router(motor_router)
+api_router.include_router(playlist_router)
+api_router.include_router(playback_router)
+api_router.include_router(update_router)
+api_router.include_router(settings_router)
+api_router.include_router(version_router)
+

globe_server/api/media.py

@@ -0,0 +1,191 @@
+# app/api/media.py
+from fastapi import APIRouter, Depends, HTTPException, Header, status, UploadFile, File, Form, Query
+from typing import List
+from sqlalchemy.orm import Session
+from globe_server.db.orm import Media
+from globe_server.db.database import create, update, delete, get_by_id, get_all
+from globe_server.db.schemas import MediaCreate, MediaRead, MediaUpdate, PlanetOptions
+from globe_server.utils import files
+from globe_server import config
+import os
+import logging
+import json
+
+router = APIRouter(prefix="/media", tags=["media"])
+
+@router.get("/files")
+def list_media_files(type: str = Query(..., regex="^(video|image)$")):
+    """List available media files on the server for a given type."""
+    try:
+        file_list = files.list_media_files(type)
+        return {"files": file_list}
+    except Exception as e:
+        logging.error(f"Error listing media files: {str(e)}", exc_info=True)
+        raise HTTPException(
+            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            detail=str(e)
+        )
+
+@router.post("/upload/")
+async def upload_file(
+    file: UploadFile = File(...),
+    media_type: str = Form(...),
+):
+    try:
+        if media_type == "image":
+            upload_directory = os.path.join(config.GLOBE_MEDIA_DIRECTORY, "Images")
+        elif media_type == "video":
+            upload_directory = os.path.join(config.GLOBE_MEDIA_DIRECTORY, "Videos")
+        else:
+            raise HTTPException(
+                status_code=status.HTTP_400_BAD_REQUEST,
+                detail=f"Invalid media type: {media_type}. Allowed types: image, video"
+            )
+
+        file_path = await files.save_uploaded_file(file, upload_directory)
+        return {"filepath": file_path}
+    except ValueError as e:
+        raise HTTPException(status_code=status.HTTP_400_BAD_REQUEST, detail=str(e))
+    except HTTPException as e:
+        raise e
+    except Exception as e:
+        raise HTTPException(status_code=status.HTTP_500_INTERNAL_SERVER_ERROR, detail=str(e))
+
+@router.get("/", response_model=List[MediaRead])
+def get_all_media():
+    try:
+        media_items = get_all(Media)
+        return media_items
+    except Exception as e:
+        logging.error(f"Error getting all media: {e}")
+        raise HTTPException(
+            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR, detail=str(e)
+        )
+
+@router.post("/", response_model=MediaRead)
+def create_media(media: MediaCreate):
+    try:
+        # Only validate filepath for image and video types
+        if media.type in ("image", "video"):
+            if not media.filepath or not os.path.exists(media.filepath):
+                raise HTTPException(
+                    status_code=status.HTTP_400_BAD_REQUEST,
+                    detail="Filepath is required and must exist for image and video types",
+                )
+
+        # Serialize planet_options to JSON string if it exists
+        planet_options_json = None
+        if media.planet_options:
+            if isinstance(media.planet_options, dict):
+                planet_options_json = json.dumps(media.planet_options)
+            else:
+                planet_options_json = media.planet_options.model_dump_json(exclude_none=True)
+
+        # Create new media item
+        db_media = Media(
+            type=media.type,
+            name=media.name,
+            filepath=media.filepath,
+            display_duration=media.display_duration,
+            planet_options=planet_options_json
+        )
+        
+        # Use CRUD function that handles broadcasting
+        db_media = create(db_media)
+        
+        return db_media
+    except Exception as e:
+        logging.error(f"Error creating media: {e}")
+        #db.rollback()
+        raise HTTPException(
+            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR, detail=str(e)
+        )
+
+@router.get("/{media_id}", response_model=MediaRead)
+def get_media(media_id: int):
+    try:
+        media = get_by_id(Media, media_id)
+        if media is None:
+            raise HTTPException(
+                status_code=status.HTTP_404_NOT_FOUND, detail="Media item not found"
+            )
+        return media
+    except HTTPException:
+        raise
+    except Exception as e:
+        logging.error(f"Error getting media: {e}")
+        raise HTTPException(
+            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR, detail=str(e)
+        )
+
+@router.put("/{media_id}", response_model=MediaRead)
+def update_media(media_id: int, media_update: MediaUpdate):
+    try:
+        # Get the existing media item
+        db_media = get_by_id(Media, media_id)
+        if db_media is None:
+            raise HTTPException(
+                status_code=status.HTTP_404_NOT_FOUND, detail="Media item not found"
+            )
+
+        # Update the fields that are provided
+        update_data = media_update.model_dump(exclude_unset=True)
+        
+        # Handle planet_options separately if it exists
+        if 'planet_options' in update_data and update_data['planet_options'] is not None:
+            if isinstance(update_data['planet_options'], dict):
+                db_media.planet_options = json.dumps(update_data['planet_options'])
+            else:
+                db_media.planet_options = update_data['planet_options'].model_dump_json(exclude_none=True)
+            del update_data['planet_options']
+
+        # Update all other fields
+        for key, value in update_data.items():
+            if value is not None:  # Only update non-None values
+                setattr(db_media, key, value)
+
+        # Use CRUD function that handles broadcasting
+        db_media = update(db_media)
+        
+        return db_media
+    except HTTPException:
+        raise
+    except Exception as e:
+        logging.error(f"Error updating media: {e}")
+        raise HTTPException(
+            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR, detail=str(e)
+        )
+
+@router.delete("/{media_id}")
+def delete_media(media_id: int):
+    try:
+        # Get the media item
+        db_media = get_by_id(Media, media_id)
+        if db_media is None:
+            raise HTTPException(
+                status_code=status.HTTP_404_NOT_FOUND, detail="Media item not found"
+            )
+        
+        # Store filepath and type before deletion
+        filepath = db_media.filepath
+        media_type = db_media.type
+        
+        # Delete the media item from the database using CRUD function
+        delete(db_media)
+        
+        # Delete the file from the file system if it's an image or video
+        if media_type in ("image", "video") and filepath:
+            try:
+                files.delete_file(filepath)
+            except Exception as e:
+                # Log the error but don't raise an exception, as the media item has already been deleted
+                logging.warning(f"Error deleting file: {e}")
+        
+        return {"message": "Media item deleted successfully"}
+    except HTTPException:
+        raise
+    except Exception as e:
+        logging.error(f"Error deleting media: {e}")
+        raise HTTPException(
+            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR, detail=str(e)
+        )

globe_server/api/motor.py

@@ -0,0 +1,44 @@
+# app/api/motor.py
+
+from fastapi import APIRouter, HTTPException, status
+from globe_server import config
+from globe_server.hardware.esp32_client import esp32_client, ESP32Error
+import logging
+
+logger = logging.getLogger(__name__)
+
+router = APIRouter(prefix="/motor", tags=["motor"])
+
+@router.post("/start")
+async def start_motor():
+    try:
+        await esp32_client.set_motor_speed(config.MOTOR_RPM)
+        return {"message": "Motor started successfully"}
+    except ESP32Error as e:
+        raise HTTPException(
+            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR, 
+            detail=str(e)
+        )
+
+@router.post("/stop")
+async def stop_motor():
+    try:
+        await esp32_client.set_motor_speed(0)
+        return {"message": "Motor stopped successfully"}
+    except ESP32Error as e:
+        raise HTTPException(
+            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR, 
+            detail=str(e)
+        )
+
+@router.get("/status")
+async def get_motor_status():
+    """Get the current motor status."""
+    try:
+        return await esp32_client.get_status()
+    except ESP32Error as e:
+        logger.error(f"Error getting motor status: {e}")
+        raise HTTPException(
+            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            detail=str(e)
+        )

globe_server/api/network.py

@@ -0,0 +1,73 @@
+from fastapi import APIRouter, Depends, HTTPException, Header, status
+from pydantic import BaseModel
+from typing import List, Optional
+from globe_server.network_manager.network_service import network_manager as state_machine, connect_to_wifi, scan_available_networks
+from globe_server.network_manager.models import NetworkInfo as NetworkInfoModel
+from globe_server.network_manager.platform import get_current_connection_info
+import logging
+
+logger = logging.getLogger(__name__)
+
+router = APIRouter(prefix="/network", tags=["network"])
+
+class WiFiConfig(BaseModel):
+    ssid: str
+    password: str
+
+# Use our model directly
+class WiFiNetwork(BaseModel):
+    ssid: str
+    signal_strength: int
+    security: str
+    
+    @classmethod
+    def from_model(cls, model: NetworkInfoModel) -> 'WiFiNetwork':
+        return cls(
+            ssid=model.ssid,
+            signal_strength=model.signal_strength,
+            security=model.security
+        )
+
+class WiFiStatus(BaseModel):
+    status: str  # FSM state (idle, connecting, connected, etc.)
+    current_ssid: str | None  # From OS
+    ip_address: str | None  # From OS
+    esp32_connected: bool  # From FSM
+    error: str | None = None  # From FSM
+
+
+@router.post("/wifi")
+async def configure_wifi(wifi_config: WiFiConfig):
+    """Initiate WiFi connection (async operation)."""
+    success = await connect_to_wifi(wifi_config.ssid, wifi_config.password)
+    if not success:
+        raise HTTPException(
+            status_code=status.HTTP_400_BAD_REQUEST, 
+            detail="Failed to initiate WiFi connection"
+        )
+    
+    return {"message": f"Connection to {wifi_config.ssid} initiated"}
+
+
+@router.get("/wifi/status", response_model=WiFiStatus)
+async def get_wifi_status():
+    """Get current WiFi connection status."""
+    # Query OS for real-time connection info
+    conn_info = await get_current_connection_info()
+    
+    return WiFiStatus(
+        status=state_machine.context.current_state.value,
+        current_ssid=conn_info.ssid,
+        ip_address=conn_info.ip_address,
+        esp32_connected=state_machine.context.esp32_connected,
+        error=state_machine.context.error_message
+    )
+
+@router.get("/wifi/scan", response_model=dict)
+async def scan_networks():
+    """Scan for available WiFi networks."""
+    network_models = await scan_available_networks()
+    networks = [WiFiNetwork.from_model(model) for model in network_models]
+    return {"networks": networks}
+
+

globe_server/api/playback.py

@@ -0,0 +1,59 @@
+from fastapi import APIRouter, HTTPException, status
+from fastapi.responses import JSONResponse
+import logging
+import asyncio
+from globe_server.playback import playback_service
+import time
+import vlc
+import subprocess
+from globe_server import config
+import os
+import json
+from typing import List, Optional, Dict, Any
+
+# Create router for REST endpoints
+router = APIRouter(prefix="/playback", tags=["playback"])
+
+# Configure logging
+logging.basicConfig(level=logging.INFO, format="%(asctime)s - %(levelname)s - %(message)s")
+
+# =====================================================================
+# API ENDPOINTS
+# =====================================================================
+
+@router.post("/play")
+async def play_playlist():
+    """Start playing the playlist or resume if paused."""
+    try:
+        if await playback_service.play():
+            return JSONResponse({"status": "success", "message": "Playback started/resumed"})
+        else:
+            return JSONResponse({"status": "error", "message": "Failed to start playback"})
+    except Exception as e:
+        logging.error(f"Error starting playback: {e}")
+        return JSONResponse({"status": "error", "message": str(e)})
+
+@router.post("/stop")
+async def stop_playback():
+    """Stop the current playback."""
+    try:
+        if await playback_service.stop():
+            return JSONResponse({"status": "success", "message": "Playback stopped"})
+        else:
+            return JSONResponse({"status": "error", "message": "Failed to stop playback"})
+    except Exception as e:
+        logging.error(f"Error stopping playback: {e}")
+        return JSONResponse({"status": "error", "message": str(e)})
+
+@router.post("/pause")
+async def pause_item():
+    """Pauses the currently playing media item."""
+    try:
+        if await playback_service.pause():
+            return JSONResponse({"status": "success", "message": "Playback paused"})
+        else:
+            return JSONResponse({"status": "error", "message": "Failed to pause playback"})
+    except Exception as e:
+        logging.error(f"Error pausing playback: {e}")
+        return JSONResponse({"status": "error", "message": str(e)})
+

globe_server/api/playlist.py

@@ -0,0 +1,182 @@
+# app/api/playlist.py
+
+from fastapi import APIRouter, Depends, HTTPException, status
+from typing import List, Optional
+from sqlalchemy.orm import Session
+
+from globe_server.db.orm import Media, PlaylistItem
+from globe_server.db.database import create, update, delete, get_by_id, get_all, get_max_position, get_all_ordered_by_position, update_playlist_position
+from globe_server.db.schemas import PlaylistItemCreate, PlaylistItemUpdate, PlaylistItemRead
+import os
+import logging
+
+# Create router for REST endpoints
+router = APIRouter(prefix="/playlist", tags=["playlist"])
+
+# Helper functions for consistent data handling using SQLAlchemy ORM
+
+def _get_playlist_item_with_media(playlist_id: int) -> Optional[PlaylistItem]:
+    """Fetch a single playlist item with its media data using ORM"""
+    return get_by_id(PlaylistItem, playlist_id)
+
+# =====================================================================
+# HELPER FUNCTIONS
+# =====================================================================
+
+def get_playlist_items() -> List[PlaylistItem]:
+    """
+    Get all playlist items ordered by position.
+    """
+    return get_all_ordered_by_position()
+
+# =====================================================================
+# API ENDPOINTS
+# =====================================================================
+
+@router.get("/", response_model=List[PlaylistItemRead])
+async def get_all_playlist_items():
+    """
+    Get all playlist items with complete media details.
+    
+    This endpoint is for direct REST API access to playlist data.
+    Real-time updates are now handled by the status WebSocket.
+    """
+    return get_playlist_items()
+
+@router.post("/", response_model=PlaylistItemRead)
+async def create_playlist_item(playlist_item: PlaylistItemCreate):
+    logging.info(f"=== CREATE PLAYLIST ITEM CALLED ===")
+    logging.info(f"Received playlist_item: {playlist_item}")
+    
+    try:
+        # Check if the media_id exists
+        logging.info(f"Checking if media_id {playlist_item.media_id} exists...")
+        media = get_by_id(Media, playlist_item.media_id)
+        if media is None:
+            logging.error(f"Media ID {playlist_item.media_id} not found")
+            raise HTTPException(
+                status_code=status.HTTP_400_BAD_REQUEST, detail="Invalid media_id"
+            )
+        logging.info(f"Media found: {media.name}")
+
+        # Get the next available position
+        logging.info("Getting next position...")
+        next_position = get_max_position() + 1
+        logging.info(f"Next position: {next_position}")
+
+        # Create new playlist item
+        logging.info("Creating PlaylistItem object...")
+        new_item = PlaylistItem(
+            media_id=playlist_item.media_id,
+            position=next_position,
+            status="unplayed",
+            elapsed_time=0
+        )
+        
+        # Use CRUD function that handles broadcasting
+        logging.info("Calling create() to save to database...")
+        new_item = create(new_item)
+        logging.info(f"Successfully created playlist item with ID: {new_item.id}")
+        
+        return new_item
+    except HTTPException:
+        raise
+    except Exception as e:
+        logging.error(f"Error creating playlist item: {e}", exc_info=True)
+        raise HTTPException(
+            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR, detail=str(e)
+        )
+
+@router.get("/{playlist_id}", response_model=PlaylistItemRead)
+async def get_playlist_item(playlist_id: int):
+    """
+    NOTE: This endpoint is not currently used by the frontend.
+    The frontend primarily receives playlist data via WebSockets.
+    
+    This endpoint is kept for API completeness, external tools,
+    and as a fallback mechanism.
+    """
+    playlist_item = _get_playlist_item_with_media(playlist_id)
+    if playlist_item is None:
+        raise HTTPException(
+            status_code=status.HTTP_404_NOT_FOUND, detail="Playlist item not found"
+        )
+        
+    return playlist_item
+
+@router.put("/{playlist_id}", response_model=PlaylistItemRead)
+async def update_playlist_item(playlist_id: int, playlist_item_update: PlaylistItemUpdate):
+    try:
+        # Check if the item exists
+        db_item = get_by_id(PlaylistItem, playlist_id)
+        if db_item is None:
+            raise HTTPException(
+                status_code=status.HTTP_404_NOT_FOUND, detail="Playlist item not found"
+            )
+            
+        # Check if media_id exists if it's being updated
+        if playlist_item_update.media_id is not None:
+            media = get_by_id(Media, playlist_item_update.media_id)
+            if media is None:
+                raise HTTPException(
+                    status_code=status.HTTP_400_BAD_REQUEST, detail="Invalid media_id"
+                )
+
+        # Update the playlist item attributes
+        update_data = playlist_item_update.model_dump(exclude_unset=True)
+        
+        # If position is being updated, use database function to handle shifts
+        if 'position' in update_data:
+            new_position = update_data['position']
+            logging.info(f"Updating item {playlist_id} position to {new_position}")
+            
+            # Database function handles shifting other items and updating this one
+            update_playlist_position(playlist_id, new_position)
+            
+            # Get the updated item to return
+            db_item = get_by_id(PlaylistItem, playlist_id)
+        else:
+            # No position change, just update other attributes
+            for key, value in update_data.items():
+                setattr(db_item, key, value)
+            db_item = update(db_item)
+        
+        # Broadcasting is now handled by the CRUD functions
+        return db_item
+    except HTTPException:
+        raise
+    except Exception as e:
+        logging.error(f"Error updating playlist item: {e}")
+        raise HTTPException(
+            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR, detail=str(e)
+        )
+
+@router.delete("/{playlist_id}")
+async def delete_playlist_item(playlist_id: int):
+    try:
+        # Check if the item exists
+        db_item = get_by_id(PlaylistItem, playlist_id)
+        if db_item is None:
+            raise HTTPException(
+                status_code=status.HTTP_404_NOT_FOUND, detail="Playlist item not found"
+            )
+            
+        # Delete the item using CRUD function
+        delete(db_item)
+
+        # Reset positions for remaining items
+        all_items = get_all_ordered_by_position()
+        for i, item in enumerate(all_items, 1):
+            if item.position != i:
+                item.position = i
+                update(item)
+        
+        # Broadcasting is now handled by the CRUD functions
+        return {"message": "Playlist item deleted successfully"}
+    except HTTPException:
+        raise
+    except Exception as e:
+        logging.error(f"Error deleting playlist item: {e}")
+        raise HTTPException(
+            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR, detail=str(e)
+        )

globe_server/api/settings.py

@@ -0,0 +1,67 @@
+# app/api/settings.py
+
+from fastapi import APIRouter, Depends, HTTPException, status
+from sqlalchemy.orm import Session
+
+from globe_server.db.orm import Settings
+from globe_server.db.schemas import SettingsRead, SettingsUpdate
+from globe_server.db.database import get_singleton, update, get_all
+from globe_server.utils import uart  # Import the uart module
+from globe_server import config
+import logging
+
+router = APIRouter(prefix="/settings", tags=["settings"])
+@router.get("/", response_model=SettingsRead)
+async def get_settings():
+    # Get singleton settings record
+    settings = get_singleton(Settings)
+    if not settings:
+        # This shouldn't happen because init_db creates settings
+        # But just in case, we'll return an error
+        raise HTTPException(status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+                            detail="Settings record not found in database")
+    
+    return settings
+
+@router.put("/", response_model=SettingsRead)
+async def update_settings(settings_update: SettingsUpdate):
+    try:
+        # Get existing settings
+        db_settings = get_singleton(Settings)
+        if not db_settings:
+            raise HTTPException(status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+                              detail="Settings record not found in database")
+        
+        # Update with new values
+        update_data = settings_update.model_dump(exclude_unset=True)
+        for key, value in update_data.items():
+            if value is not None:  # Only update non-None values
+                setattr(db_settings, key, value)
+        
+        # Send brightness values to FPGA via UART
+        red_brightness = getattr(settings_update, 'red_brightness', None)
+        if red_brightness is not None:
+            red_hex = uart.convert_brightness_to_hex(red_brightness)
+            red_command = uart.create_uart_message("red", red_hex)
+            uart.send_uart_command(red_command)
+            
+        green_brightness = getattr(settings_update, 'green_brightness', None)
+        if green_brightness is not None:
+            green_hex = uart.convert_brightness_to_hex(green_brightness)
+            green_command = uart.create_uart_message("green", green_hex)
+            uart.send_uart_command(green_command)
+            
+        blue_brightness = getattr(settings_update, 'blue_brightness', None)
+        if blue_brightness is not None:
+            blue_hex = uart.convert_brightness_to_hex(blue_brightness)
+            blue_command = uart.create_uart_message("blue", blue_hex)
+            uart.send_uart_command(blue_command)
+
+        # Save changes using CRUD function
+        db_settings = update(db_settings)
+        
+        return db_settings
+    except Exception as e:
+        logging.error(f"Error updating settings: {e}")
+        raise HTTPException(status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+                          detail=str(e))