Skip to content

स्थानीय विकास

विकास और परीक्षण के लिए Potato को स्थानीय रूप से इंस्टॉल करें और चलाएं। इसमें pip से इंस्टॉलेशन, कॉन्फ़िग सेटअप, सर्वर शुरू करना और स्टार्टअप की आम समस्याओं की डीबगिंग शामिल है।

विकास और परीक्षण के लिए अपनी स्थानीय मशीन पर Potato चलाएं।

पूर्व-आवश्यकताएं

  • Python 3.9 या उससे अधिक
  • pip पैकेज मैनेजर
  • Git (वैकल्पिक, उदाहरण क्लोन करने के लिए)

इंस्टॉलेशन

pip का उपयोग करके (अनुशंसित)

bash
pip install potato-annotation

सोर्स से

bash
git clone https://github.com/davidjurgens/potato.git
cd potato
pip install -e .

वैकल्पिक डिपेंडेंसी के साथ

bash
# Local speech-to-text and diarization for transcript projects
pip install "potato-annotation[transcribe]"
 
# Hosted model providers for AI support and active learning
pip install "potato-annotation[ai]"
 
# Everything except the multi-gigabyte server-side vision stack
pip install "potato-annotation[all]"

extra को उद्धरण चिह्नों में रखें, ताकि शेल ब्रैकेट को glob पैटर्न न समझे। all में vision जानबूझकर शामिल नहीं है, क्योंकि वह समूह torch इंस्टॉल करता है और डिफ़ॉल्ट उपयोग में किसी चीज़ को उसकी ज़रूरत नहीं होती।

त्वरित शुरुआत

1. कॉन्फ़िगरेशन फ़ाइल बनाएं

config.yaml बनाएं:

yaml
annotation_task_name: "My First Annotation Task"
task_dir: "."
port: 8000
 
data_files:
  - data.json
 
item_properties:
  id_key: id
  text_key: text
 
annotation_schemes:
  - annotation_type: radio
    name: sentiment
    description: "What is the sentiment?"
    labels:
      - Positive
      - Negative
      - Neutral
 
output_annotation_dir: "annotations/"

task_dir वह रूट है जिसके सापेक्ष बाकी सभी रिलेटिव पथ हल होते हैं, और Potato इसके बाहर से पढ़ने से इनकार करता है। इसे . पर सेट करने से कॉन्फ़िग, डेटा फ़ाइल और आउटपुट डायरेक्टरी एक ही फ़ोल्डर में रहती हैं, और इसी से प्रोजेक्ट को बाद में सर्वर पर ले जाना संभव होता है।

2. सैंपल डेटा तैयार करें

data.json बनाएं:

json
[
  {"id": "1", "text": "I love this product!"},
  {"id": "2", "text": "This is terrible."},
  {"id": "3", "text": "It's okay, nothing special."}
]

3. सर्वर शुरू करें

bash
potato start config.yaml

4. इंटरफ़ेस तक पहुंचें

अपने ब्राउज़र में http://localhost:8000 खोलें

डेवलपमेंट मोड

डीबग मोड

डीबग मोड विस्तृत लॉगिंग चालू करता है, सेशन का निष्क्रियता टाइमआउट बंद करता है, और आपकी अपनी मशीन से आए अनुरोधों के लिए एडमिन पेज बिना key के खोलता है। लॉगिन पेज बना रहता है, और --debug-phase (नीचे) उसे छोड़ देता है:

bash
potato start config.yaml --debug

डिप्लॉय किए गए सर्वर पर डीबग मोड कभी चालू न करें। उसी मशीन पर चलने वाला कोई टनल या रिवर्स प्रॉक्सी, जो कोई फ़ॉरवर्डिंग हेडर नहीं जोड़ता, हर कॉल करने वाले को स्थानीय जैसा दिखाता है, और --debug-phase हर विज़िटर को एक ही debug_user के रूप में साइन इन कर देता है। Potato 2.8.2 से 2.11.0 तक डिफ़ॉल्ट 0.0.0.0 पते पर डीबग मोड में शुरू नहीं होता, इसलिए इन संस्करणों पर --host 127.0.0.1 जोड़ें।

डीबग लॉगिंग

चुनें कि एप्लिकेशन का कौन-सा हिस्सा लॉग दे:

bash
potato start config.yaml --debug-log server

स्वीकृत मान all, ui, server और none हैं। जब एनोटेशन पेज गड़बड़ व्यवहार करे तो ui का उपयोग करें, और जब कोई आइटम लोड न हो तो server का।

वर्बोज़ आउटपुट

सभी सर्वर गतिविधि देखें:

bash
potato start config.yaml --verbose

किसी फ़ेज़ पर सीधे जाना

--debug चालू होने पर, हर रीस्टार्ट में सहमति और निर्देशों से होकर गुज़रने के बजाय लॉगिन छोड़कर सीधे उस फ़ेज़ पर जाएं जिस पर आप काम कर रहे हैं:

bash
potato start config.yaml --debug --debug-phase annotation

डायरेक्टरी संरचना

अनुशंसित प्रोजेक्ट लेआउट:

text
my-annotation-project/
├── config.yaml           # Main configuration, inside task_dir
├── data/
│   ├── training.json     # Practice items for the training phase
│   └── main.json         # Annotation data
├── annotations/          # output_annotation_dir
├── media/                # media_directory, served at /media/
└── templates/            # site_dir, if you override the default templates

