Update the OP25 generator model to take either a string or an int

Reviewed-on: #2

.gitea/workflows/build.yml

@@ -0,0 +1,57 @@
+name: release-tag
+
+on:
+  push:
+    branches:
+      - master
+
+jobs:
+  release-image:
+    runs-on: ubuntu-latest
+    env:
+      DOCKER_LATEST: nightly
+      CONTAINER_NAME: drb-client-discord-bot
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+
+      - name: Set up QEMU
+        uses: docker/setup-qemu-action@v3
+
+      - name: Set up Docker BuildX
+        uses: docker/setup-buildx-action@v3
+        with: # replace it with your local IP
+          config-inline: |
+            [registry."git.vpn.cusano.net"] 
+              http = false
+              insecure = false            
+
+      - name: Login to DockerHub
+        uses: docker/login-action@v3
+        with:
+          registry: git.vpn.cusano.net # replace it with your local IP
+          username: ${{ secrets.GIT_REPO_USERNAME }}
+          password: ${{ secrets.GIT_REPO_PASSWORD }}
+          
+      - name: Get Meta
+        id: meta
+        run: |
+          echo REPO_NAME=$(echo ${GITHUB_REPOSITORY} | awk -F"/" '{print $2}') >> $GITHUB_OUTPUT
+          echo REPO_VERSION=$(git describe --tags --always | sed 's/^v//') >> $GITHUB_OUTPUT                
+
+      - name: Validate build configuration
+        uses: docker/build-push-action@v6
+        with:
+          call: check
+
+      - name: Build and push
+        uses: docker/build-push-action@v6
+        with:
+          context: .
+          file: ./Dockerfile
+          platforms: |
+            linux/arm64
+          push: true
+          tags: | # replace it with your local IP and tags
+            git.vpn.cusano.net/${{ vars.DOCKER_ORG }}/${{ steps.meta.outputs.REPO_NAME }}/${{ env.CONTAINER_NAME }}:${{ steps.meta.outputs.REPO_VERSION }}
+            git.vpn.cusano.net/${{ vars.DOCKER_ORG }}/${{ steps.meta.outputs.REPO_NAME }}/${{ env.CONTAINER_NAME }}:${{ env.DOCKER_LATEST }}

.gitea/workflows/lint.yml

@@ -0,0 +1,30 @@
+name: Lint
+
+on:
+  push:
+    branches:
+      - master
+  pull_request:
+    branches:
+      - "*"
+
+jobs:
+  lint:
+    runs-on: ubuntu-latest
+
+    steps:
+    - uses: actions/checkout@v4
+
+    - name: Set up Python
+      uses: actions/setup-python@v5
+      with:
+        python-version: '3.13'
+
+    - name: Install dependencies
+      run: |
+        python -m pip install --upgrade pip
+        pip install flake8
+
+    - name: Run Lint
+      run: |
+        flake8 --max-line-length=88 --ignore=E203,E302,E501 .

.gitignore

@@ -2,3 +2,4 @@ __pycache__*
 bot-poc.py
 configs*
 .env
+*.log*

Dockerfile

@@ -6,7 +6,8 @@ ENV DEBIAN_FRONTEND=noninteractive
 
 # Install system dependencies
 RUN apt-get update && \
-    apt-get install -y git \
+    apt-get install -y --no-install-recommends libc-bin apt-transport-https tzdata && \
+    apt-get install -y --no-install-recommends git \
     curl \
     python3 \
     python3-pip \
@@ -25,7 +26,9 @@ RUN apt-get update && \
     libportaudio2 \
     libpulse-dev \
     apulse \
-    ffmpeg 
+    ffmpeg \
+    liquidsoap \
+    supervisor
 
 # Clone the boatbod op25 repository
 RUN git clone -b gr310 https://github.com/boatbod/op25 /op25
@@ -36,6 +39,9 @@ WORKDIR /op25
 # Run the install script to set up op25
 RUN ./install.sh -f
 
+# Update the liquid file
+COPY op25.liq /op25/op25.liq
+
 # Install Python dependencies
 COPY requirements.txt /tmp/requirements.txt
 RUN pip3 install --no-cache-dir -r /tmp/requirements.txt
@@ -59,11 +65,14 @@ VOLUME ["/configs"]
 # Set the working directory in the container
 WORKDIR /app
 
+# Copy opus first to break up the build time
+COPY ./app/internal/opus /app/internal/opus
+
 # Copy the rest of the directory contents into the container at /app
 COPY ./app /app
 
-# Copy the pre-built opus libraries
-COPY ./opus /app/opus
+# Add Supervisord configuration
+COPY supervisord.conf /etc/supervisor/conf.d/supervisord.conf
 
-# Run the node script
-ENTRYPOINT ["uvicorn", "bot:app", "--host", "0.0.0.0", "--port", "8001", "--reload"]
+# Modify the ENTRYPOINT to run Supervisord
+ENTRYPOINT ["/usr/bin/supervisord", "-n", "-c", "/etc/supervisor/conf.d/supervisord.conf"]

