UV Workspaces का उपयोग करके Python monorepo मैनेज करना

UV Workspaces का उपयोग करके Python monorepo मैनेज करने का सारांश

यह वीडियो बताता है कि एक ही Git repository में कई Python applications (monorepo) को मैनेज करते समय आने वाली समस्याओं को UV Workspaces फीचर की मदद से साफ़-सुथरे तरीके से कैसे हल किया जा सकता है।

1. वीडियो सारांश

समस्याएँ

जब एक ही repository में CLI tool और FastAPI app को साथ में develop किया जाता है, तो निम्न समस्याएँ सामने आती हैं।

• कोड duplication: CLI और API में साझा रूप से इस्तेमाल होने वाले फ़ंक्शन (जैसे headline crawling function) को copy/paste करना पड़ता है।
• जटिल environment management: हर app के लिए अलग virtual environment मैनेज करना पड़ता है, जिससे dependency versions टकरा सकती हैं या disk space बेकार खर्च होता है।

समाधान: UV Workspaces

UV Workspaces इन समस्याओं को हल करने के लिए दो मुख्य फीचर देता है।

1. shared dependencies और single virtual environment

   • प्रोजेक्ट root में मौजूद pyproject.toml फ़ाइल में shared dependencies define की जा सकती हैं।
   • uv sync कमांड चलाने पर UV इस config फ़ाइल को पढ़कर repository पूरे में साझा होने वाला single virtual environment (.venv) root folder में बनाता है।
   • इससे सभी subprojects (CLI, API आदि) एक ही environment और dependencies साझा करते हैं, जिससे version conflicts रुकते हैं और management आसान हो जाता है।

2. internal package के ज़रिए code sharing

   • बार-बार दोहराया जाने वाला shared code (जैसे fetch_headlines फ़ंक्शन) core जैसे अलग "internal package" में निकाला जा सकता है।
   • workspace settings के ज़रिए इस core package को PyPI नहीं बल्कि local source के रूप में पहचाना जाता है।
   • अब CLI app और API app, from core.news import fetch_headlines की तरह इस shared code को import करके दोबारा इस्तेमाल कर सकते हैं।

2. UV Workspaces इस्तेमाल करने का तरीका

चरण 1: workspace setup

प्रोजेक्ट root folder में pyproject.toml फ़ाइल बनाइए, और [tool.uv.workspace] सेक्शन define करके बताइए कि subprojects कहाँ मौजूद हैं।

[tool.uv.workspace]  
# "packages" फ़ोल्डर के अंदर मौजूद सभी subfolders को workspace members के रूप में पहचानें  
members = ["packages/*"]  

चरण 2: dependency management

• shared dependencies: जो dependencies सभी projects में कॉमन हैं (जैसे python-dotenv), उन्हें root pyproject.toml में जोड़ें।
• individual dependencies: जो dependencies सिर्फ किसी खास app (जैसे api) में इस्तेमाल होती हैं (जैसे fastapi, uvicorn), उन्हें उस app के pyproject.toml (जैसे packages/api/pyproject.toml) में जोड़ें।
• root folder में uv sync चलाने पर UV सभी pyproject.toml को scan करके root virtual environment में ज़रूरी सभी dependencies install कर देता है।

चरण 3: internal package के रूप में code share करना

1. packages/core की तरह shared code रखने के लिए एक नया package (folder) बनाइए।
2. root pyproject.toml में इस package को सामान्य dependency की तरह जोड़ें।
3. root pyproject.toml में [tool.uv.sources] सेक्शन जोड़ें, ताकि core package को PyPI के बजाय workspace के अंदर खोजा जाए।

<!-- end list -->

[project]  
# 1. internal package को dependency के रूप में जोड़ें  
dependencies = [  
    "core",  
    "python-dotenv"  
]  
  
# 2. स्पष्ट करें कि 'core' एक local workspace package है  
[tool.uv.sources]  
core = { workspace = true }  

4. uv sync दोबारा चलाने पर core package local source से install हो जाएगा।
5. अब packages/api या packages/cli में from core.news import ... syntax के साथ shared code को import किया जा सकता है।

चरण 4: project चलाना

किसी खास project को चलाने के लिए uv run --from <패키지명> का उपयोग करें।

# API server चलाएँ  
uv run --from packages/api uvicorn main:app --reload  
  
# CLI tool चलाएँ  
uv run --from packages/cli python main.py  

3. किन लोगों के लिए उपयोगी

• जब आप एक ही repository में कई छोटे automation scripts, webhooks, APIs, CLI आदि मैनेज कर रहे हों।
• जब ये applications shared logic या dependencies इस्तेमाल करती हों, तब यह बहुत उपयोगी है।
• इसके उलट, single script, PyPI पर अलग से publish होने वाले package, या एक-दूसरे से पूरी तरह असंबंधित apps को मैनेज करने के लिए यह उपयुक्त न भी हो सकता है।

---

मूल वीडियो लिंक: https://www.youtube.com/watch?v=N_ypJwV8Q8I

[pcj9024]

यह काफ़ी हद तक pnpm जैसा लगता है।