केवल config.yaml और डेटा फ़ाइल आवश्यक हैं। Potato अपने टेम्पलेट साथ लाता है, इसलिए site_dir सेट करें और templates/ फ़ोल्डर तभी जोड़ें जब आप उन्हें बदल रहे हों, और एनोटेशन पेज को किसी खास फ़ाइल से रेंडर करने के लिए site_file को उस फ़ाइल पर पॉइंट करें।

अपने कॉन्फ़िगरेशन का परीक्षण

कॉन्फ़िग सत्यापित करें

सर्वर शुरू करने में समय लगाने से पहले, कॉन्फ़िग की जांच उसी तरह करें जैसे सर्वर बूट होते समय करता है:

bash
potato validate config.yaml

--strict जोड़ें ताकि चेतावनियां, जैसे कोई अपरिचित key, प्रिंट होकर आगे बढ़ने के बजाय रन को विफल कर दें।

प्रीव्यू मोड

देखें कि कोई कॉन्फ़िग क्या घोषित करता है, और पूरा सर्वर शुरू किए बिना उसे ब्राउज़र में रेंडर करें:

bash
potato preview config.yaml

स्क्रीनशॉट के लिए हेडलेस ब्राउज़र वाला extra चाहिए, pip install "potato-annotation[preview]":

bash
potato preview config.yaml --screenshot preview.png

सामान्य समस्याएं

पोर्ट पहले से उपयोग में है

bash
# Use a different port
potato start config.yaml -p 8080

या इसे config.yaml में सेट करें, जिसे फिर -p फ़्लैग ओवरराइड करता है:

yaml
port: 8080

डेटा फ़ाइल नहीं मिली

सुनिश्चित करें कि पथ कॉन्फ़िग फ़ाइल के स्थान के सापेक्ष हैं:

yaml
# If data is in a subdirectory
data_files:
  - data/main.json

पथ task_dir के सापेक्ष हल होते हैं, और Potato इसके बाहर की फ़ाइल लोड करने से इनकार करता है, इसलिए मशीन पर कहीं और के absolute पथ की ओर इशारा करने के बजाय डेटा को टास्क डायरेक्टरी के अंदर ले आएं।

अनुमति अस्वीकृत

फ़ाइल अनुमतियों की जांच करें:

bash
chmod 755 annotations/
chmod 644 data/*.json

स्थानीय रूप से एकाधिक उपयोगकर्ता

बहु-उपयोगकर्ता परिदृश्यों के परीक्षण के लिए:

yaml
user_config:
  allow_all_users: true
 
login:
  type: url_direct
  url_argument: user_id

url_direct उपयोगकर्ता नाम सीधे URL से पढ़ता है और पासवर्ड नहीं मांगता, इसलिए आप दो ब्राउज़र प्रोफ़ाइल खोलकर बिना खाते पंजीकृत किए दो लोगों के रूप में एनोटेट कर सकते हैं:

  • http://localhost:8000/?user_id=annotator1
  • http://localhost:8000/?user_id=annotator2

एनोटेशन रीसेट करें

Potato output_annotation_dir के अंदर हर एनोटेटर के लिए एक डायरेक्टरी लिखता है, और हर डायरेक्टरी में उस व्यक्ति की user_state.json होती है:

bash
# Remove one annotator's work
rm -rf annotations/annotator1
 
# Or clear every annotator
rm -rf annotations/*
 
# Restart server
potato start config.yaml

किसी उपयोगकर्ता की डायरेक्टरी हटाने से उसके उत्तरों के साथ उसके असाइनमेंट भी हट जाते हैं, इसलिए नया रन आइटम शुरू से फिर असाइन करता है।

पर्यावरण चर

पर्यावरण के माध्यम से कॉन्फ़िगर करें:

bash
# Keeps sessions valid across restarts; required for OAuth
export POTATO_SECRET_KEY="$(python3 -c 'import secrets; print(secrets.token_hex(32))')"
 
# Fixes the shared admin key instead of letting Potato generate one per task
export POTATO_ADMIN_API_KEY="your-admin-key"
 
potato start config.yaml

POTATO_SECRET_KEY के बिना Potato हर स्टार्टअप पर एक रैंडम साइनिंग key बनाता है, जिससे हर रीस्टार्ट पर सभी लॉग आउट हो जाते हैं।

वर्चुअल एनवायरनमेंट के साथ उपयोग

venv

bash
python -m venv potato-env
source potato-env/bin/activate  # Linux/Mac
potato-env\Scripts\activate     # Windows
pip install potato-annotation

Conda

bash
conda create -n potato python=3.10
conda activate potato
pip install potato-annotation

IDE एकीकरण

VS Code

कॉन्फ़िग फ़ाइल समर्थन के लिए YAML एक्सटेंशन इंस्टॉल करें:

json
// settings.json
{
  "yaml.schemas": {
    "https://potatoannotator.readthedocs.io/en/latest/schemas/potato-config.schema.json": "config.yaml"
  }
}

स्टडी डिज़ाइनर से डाउनलोड किए गए कॉन्फ़िग में यह स्कीमा पहले से एक # yaml-language-server: लाइन पर होता है, इसलिए इस सेटिंग के बिना भी एडिटर में उनका सत्यापन हो जाता है।

PyCharm

रन कॉन्फ़िगरेशन सेट करें:

  1. Add → Python
  2. Script: potato
  3. Parameters: start config.yaml
  4. Working directory: आपका प्रोजेक्ट पथ

अगले कदम