Makefile

@@ -23,6 +23,16 @@ run: build
 		--network=host \
 		$(IMAGE_NAME)
 
+# Deploy docker
+deploy: build
+	docker run --rm -d \
+		--privileged \
+	    -v /dev:/dev \
+	    -v $(shell pwd)/configs:/configs \
+		--name $(CONTAINER_NAME) \
+		--network=host \
+		$(IMAGE_NAME)
+
 # Stop the Docker container
 stop:
 	docker stop $(CONTAINER_NAME)

app/bot.py

@@ -1,157 +0,0 @@
-import asyncio
-from typing import Optional, Dict
-
-from fastapi import FastAPI, HTTPException
-from pydantic import BaseModel
-import discord
-from discord.ext import commands
-from NoiseGatev2 import NoiseGate
-import op25_controller
-import pulse
-
-# Define FastAPI app
-app = FastAPI()
-
-# Discord Bot Setup
-intents = discord.Intents.default()
-intents.voice_states = True
-intents.guilds = True
-
-# Models for API requests
-class BotConfig(BaseModel):
-    token: str  # Discord Bot Token
-
-class VoiceChannelRequest(BaseModel):
-    guild_id: int
-    channel_id: int
-
-# Discord Bot Manager
-class DiscordBotManager:
-    def __init__(self):
-        self.bot: Optional[commands.Bot] = None
-        self.bot_task: Optional[asyncio.Task] = None
-        self.voice_clients: Dict[int, discord.VoiceClient] = {}
-        self.token: Optional[str] = None
-        self.loop = asyncio.get_event_loop()
-        self.lock = asyncio.Lock()
-
-    async def start_bot(self, token: str):
-        async with self.lock:
-            if self.bot and self.bot.is_closed():
-                raise RuntimeError("Bot is already running.")
-            if self.bot_task and not self.bot_task.done():
-                raise RuntimeError("Bot is already running.")
-
-            self.token = token
-            self.bot = commands.Bot(command_prefix="!", intents=intents)
-
-            @self.bot.event
-            async def on_ready():
-                print(f'Logged in as {self.bot.user}')
-
-            # Handle graceful shutdown when all voice connections are closed
-            @self.bot.event
-            async def on_voice_state_update(member, before, after):
-                # Check if all voice clients are disconnected
-                await asyncio.sleep(1)  # Give time for the state to update
-                if not self.voice_clients:
-                    await self.stop_bot()
-
-            # Start the bot in the background
-            self.bot_task = self.loop.create_task(self.bot.start(token))
-
-    async def stop_bot(self):
-        async with self.lock:
-            if self.bot:
-                await self.bot.close()
-                self.bot = None
-            if self.bot_task:
-                await self.bot_task
-                self.bot_task = None
-            self.voice_clients.clear()
-            print("Bot has been stopped.")
-
-    async def join_voice_channel(self, guild_id: int, channel_id: int, ng_threshold: int = 50, device_id: int = 4):
-        if not self.bot:
-            raise RuntimeError("Bot is not running.")
-
-        guild = self.bot.get_guild(guild_id)
-        if not guild:
-            raise ValueError("Guild not found.")
-
-        channel = guild.get_channel(channel_id)
-        if not isinstance(channel, discord.VoiceChannel):
-            raise ValueError("Channel is not a voice channel.")
-
-        if guild_id in self.voice_clients:
-            raise RuntimeError("Already connected to this guild's voice channel.")
-
-        voice_client = await channel.connect()
-        streamHandler = NoiseGate(
-                _input_device_index=device_id,
-                _voice_connection=voice_client,
-                _noise_gate_threshold=ng_threshold)
-            # Start the audio stream
-        streamHandler.run()
-        self.voice_clients[guild_id] = voice_client
-        print(f"Joined guild {guild_id} voice channel {channel_id}.")
-
-    async def leave_voice_channel(self, guild_id: int):
-        if not self.bot:
-            raise RuntimeError("Bot is not running.")
-
-        voice_client = self.voice_clients.get(guild_id)
-        if not voice_client:
-            raise RuntimeError("Not connected to the specified guild's voice channel.")
-
-        await voice_client.disconnect()
-        del self.voice_clients[guild_id]
-        print(f"Left guild {guild_id} voice channel.")
-
-# Initialize Discord Bot Manager
-bot_manager = DiscordBotManager()
-
-# API Endpoints
-@app.post("/start_bot")
-async def start_bot(config: BotConfig):
-    try:
-        await bot_manager.start_bot(config.token)
-        return {"status": "Bot started successfully."}
-    except Exception as e:
-        raise HTTPException(status_code=400, detail=str(e))
-
-@app.post("/stop_bot")
-async def stop_bot():
-    try:
-        await bot_manager.stop_bot()
-        return {"status": "Bot stopped successfully."}
-    except Exception as e:
-        raise HTTPException(status_code=400, detail=str(e))
-
-@app.post("/join_voice")
-async def join_voice_channel(request: VoiceChannelRequest):
-    try:
-        await bot_manager.join_voice_channel(request.guild_id, request.channel_id)
-        return {"status": f"Joined guild {request.guild_id} voice channel {request.channel_id}."}
-    except Exception as e:
-        raise HTTPException(status_code=400, detail=str(e))
-
-@app.post("/leave_voice")
-async def leave_voice_channel(request: VoiceChannelRequest):
-    try:
-        await bot_manager.leave_voice_channel(request.guild_id)
-        return {"status": f"Left guild {request.guild_id} voice channel."}
-    except Exception as e:
-        raise HTTPException(status_code=400, detail=str(e))
-
-@app.get("/status")
-async def get_status():
-    status = {
-        "bot_running": bot_manager.bot is not None and not bot_manager.bot.is_closed(),
-        "connected_guilds": list(bot_manager.voice_clients.keys())
-    }
-    return status
-
-
-app.include_router(op25_controller.router, prefix="/op25")
-app.include_router(pulse.router, prefix="/pulse")

