Tackle the frustrating Lidarr and tubifary crash by resolving its root cause: a Python dependency conflict. This guide provides three distinct solutions, from a quick command-line fix to a robust, long-term architectural change.

Wrestling with Python: A DevOps Deep Dive into the Lidarr vs. tubifary Dependency Glitch

I remember a 3 AM PagerDuty alert that woke me from a dead sleep. A critical microservice, responsible for processing payments, was flatlining. The logs were a mess, but deep in the stack trace was a cryptic `ImportError`. It turned out a junior dev had pushed a “minor” library update to a shared dependency, and it cascaded into a full-blown production outage. We spent the next hour rolling back the change on `prod-api-gw-07`. That’s the exact feeling I get when I see issues like the one between Lidarr and tubifary: it’s not just a bug, it’s a classic symptom of dependency hell, and it can bite you whether you’re managing a corporate cloud or a humble homelab media server.

The “Why”: It’s a Battle Over a Shared Library

So, what’s really going on here? It’s not that Lidarr or tubifary are inherently broken. The problem is that they’re both living in the same house (your Python environment) and fighting over the same toy (the requests library).

Here’s the breakdown:

• Lidarr depends on a specific version range of the Python requests library to function correctly.
• tubifary, a script that Lidarr calls, also depends on the requests library, but it often requires a newer or different version.
• When you install or update one, its package manager (pip) “helpfully” upgrades or downgrades requests to the version it needs, which promptly breaks the other application.

This is a fundamental conflict in software environments. You can’t have two different versions of the same library active in the same Python path. One will always lose, and that’s when you see the crashes.

The Solutions: From Quick Patch to Architectural Purity

Alright, let’s get our hands dirty. I’m going to walk you through three ways to fix this, ranging from a quick-and-dirty patch to the “Cloud Architect” approved method.

Solution	Pros	Cons
1. The Quick Fix (Pinning)	Fastest, easiest to implement.	Brittle, may break on future updates.
2. The Permanent Fix (Virtual Environment)	Properly isolates dependencies, robust.	Requires more setup, slight learning curve.
3. The ‘Nuclear’ Option (Containerization)	Total isolation, portable, scalable.	Overkill for some, requires Docker knowledge.

Solution 1: The Quick Fix – Pin the Dependency

This is the “I need it working five minutes ago” approach. We’re going to manually edit tubifary’s requirements to force it to use a version of requests that Lidarr is happy with. Lidarr often works well with versions in the 2.28.x range.

Step 1: Find tubifary’s requirements file. It’s usually located where you cloned or installed it, often at a path like /opt/tubifary/requirements.txt.

Step 2: Edit the file. Open requirements.txt and find the line for requests. Change it to pin a specific, compatible version.

# Find this line:
requests

# And change it to this:
requests==2.28.2

Step 3: Re-install the requirements. Navigate to the tubifary directory and run pip again to enforce this change.

cd /opt/tubifary
pip install -r requirements.txt --upgrade

This works, but it’s a hack. The next time you update tubifary, your changes will likely be overwritten. It’s a patch, not a fix.

Solution 2: The Permanent Fix – Isolate with a Virtual Environment

This is the solution I’d recommend to any junior engineer. We’re going to give tubifary its own, isolated Python environment using venv. This way, it can have whatever version of requests it wants without affecting Lidarr’s global environment.

Step 1: Create a virtual environment for tubifary.

cd /opt/tubifary
python3 -m venv .venv

This creates a .venv directory inside your tubifary folder containing a sandboxed Python installation.

Step 2: Install dependencies into the venv.

Instead of just running pip, you’ll now use the pip from inside your new venv. This ensures the libraries are installed in isolation.

/opt/tubifary/.venv/bin/pip install -r requirements.txt

Step 3: Update Lidarr’s custom script path.

In Lidarr’s settings, you can’t just point to /opt/tubifary/tubifary.py anymore. You need to tell it to use the Python interpreter from the virtual environment to run the script. The path in Lidarr’s “Custom Scripts” section should now be:

/opt/tubifary/.venv/bin/python3

And the arguments would be the path to the script, like:

/opt/tubifary/tubifary.py

This is the proper, clean way to handle this on a single machine.

Pro Tip from the Trenches: Once you get comfortable with venv, look into tools like Poetry or pip-tools. They provide more robust dependency locking and management, which is crucial for preventing these issues in larger projects.

Solution 3: The ‘Nuclear’ Option – Containerize Everything

Look, if you’re running a serious homelab or you’re like me and believe in infrastructure-as-code for everything, this is the way. We treat each application as a distinct, immutable service in its own Docker container. This provides the ultimate isolation.

You’d have a docker-compose.yml file for your media stack, with separate service definitions for Lidarr, Radarr, and a custom container for tubifary.

A simple Dockerfile for tubifary might look like this:

# Dockerfile for tubifary
FROM python:3.9-slim

WORKDIR /app

COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt

COPY . .

# This container would likely not run a process, 
# but would be executed by Lidarr via Docker command.
# Or it could be set up as a small web service.
CMD ["python3", "tubifary.py"]

In this scenario, Lidarr (also in a container) would be configured to execute a command in the tubifary container using docker exec. It’s more complex, but it’s bulletproof. Your dependencies are completely isolated, and updates to one service can never, ever break another. It’s the DevOps dream.

Final Thoughts

The Lidarr and tubifary issue is a perfect microcosm of the challenges we face daily in DevOps. A small, seemingly insignificant dependency conflict can cause real headaches. While the quick fix will get you by, understanding why it’s happening and learning to use tools like virtual environments or containers is what separates a novice from a seasoned engineer. Choose the path that fits your setup, but always try to understand the “why” behind the fix.

---

🤖 Frequently Asked Questions