Best Practices

# Good: .gitignore already includes config.env
*.env
config.env

chmod 600 config.env

def _is_authorized(self, user_id: int, chat_id: int) -> bool:
    if self._is_owner(user_id):
        return True
    if self.auth_service.is_configured_id_authorized(chat_id):
        return True
    if self.auth_service.is_temporary_id_authorized(chat_id):
        return True
    if user_id and self.auth_service.is_configured_id_authorized(user_id):
        return True
    if user_id and self.auth_service.is_temporary_id_authorized(user_id):
        return True
    return False

[Unit]
Description=JackettSearchBot Telegram Bot
After=network.target

[Service]
Type=simple
User=your-user
WorkingDirectory=/path/to/JackettSearchBot
Environment="PATH=/path/to/JackettSearchBot/.venv/bin:/usr/bin"
ExecStart=/path/to/uv run python main.py
Restart=always
RestartSec=10

[Install]
WantedBy=multi-user.target

sudo systemctl daemon-reload
sudo systemctl enable jackett-bot
sudo systemctl start jackett-bot

sudo journalctl -u jackett-bot -f

FROM python:3.12-slim

# Install uv
COPY --from=ghcr.io/astral-sh/uv:latest /uv /usr/local/bin/uv

WORKDIR /app

# Copy dependency files
COPY pyproject.toml uv.lock ./

# Install dependencies
RUN uv sync --frozen

# Copy application
COPY . .

# Run bot
CMD ["uv", "run", "python", "main.py"]

version: '3.8'
services:
  jackett-bot:
    build: .
    container_name: jackett-bot
    restart: unless-stopped
    env_file:
      - config.env
    volumes:
      - ./logs:/app/logs

# Bot uses in-memory sessions to avoid this issue
self.app = Client(
    "jackett_bot",
    api_id=self.config.api_id,
    api_hash=self.config.api_hash,
    bot_token=self.config.token,
    in_memory=True,  # Prevents session file locks
)

CONSOLE_LOG_LEVEL=INFO
FILE_LOG_LEVEL=DEBUG

file_handler = RotatingFileHandler(
    filename=log_path,
    maxBytes=10 * 1024 * 1024,  # 10 MB
    backupCount=5,              # Keep 5 old files
    encoding="utf-8",
)

# Install dependencies (creates .venv automatically)
uv sync

# Add a new dependency
uv add package-name

# Update lock file after manual pyproject.toml edits
uv lock

# Run without activating venv
uv run python main.py

[project.dependencies]
tgcrypto = { version = "*", python = "<3.13" }

# Remove from pyproject.toml or install build tools
sudo apt-get install build-essential python3-dev

# Default timeout
results = await jackett_service.search("query")

# Custom timeout for slow indexers
results = await jackett_service.search("query", timeout=30)

is_up = await ptp_service.is_available(timeout=5)

REDACT_AFTER_SECONDS=300  # 5 minutes

def _schedule_message_redaction(self, session_id: str, message: Message):
    task = asyncio.create_task(self._redact_message_later(session_id, message))
    self._redaction_tasks.add(task)
    task.add_done_callback(self._redaction_tasks.discard)

async def _redact_message_later(self, session_id: str, message: Message):
    await asyncio.sleep(self._redaction_delay_seconds)
    self._pagination_sessions.pop(session_id, None)
    try:
        await message.edit_text(
            "<code>RESULTS REDACTED</code>",
            parse_mode=ParseMode.HTML,
            reply_markup=None,
        )
    except Exception as exc:
        self.logger.debug("Failed to redact release message %s: %s", message.id, exc)

def _prune_expired_sessions(self):
    now = time.time()
    expired_session_ids = [
        session_id
        for session_id, session in self._pagination_sessions.items()
        if now - session.created_at > self._pagination_ttl_seconds
    ]
    for session_id in expired_session_ids:
        self._pagination_sessions.pop(session_id, None)

try:
    all_results = await self.jackett_service.search(query, golden_popcorn=golden_popcorn)
except httpx.HTTPStatusError as http_err:
    self.logger.error("HTTP error occurred: %s", http_err)
    await self._reply_key_value(message, "ERROR", "HTTP ERROR OCCURRED")
except httpx.HTTPError as http_err:
    self.logger.error("Network error occurred: %s", http_err)
    await self._reply_key_value(message, "ERROR", "NETWORK ERROR OCCURRED")
except Exception as exc:
    self.logger.exception("Unexpected error occurred: %s", exc)
    await self._reply_key_value(message, "ERROR", "UNEXPECTED ERROR OCCURRED")

if __name__ == "__main__":
    try:
        bot = JackettSearchBot.initialize("config.env")
    except ValueError as exc:
        print(f"Initialization failed: {exc}")
        print("Please fill the missing values in config.env and start again.")
        raise SystemExit(1) from exc

    bot.run()

def run(self):
    self.logger.info("Starting bot runtime.")
    try:
        self.app.run()
    except KeyboardInterrupt:
        self.logger.info("Stop signal received (KeyboardInterrupt). Exiting gracefully.")
    except sqlite3.OperationalError as exc:
        if "database is locked" in str(exc).lower():
            self.logger.error(
                "Session database is locked. This usually means another bot instance is still running "
                "or a stale session lock exists."
            )
            raise SystemExit(2) from exc
        self.logger.exception("SQLite operational error while starting bot.")
        raise
    except Exception:
        self.logger.exception("Fatal runtime error. Bot stopped unexpectedly.")
        raise
    finally:
        self._shutdown_services()
        self.logger.info("Bot shutdown complete.")

# Update all dependencies to latest compatible versions
uv lock --upgrade

# Update specific package
uv add package-name --upgrade

# Install updated dependencies
uv sync

# Count errors in last hour
grep -c "ERROR" logs/jackett_bot.log

# Show recent authorization failures
grep "NOT AUTHORIZED" logs/jackett_bot.log | tail -20

# Monitor in real-time
tail -f logs/jackett_bot.log | grep -E "ERROR|CRITICAL"

# Clone repository
git clone <repo-url>
cd JackettSearchBot

# Restore configuration
cp /backup/config.env .

# Install dependencies (uses committed uv.lock)
uv sync --frozen

# Start bot
uv run python main.py