app/internal/NoiseGatev2.py

@@ -1,15 +1,15 @@
 import audioop
-import logging
 import math
 import time
 
 import pyaudio
 import discord
 import numpy
+from internal.logger import create_logger
 
 voice_connection = None
 
-LOGGER = logging.getLogger("Discord_Radio_Bot.NoiseGateV2")
+LOGGER = create_logger(__name__)
 
 
 # noinspection PyUnresolvedReferences
@@ -30,15 +30,15 @@ class AudioStream:
             if _input:
                 self.paInstance_kwargs['input_device_index'] = _input_device_index
             else:
-                LOGGER.warning(f"[AudioStream.__init__]:\tInput was not enabled."
-                               f" Reinitialize with '_input=True'")
+                LOGGER.warning("[AudioStream.__init__]:\tInput was not enabled."
+                               " Reinitialize with '_input=True'")
 
         if _output_device_index:
             if _output:
                 self.paInstance_kwargs['output_device_index'] = _output_device_index
             else:
-                LOGGER.warning(f"[AudioStream.__init__]:\tOutput was not enabled."
-                               f" Reinitialize with '_output=True'")
+                LOGGER.warning("[AudioStream.__init__]:\tOutput was not enabled."
+                               " Reinitialize with '_output=True'")
 
         if _init_on_startup:
             # Init PyAudio instance
@@ -59,15 +59,15 @@ class AudioStream:
             if self.paInstance_kwargs['input']:
                 self.paInstance_kwargs['input_device_index'] = _new_input_device_index
             else:
-                LOGGER.warning(f"[AudioStream.init_stream]:\tInput was not enabled when initialized."
-                               f" Reinitialize with '_input=True'")
+                LOGGER.warning("[AudioStream.init_stream]:\tInput was not enabled when initialized."
+                               " Reinitialize with '_input=True'")
 
         if _new_output_device_index:
             if self.paInstance_kwargs['output']:
                 self.paInstance_kwargs['output_device_index'] = _new_output_device_index
             else:
-                LOGGER.warning(f"[AudioStream.init_stream]:\tOutput was not enabled when initialized."
-                               f" Reinitialize with '_output=True'")
+                LOGGER.warning("[AudioStream.init_stream]:\tOutput was not enabled when initialized."
+                               " Reinitialize with '_output=True'")
 
         self.close_if_open()
 
@@ -80,7 +80,7 @@ class AudioStream:
             if self.stream.is_active():
                 self.stream.stop_stream()
                 self.stream.close()
-                LOGGER.debug(f"[ReopenStream.close_if_open]:\t Stream was open; It was closed.")
+                LOGGER.debug("[ReopenStream.close_if_open]:\t Stream was open; It was closed.")
 
     def list_devices(self, _display_input_devices: bool = True, _display_output_devices: bool = True):
         LOGGER.info('Getting a list of the devices connected')
@@ -126,7 +126,7 @@ class NoiseGate(AudioStream):
     def run(self) -> None:
         global voice_connection
         # Start the audio stream
-        LOGGER.debug(f"Starting stream")
+        LOGGER.debug("Starting stream")
         self.stream.start_stream()
         # Start the stream to discord
         self.core()
@@ -139,15 +139,15 @@ class NoiseGate(AudioStream):
             time.sleep(.2)
 
         if not voice_connection.is_playing():
-            LOGGER.debug(f"Playing stream to discord")
+            LOGGER.debug("Playing stream to discord")
             voice_connection.play(self.NGStream, after=self.core)
 
     async def close(self):
-        LOGGER.debug(f"Closing")
+        LOGGER.debug("Closing")
         await voice_connection.disconnect()
         if self.stream.is_active:
             self.stream.stop_stream()
-            LOGGER.debug(f"Stopping stream")
+            LOGGER.debug("Stopping stream")
 
 
 # noinspection PyUnresolvedReferences

app/internal/bot_manager.py

@@ -0,0 +1,173 @@
+import asyncio
+import platform
+import os
+from discord import VoiceClient, VoiceChannel, opus, Activity, ActivityType, Intents
+from discord.ext import commands
+from typing import Optional, Dict
+from internal.NoiseGatev2 import NoiseGate
+from internal.logger import create_logger
+
+LOGGER = create_logger(__name__)
+
+# Configure discord intents
+intents = Intents.default()
+intents.voice_states = True
+intents.guilds = True
+
+class DiscordBotManager:
+    def __init__(self):
+        self.bot: Optional[commands.Bot] = None
+        self.bot_task: Optional[asyncio.Task] = None
+        self.voice_clients: Dict[int, VoiceClient] = {}
+        self.token: Optional[str] = None
+        self.loop = asyncio.get_event_loop()
+        self.lock = asyncio.Lock()
+        self._ready_event = asyncio.Event()
+        self._voice_ready_event = asyncio.Event()
+
+    async def start_bot(self, token: str):
+        async with self.lock:
+            if self.bot and not self.bot.is_closed():
+                raise RuntimeError("Bot is already running.")
+            if self.bot_task and not self.bot_task.done():
+                raise RuntimeError("Bot is already running.")
+
+            self.token = token
+            self.bot = commands.Bot(command_prefix="!", intents=intents)
+
+            @self.bot.event
+            async def on_ready():
+                LOGGER.info(f'Logged in as {self.bot.user}')
+                # Set the event when on_ready is called
+                self._ready_event.set()
+
+            @self.bot.event
+            async def on_voice_state_update(member, before, after):
+                # Check if the bot was disconnected
+                if member == self.bot.user and after.channel is None:
+                    guild_id = before.channel.guild.id
+                    if not self.voice_clients.get(guild_id):
+                        LOGGER.info("Bot has left channel, reconnection ignored.")
+                        return
+                    LOGGER.info(f"Bot was disconnected from channel in guild {guild_id}. Attempting to reconnect...")
+                    try:
+                        await self.leave_voice_channel(guild_id)
+                    except Exception as e:
+                        LOGGER.warning(f"Error leaving voice channel: '{e}'")
+                    # Attempt to reconnect to the channel after a brief pause
+                    await asyncio.sleep(2)
+                    await self.join_voice_channel(guild_id, before.channel.id)
+
+                if member == self.bot.user and before.channel is None and after.channel is not None:
+                    print(f"{member.name} joined voice channel {after.channel.name}")
+                    self._voice_ready_event.set()
+
+            # Load Opus for the current CPU
+            await self.load_opus()
+
+            # Create the task to run the bot in the background
+            self.bot_task = self.loop.create_task(self.bot.start(token))
+
+        # Wait for the on_ready event to be set by the bot task
+        LOGGER.info("Waiting for bot to become ready...")
+        try:
+            await asyncio.wait_for(self._ready_event.wait(), timeout=60.0)
+            LOGGER.info("Bot is ready, start_bot returning.")
+            return
+        except asyncio.TimeoutError:
+             LOGGER.error("Timeout waiting for bot to become ready. Bot might have failed to start.")
+             if self.bot_task and not self.bot_task.done():
+                 self.bot_task.cancel()
+             raise RuntimeError("Bot failed to become ready within timeout.")
+
+    async def stop_bot(self):
+        async with self.lock:
+            if self.bot:
+                await self.bot.close()
+                self.bot = None
+            if self.bot_task:
+                await self.bot_task
+                self.bot_task = None
+            self.voice_clients.clear()
+            self._ready_event.clear()
+            LOGGER.info("Bot has been stopped.")
+
+    async def join_voice_channel(self, guild_id: int, channel_id: int, ng_threshold: int = 50, device_id: int = 4):
+        if not self.bot:
+            raise RuntimeError("Bot is not running.")
+
+        guild = self.bot.get_guild(guild_id)
+        if not guild:
+            raise ValueError("Guild not found.")
+
+        if not opus.is_loaded():
+            raise RuntimeError("Opus is not loaded.")
+
+        channel = guild.get_channel(channel_id)
+        if not isinstance(channel, VoiceChannel):
+            raise ValueError("Channel is not a voice channel.")
+
+        if guild_id in self.voice_clients:
+            raise RuntimeError("Already connected to this guild's voice channel.")
+
+        try:
+            voice_client = await channel.connect(timeout=60.0, reconnect=True)
+            LOGGER.debug("Voice Connected.")
+            streamHandler = NoiseGate(
+                _input_device_index=device_id,
+                _voice_connection=voice_client,
+                _noise_gate_threshold=ng_threshold)
+            streamHandler.run()
+            LOGGER.debug("Stream is running.")
+            self.voice_clients[guild_id] = voice_client
+            LOGGER.info(f"Joined guild {guild_id} voice channel {channel_id} and stream is running.")
+        except Exception as e:
+            LOGGER.error(f"Failed to connect to voice channel: {e}")
+
+        LOGGER.info("Waiting for bot to join voice...")
+        try:
+            await asyncio.wait_for(self._voice_ready_event.wait(), timeout=60.0)
+            LOGGER.info("Bot joined voice, returning.")
+            return
+        except asyncio.TimeoutError:
+             LOGGER.error("Timeout waiting for bot to join voice.")
+             raise RuntimeError("Bot failed to join voice within timeout.")
+
+    async def leave_voice_channel(self, guild_id: int):
+        if not self.bot:
+            raise RuntimeError("Bot is not running.")
+
+        voice_client = self.voice_clients.get(guild_id)
+        if not voice_client:
+            raise RuntimeError("Not connected to the specified guild's voice channel.")
+
+        await voice_client.disconnect()
+        del self.voice_clients[guild_id]
+        LOGGER.info(f"Left guild {guild_id} voice channel.")
+
+    async def load_opus(self):
+        """ Load the proper OPUS library for the device being used """
+        processor = platform.machine()
+        script_dir = os.path.dirname(os.path.abspath(__file__))
+        LOGGER.debug("Processor: ", processor)
+        if os.name == 'nt':
+            if processor == "AMD64":
+                opus.load_opus(os.path.join(script_dir, './opus/libopus_amd64.dll'))
+                LOGGER.info("Loaded OPUS library for AMD64")
+                return "AMD64"
+        else:
+            if processor == "aarch64":
+                opus.load_opus(os.path.join(script_dir, './opus/libopus_aarcch64.so'))
+                LOGGER.info("Loaded OPUS library for aarch64")
+                return "aarch64"
+            elif processor == "armv7l":
+                opus.load_opus(os.path.join(script_dir, './opus/libopus_armv7l.so'))
+                LOGGER.info("Loaded OPUS library for armv7l")
+                return "armv7l"
+
+    async def set_presence(self, presence: str):
+        """ Set the presense (activity) of the bot """
+        try:
+            await self.bot.change_presence(activity=Activity(type=ActivityType.listening, name=presence))
+        except Exception as pe:
+            LOGGER.error(f"Unable to set presence: '{pe}'")

app/internal/logger.py

@@ -0,0 +1,55 @@
+import logging
+from logging.handlers import RotatingFileHandler
+
+def create_logger(name, level=logging.DEBUG, max_bytes=10485760, backup_count=2):
+    """
+    Creates a logger with a console and rotating file handlers for both debug and info log levels.
+
+    Args:
+        name (str): The name for the logger.
+        level (int): The logging level for the logger. Defaults to logging.DEBUG.
+        max_bytes (int): Maximum size of the log file in bytes before it gets rotated. Defaults to 10 MB.
+        backup_count (int): Number of backup files to keep. Defaults to 2.
+
+    Returns:
+        logging.Logger: Configured logger.
+    """
+    # Set the log file paths
+    debug_log_file = "./client.debug.log"
+    info_log_file = "./client.log"
+
+    # Create a logger
+    logger = logging.getLogger(name)
+    logger.setLevel(level)
+
+    # Check if the logger already has handlers to avoid duplicate logs
+    if not logger.hasHandlers():
+        # Create console handler
+        console_handler = logging.StreamHandler()
+        console_handler.setLevel(level)
+
+        # Create rotating file handler for debug level
+        debug_file_handler = RotatingFileHandler(debug_log_file, maxBytes=max_bytes, backupCount=backup_count)
+        debug_file_handler.setLevel(logging.DEBUG)
+
+        # Create rotating file handler for info level
+        info_file_handler = RotatingFileHandler(info_log_file, maxBytes=max_bytes, backupCount=backup_count)
+        info_file_handler.setLevel(logging.INFO)
+
+        # Create formatter and add it to the handlers
+        formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s')
+        console_handler.setFormatter(formatter)
+        debug_file_handler.setFormatter(formatter)
+        info_file_handler.setFormatter(formatter)
+
+        # Add the handlers to the logger
+        logger.addHandler(console_handler)
+        logger.addHandler(debug_file_handler)
+        logger.addHandler(info_file_handler)
+
+    return logger
+
+# Example usage:
+# logger = create_logger('my_logger')
+# logger.debug('This is a debug message')
+# logger.info('This is an info message')

app/main.py

@@ -0,0 +1,15 @@
+from fastapi import FastAPI
+import routers.op25_controller as op25_controller
+import routers.pulse as pulse
+import routers.bot as bot
+from internal.logger import create_logger
+
+# Initialize logging
+LOGGER = create_logger(__name__)
+
+# Define FastAPI app
+app = FastAPI()
+
+app.include_router(op25_controller.router, prefix="/op25")
+app.include_router(pulse.router, prefix="/pulse")
+app.include_router(bot.router, prefix="/bot")

app/models.py

@@ -0,0 +1,104 @@
+from pydantic import BaseModel
+from typing import List, Optional, Union
+from enum import Enum
+
+
+class BotConfig(BaseModel):
+    token: str
+
+class VoiceChannelJoinRequest(BaseModel):
+    guild_id: int
+    channel_id: int
+
+class VoiceChannelLeaveRequest(BaseModel):
+    guild_id: int
+
+class DecodeMode(str, Enum):
+    P25 = "P25"
+    DMR = "DMR"
+    ANALOG = "NBFM"
+
+class TalkgroupTag(BaseModel):
+    talkgroup: str
+    tagDec: int
+
+class ConfigGenerator(BaseModel):
+    type: DecodeMode
+    systemName: str
+    channels: List[Union[int, str]]
+    tags: Optional[List[TalkgroupTag]]
+    whitelist: Optional[List[int]]
+
+class DemodType(str, Enum):
+    CQPSK = "cqpsk"
+    FSK4 = "fsk4"
+
+class FilterType(str, Enum):
+    RC = "rc"
+    WIDEPULSE = "widepulse"
+
+class ChannelConfig(BaseModel):
+    name: str
+    trunking_sysname: Optional[str]
+    enable_analog: str
+    demod_type: DemodType
+    filter_type: FilterType
+    device: Optional[str] = "sdr"
+    cqpsk_tracking: Optional[bool] = None
+    frequency: Optional[float] = None
+    nbfmSquelch: Optional[float] = None
+    destination: Optional[str] = "udp://127.0.0.1:23456"
+    tracking_threshold: Optional[int] = 120
+    tracking_feedback: Optional[float] = 0.75
+    excess_bw: Optional[float] = 0.2
+    if_rate: Optional[int] = 24000
+    plot: Optional[str] = ""
+    symbol_rate: Optional[int] = 4800
+    blacklist: Optional[str] = ""
+    whitelist: Optional[str] = ""
+
+class DeviceConfig(BaseModel):
+    args: Optional[str] = "rtl"
+    gains: Optional[str] = "lna:39"
+    gain_mode: Optional[bool] = False
+    name: Optional[str] = "sdr"
+    offset: Optional[int] = 0
+    ppm: Optional[float] = 0.0
+    rate: Optional[int] = 1920000
+    usable_bw_pct: Optional[float] = 0.85
+    tunable: Optional[bool] = True
+
+class TrunkingChannelConfig(BaseModel):
+    sysname: str
+    control_channel_list: str
+    tagsFile: Optional[str] = None
+    whitelist: Optional[str] = None
+    nac: Optional[str] = ""
+    wacn: Optional[str] = ""
+    tdma_cc: Optional[bool] = False
+    crypt_behavior: Optional[int] = 2
+
+class TrunkingConfig(BaseModel):
+    module: str
+    chans: List[TrunkingChannelConfig]
+
+class AudioInstanceConfig(BaseModel):
+    instance_name: Optional[str] = "audio0"
+    device_name: Optional[str] = "pulse"
+    udp_port: Optional[int] = 23456
+    audio_gain: Optional[float] = 2.5
+    number_channels: Optional[int] = 1
+
+class AudioConfig(BaseModel):
+    module: Optional[str] = "sockaudio.py"
+    instances: Optional[List[AudioInstanceConfig]] = [AudioInstanceConfig()]
+
+class TerminalConfig(BaseModel):
+    module: Optional[str] = "terminal.py"
+    terminal_type: Optional[str] = "http:0.0.0.0:8081"
+    terminal_timeout: Optional[float] = 5.0
+    curses_plot_interval: Optional[float] = 0.2
+    http_plot_interval: Optional[float] = 1.0
+    http_plot_directory: Optional[str] = "../www/images"
+    tuning_step_large: Optional[int] = 1200
+    tuning_step_small: Optional[int] = 100

app/routers/bot.py

@@ -0,0 +1,57 @@
+from fastapi import APIRouter, HTTPException
+from models import BotConfig, VoiceChannelJoinRequest, VoiceChannelLeaveRequest
+from internal.bot_manager import DiscordBotManager
+from internal.logger import create_logger
+
+LOGGER = create_logger(__name__)
+
+# Define FastAPI app
+router = APIRouter()
+
+# Initialize Discord Bot Manager
+bot_manager = DiscordBotManager()
+
+# API Endpoints
+@router.post("/start_bot")
+async def start_bot(config: BotConfig):
+    try:
+        await bot_manager.start_bot(config.token)
+        return {"status": "Bot started successfully."}
+    except Exception as e:
+        LOGGER.error(f"Error starting bot: {e}")
+        raise HTTPException(status_code=400, detail=str(e))
+
+@router.post("/stop_bot")
+async def stop_bot():
+    try:
+        await bot_manager.stop_bot()
+        return {"status": "Bot stopped successfully."}
+    except Exception as e:
+        LOGGER.error(f"Error stopping bot: {e}")
+        raise HTTPException(status_code=400, detail=str(e))
+
+@router.post("/join_voice")
+async def join_voice_channel(request: VoiceChannelJoinRequest):
+    try:
+        await bot_manager.join_voice_channel(request.guild_id, request.channel_id)
+        return {"status": f"Joined guild {request.guild_id} voice channel {request.channel_id}."}
+    except Exception as e:
+        LOGGER.error(f"Error joining voice channel: {e}")
+        raise HTTPException(status_code=400, detail=str(e))
+
+@router.post("/leave_voice")
+async def leave_voice_channel(request: VoiceChannelLeaveRequest):
+    try:
+        await bot_manager.leave_voice_channel(request.guild_id)
+        return {"status": f"Left guild {request.guild_id} voice channel."}
+    except Exception as e:
+        LOGGER.error(f"Error leaving voice channel: {e}")
+        raise HTTPException(status_code=400, detail=str(e))
+
+@router.get("/status")
+async def get_status():
+    status = {
+        "bot_running": bot_manager.bot is not None and not bot_manager.bot.is_closed(),
+        "connected_guilds": list(bot_manager.voice_clients.keys())
+    }
+    return status

app/routers/op25_controller.py

@@ -1,14 +1,15 @@
-from fastapi import FastAPI, HTTPException, APIRouter
-from pydantic import BaseModel
-from enum import Enum
+from fastapi import HTTPException, APIRouter
 import subprocess
 import os
 import signal
 import json
 import csv
-from typing import List, Optional, Union
+from models import ConfigGenerator, DecodeMode, ChannelConfig, DeviceConfig, TrunkingConfig, TrunkingChannelConfig, AudioConfig, TerminalConfig, TalkgroupTag
+from internal.logger import create_logger
+from typing import List
 
 router = APIRouter()
+LOGGER = create_logger(__name__)
 
 op25_process = None
 OP25_PATH = "/op25/op25/gr-op25_repeater/apps/"
@@ -20,7 +21,7 @@ async def start_op25():
     if op25_process is None:
         try:
             op25_process = subprocess.Popen(os.path.join(OP25_PATH, OP25_SCRIPT), shell=True, preexec_fn=os.setsid, cwd=OP25_PATH)
-            print(op25_process)
+            LOGGER.debug(op25_process)
             return {"status": "OP25 started"}
         except Exception as e:
             raise HTTPException(status_code=500, detail=str(e))
@@ -44,96 +45,6 @@ async def stop_op25():
 async def get_status():
     return {"status": "running" if op25_process else "stopped"}
 
-class DecodeMode(str, Enum):
-    P25 = "P25"
-    DMR = "DMR"
-    ANALOG = "NBFM"
-
-class TalkgroupTag(BaseModel):
-    talkgroup: str
-    tagDec: int
-
-class ConfigGenerator(BaseModel):
-    type: DecodeMode
-    systemName: str
-    channels: List[str]
-    tags: List[TalkgroupTag]
-    whitelist: List[int]
-
-class DemodType(str, Enum):
-    CQPSK = "cqpsk"
-    FSK4 = "fsk4"
-
-class FilterType(str, Enum):
-    RC = "rc"
-    WIDEPULSE = "widepulse"
-
-class ChannelConfig(BaseModel):
-    name: str
-    trunking_sysname: Optional[str]
-    enable_analog: str
-    demod_type: DemodType
-    filter_type: FilterType
-    device: Optional[str] = "sdr"
-    cqpsk_tracking: Optional[bool] = None
-    frequency: Optional[float] = None
-    nbfmSquelch: Optional[float] = None
-    destination: Optional[str] = "udp://127.0.0.1:23456"
-    tracking_threshold: Optional[int] = 120
-    tracking_feedback: Optional[float] = 0.75
-    excess_bw: Optional[float] = 0.2
-    if_rate: Optional[int] = 24000
-    plot: Optional[str] = ""
-    symbol_rate: Optional[int] = 4800
-    blacklist: Optional[str] = ""
-    whitelist: Optional[str] = ""
-    
-class DeviceConfig(BaseModel):
-    args: Optional[str] = "rtl"
-    gains: Optional[str] = "lna:39"
-    gain_mode: Optional[bool] = False
-    name: Optional[str] = "sdr"
-    offset: Optional[int] = 0
-    ppm: Optional[float] = 0.0
-    rate: Optional[int] = 1920000
-    usable_bw_pct: Optional[float] = 0.85
-    tunable: Optional[bool] = True
-
-class TrunkingChannelConfig(BaseModel):
-    sysname: str
-    control_channel_list: str
-    tagsFile: Optional[str] = None
-    whitelist: Optional[str] = None
-    nac: Optional[str] = ""
-    wacn: Optional[str] = ""
-    tdma_cc: Optional[bool] = False
-    crypt_behavior: Optional[int] = 2
-
-class TrunkingConfig(BaseModel):
-    module: str
-    chans: List[TrunkingChannelConfig]
-
-class AudioInstanceConfig(BaseModel):
-    instance_name: Optional[str] = "audio0"
-    device_name: Optional[str] = "pulse"
-    udp_port: Optional[int] = 23456
-    audio_gain: Optional[float] = 2.5
-    number_channels: Optional[int] = 1
-
-class AudioConfig(BaseModel):
-    module: Optional[str] = "sockaudio.py"
-    instances: Optional[List[AudioInstanceConfig]] = [AudioInstanceConfig()]
-
-class TerminalConfig(BaseModel):
-    module: Optional[str] = "terminal.py"
-    terminal_type: Optional[str] = "http:0.0.0.0:8081"
-    terminal_timeout: Optional[float] = 5.0
-    curses_plot_interval: Optional[float] = 0.2
-    http_plot_interval: Optional[float] = 1.0
-    http_plot_directory: Optional[str] = "../www/images"
-    tuning_step_large: Optional[int] = 1200
-    tuning_step_small: Optional[int] = 100
-
 @router.post("/generate-config")
 async def generate_config(generator: ConfigGenerator):
     try:
@@ -194,7 +105,7 @@ async def generate_config(generator: ConfigGenerator):
         with open('/configs/active.cfg.json', 'w') as f:
             json.dump(del_none_in_dict(config_dict), f, indent=2)
 
-        return {"message": f"Config exported to '/configs/active.cfg.json'"}
+        return {"message": "Config exported to '/configs/active.cfg.json'"}
     except Exception as e:
         raise HTTPException(status_code=500, detail=str(e))
 
@@ -231,7 +142,7 @@ def del_none_in_dict(d):
     This alters the input so you may wish to ``copy`` the dict first.
     """
     for key, value in list(d.items()):
-        print(f"Key: '{key}'\nValue: '{value}'")
+        LOGGER.info(f"Key: '{key}'\nValue: '{value}'")
         if value is None:
             del d[key]
         elif isinstance(value, dict):

op25.liq

@@ -0,0 +1,54 @@
+#!/usr/bin/liquidsoap
+
+# Example liquidsoap streaming from op25 to icecast
+# (c) 2019-2021 gnorbury@bondcar.com, wllmbecks@gmail.com
+#
+
+set("log.stdout", true)
+set("log.file", false)
+set("log.level", 1)
+
+# Make the native sample rate compatible with op25
+set("frame.audio.samplerate", 8000)
+
+input = mksafe(input.external(buffer=0.25, channels=2, samplerate=8000, restart_on_error=false, "./audio.py -x 1.5 -s"))
+# Consider increasing the buffer value on slow systems such as RPi3. e.g. buffer=0.25
+# Longer buffer results in less choppy audio but at the expense of increased latency.
+
+
+# OPTIONAL AUDIO SIGNAL PROCESSING BLOCKS 
+# Uncomment to enable
+#
+# High pass filter
+#input = filter.iir.butterworth.high(frequency = 200.0, order = 4, input)
+
+# Low pass filter
+#input = filter.iir.butterworth.low(frequency = 3250.0, order = 4, input)
+
+# Compression
+input = compress(input, attack = 2.0, gain = 0.0, knee = 13.0, ratio = 2.0, release = 12.3, threshold = -18.0)
+
+# Normalization
+input = normalize(input, gain_max = 6.0, gain_min = -6.0, target = -16.0, threshold = -65.0)
+
+
+# LOCAL AUDIO OUTPUT
+# Uncomment the appropriate line below to enable local sound
+#
+# Default audio subsystem
+#out (input)
+#
+# PulseAudio
+#output.pulseaudio(input)
+#
+# ALSA
+#output.alsa(input)
+
+
+
+# ICECAST STREAMING
+# Uncomment to enable output to an icecast server
+# Change the "host", "password", and "mount" strings appropriately first!
+# For metadata to work properly, the host address given here MUST MATCH the address in op25's meta.json file
+#
+output.icecast(%mp3(bitrate=16, samplerate=22050, stereo=false), description="op25", genre="Public Safety", url="", fallible=false, host="localhost", port=8000, mount="mountpoint", password="hackme", mean(input))

supervisord.conf

@@ -0,0 +1,20 @@
+[supervisord]
+nodaemon=true
+
+[program:op25-liq]
+command=/usr/bin/liquidsoap /op25/op25.liq
+directory=/op25
+autostart=true
+autorestart=true
+stderr_logfile=/var/log/supervisor/op25-liq.err.log
+stdout_logfile=/var/log/supervisor/op25-liq.out.log
+user=root
+
+[program:drb-client-discord]
+command=uvicorn main:app --host 0.0.0.0 --port 8001 --reload
+directory=/app
+autostart=true
+autorestart=true
+stderr_logfile=/var/log/supervisor/main_app.err.log
+stdout_logfile=/var/log/supervisor/main_app.out.log
+user=root