अजगर पैकेज में संस्करण एम्बेड करने का मानक तरीका?

Question

क्या संस्करण स्ट्रिंग को अजगर पैकेज के साथ इस तरह से संबद्ध करने का एक मानक तरीका है कि मैं निम्नलिखित कर सकता हूं?

import foo
print foo.version

मुझे लगता है कि बिना किसी अतिरिक्त हार्डकॉकिंग के उस डेटा को प्राप्त करने का कोई तरीका है, क्योंकि setup.pyपहले से ही मामूली / प्रमुख तार निर्दिष्ट हैं । वैकल्पिक समाधान जो मुझे मिला, वह import __version__मेरे पास था foo/__init__.pyऔर फिर इससे __version__.pyउत्पन्न हुआ setup.py।

Comments

FYI करें, यहाँ बहुत अच्छा अवलोकन है: पैकेजिंग

— ओरमथॉन.org

एक स्थापित पैकेज के संस्करण को मेटाडेटा से सेटप्टूल के साथ फिर से प्राप्त किया जा सकता है , इसलिए कई मामलों में केवल संस्करण डालना setup.pyपर्याप्त है। इस प्रश्न को देखें ।

— साज़

FYI करें, संस्करण संख्या के लिए सत्य के एकल स्रोत (सेटअप और रन समय दोनों) को बनाए रखने के लिए मूल रूप से 5 सामान्य पैटर्न हैं ।

— KF लिन

@ionelmc पायथन के प्रलेखन में एकल- खट्टेपन के लिए 7 विभिन्न विकल्पों की सूची है । क्या यह " सत्य के एकल स्रोत " की अवधारणा के विपरीत नहीं है ?

— Stevoisiak

@StevenVascellaro आप क्या पूछ रहे हैं यकीन नहीं है। वहाँ बहुत सारे तरीके सूचीबद्ध हैं क्योंकि पैकेजिंग गाइड की राय नहीं है।

— आयनमेक

Answer 1

सीधे आपके सवाल का जवाब नहीं, लेकिन आपको इसका नामकरण करना चाहिए __version__, नहीं version।

यह लगभग एक अर्ध-मानक है। मानक पुस्तकालय में कई मॉड्यूल उपयोग करते हैं __version__, और यह 3-पार्टी मॉड्यूल के बहुत सारे में भी उपयोग किया जाता है , इसलिए यह अर्ध-मानक है।

आमतौर पर, __version__एक स्ट्रिंग है, लेकिन कभी-कभी यह एक फ्लोट या ट्यूपल भी होता है।

संपादित करें: एस.लॉट (शुक्रिया!) द्वारा उल्लिखित, पीईपी 8 स्पष्ट रूप से कहता है:

मॉड्यूल स्तर डंडर नाम

मॉड्यूल स्तर "dunders" जैसे (दो प्रमुख और दो अनुगामी अंडरस्कोर से यानी नाम) __all__, __author__, __version__, आदि मॉड्यूल docstring के बाद, लेकिन से को छोड़कर किसी भी आयात बयान से पहले रखा जाना चाहिए __future__आयात।

आपको यह भी सुनिश्चित करना चाहिए कि संस्करण संख्या PEP 440 ( PEP 386 इस मानक के पिछले संस्करण) में वर्णित प्रारूप के अनुरूप है ।

Comments

यह एक स्ट्रिंग होना चाहिए, और ट्यूपल संस्करण के लिए एक version_info होना चाहिए ।

— जेम्स एंटिल

जेम्स: क्यों __version_info__ विशेष रूप से ? (जो मैं "अपने खुद के डबल-अंडरस्कोर-शब्द" पर आक्रमण करता हूं।) [जब जेम्स ने टिप्पणी की, तो अंडरस्कोर ने टिप्पणियों में कुछ नहीं किया, अब वे जोर देते हैं, इसलिए जेम्स ने वास्तव में __version_info__भी लिखा । --- एड।]

आप किस चीज के बारे में कुछ देख सकते हैं संस्करण कहना चाहिए packages.python.org/distribute/... पृष्ठ के बारे में वितरित किया जाता है यही कारण है, लेकिन संस्करण संख्या के अर्थ एक वास्तविक मानक बनता जा रहा है।

— १

सही। ऐसा लगता है कि ये पीईपी एक दूसरे के विपरीत हैं। ठीक है, पीईपी 8 "अगर" और "क्रूड" कहता है, तो यह वास्तव में वीसीएस कीवर्ड विस्तार का उपयोग करने का समर्थन नहीं करता है। इसके अलावा, यदि आप कभी भी एक अलग वीसीएस पर जाते हैं, तो आप संशोधन की जानकारी खो देंगे। इसलिए मैं कम से कम बड़ी परियोजनाओं के लिए एक एकल स्रोत फ़ाइल में एम्बेडेड PEP 386/440-संगत संस्करण जानकारी का उपयोग करने का सुझाव दूंगा।

— oefe

आप उस संस्करण को कहां रखेंगे । यह स्वीकार किए गए संस्करण को देखते हुए, मुझे उस अतिरिक्त जानकारी को यहाँ देखना अच्छा लगेगा।

— डार्कजैग

Answer 2

मैं _version.pyसंस्करण जानकारी को संग्रहीत करने के लिए "एक बार तोपखाने वाली जगह" के रूप में एक एकल फ़ाइल का उपयोग करता हूं :

1. यह एक __version__विशेषता प्रदान करता है ।

2. यह मानक मेटाडेटा संस्करण प्रदान करता है। इसलिए यह pkg_resourcesपैकेज मेटाडेटा (EGG-INFO और / या PKG-INFO, PEP 0345) को पार्स करने वाले अन्य उपकरणों द्वारा पता लगाया जाएगा ।

3. यह आपके पैकेज का निर्माण करते समय आपके पैकेज (या कुछ और) को आयात नहीं करता है, जो कुछ स्थितियों में समस्या पैदा कर सकता है। (इस समस्या के कारण क्या हो सकते हैं नीचे टिप्पणी देखें।)

4. केवल एक ही जगह है कि संस्करण संख्या नीचे लिखी गई है, इसलिए संस्करण संख्या में परिवर्तन होने पर इसे बदलने के लिए केवल एक ही स्थान है, और असंगत संस्करणों की संभावना कम है।

यहां बताया गया है कि यह कैसे काम करता है: संस्करण संख्या को संग्रहीत करने के लिए "एक विहित स्थान" एक .py फ़ाइल है, जिसका नाम "_version.py" है जो आपके पायथन पैकेज में है, उदाहरण के लिए myniftyapp/_version.py। यह फ़ाइल एक पायथन मॉड्यूल है, लेकिन आपका setup.py इसे आयात नहीं करता है! (यह सुविधा 3 को हरा देगा) इसके बजाय आपके setup.py पता है कि इस फ़ाइल की सामग्री बहुत सरल है, कुछ इस तरह है:

__version__ = "3.6.5"

और इसलिए आपका setup.py फ़ाइल को खोलता है और इसे पार्स करता है, जैसे कोड:

import re
VERSIONFILE="myniftyapp/_version.py"
verstrline = open(VERSIONFILE, "rt").read()
VSRE = r"^__version__ = ['\"]([^'\"]*)['\"]"
mo = re.search(VSRE, verstrline, re.M)
if mo:
    verstr = mo.group(1)
else:
    raise RuntimeError("Unable to find version string in %s." % (VERSIONFILE,))

फिर आपका setup.py "स्ट्रिंग" मान के तर्क के रूप में उस स्ट्रिंग को पास करता है setup(), इस प्रकार सुविधा 2 को संतुष्ट करता है।

सुविधा 1 को संतुष्ट करने के लिए, आप अपना पैकेज (रन-टाइम में, सेटअप समय पर नहीं!) से _version फ़ाइल आयात कर सकते हैं myniftyapp/__init__.py इस तरह करें:

from _version import __version__

यहाँ है इस तकनीक एक उदाहरण है जिसका उपयोग मैं वर्षों से कर रहा हूँ।

उस उदाहरण में कोड थोड़ा अधिक जटिल है, लेकिन मैंने इस टिप्पणी में जो सरलीकृत उदाहरण लिखा है, वह पूर्ण कार्यान्वयन होना चाहिए।

यहाँ संस्करण आयात करने का उदाहरण कोड है ।

यदि आप इस दृष्टिकोण के साथ कुछ भी गलत देखते हैं, तो कृपया मुझे बताएं।

Comments

क्या आप उन समस्याओं का वर्णन कर सकते हैं जो # 3 को प्रेरित करती हैं? ग्लिफ़ ने कहा कि इसका कुछ लेना देना है "सेप्टुपूलस यह बहाना करना पसंद करते हैं कि आपका कोड सिस्टम पर कहीं भी नहीं है जब आपका setup.py चलता है", लेकिन विवरण मुझे और दूसरों को समझाने में मदद करेगा।

— इवान कोज़िक

@ अब, उपकरण को किस क्रम में ऐसा करना चाहिए? यह (setuptools / पिप / virtualenv आज की प्रणाली में) भी नहीं पता कर सकते हैं क्या deps हैं जब तक यह अपने मूल्यांकन करता है setup.py। इसके अलावा, अगर यह पूर्ण गहराई-पहले करने की कोशिश करता है और सभी डिप्स करता है इससे पहले कि यह ऐसा करता है, तो यह अटक जाएगा अगर परिपत्र डीईएस थे। लेकिन अगर यह निर्भरता स्थापित करने से पहले इस पैकेज को बनाने की कोशिश करता है, तो यदि आप अपने पैकेज को अपने से आयात करते हैं, तो setup.pyयह आवश्यक रूप से इसके डिप्स, या इसके डिप्स के सही संस्करणों को आयात करने में सक्षम नहीं होगा।

— ज़ूको

क्या आप इसे सेटअप करने के बजाय "setup.py" से फ़ाइल "version.py" लिख सकते हैं ? यह सरल लगता है।

— जोनाथन हार्टले

जोनाथन हार्टले: मैं मानता हूं कि आपके "सेटअपहोम" के लिए इसे पार्स करने के बजाय "वर्जनहोम" फाइल लिखना थोड़ा सरल होगा, लेकिन जब आप अपना सेटअपडोम संपादित कर लेते हैं, तो यह असंगतता के लिए एक विंडो खोल देगा। नए संस्करण के लिए, लेकिन अभी तक setup.py को निष्पादित नहीं किया है। विहित संस्करण को एक अलग फ़ाइल में रखने का एक अन्य कारण यह है कि यह अन्य उपकरणों के लिए आसान बनाता है , जैसे कि उपकरण जो आपके संशोधन नियंत्रण राज्य को पढ़ते हैं, संस्करण फ़ाइल को लिखने के लिए।

— ज़ूको

execfile("myniftyapp/_version.py")मैन्युअल रूप से संस्करण कोड को पार्स करने की कोशिश करने के बजाय, सेटअप के अंदर से इसी तरह का दृष्टिकोण है । में सुझाए गए stackoverflow.com/a/2073599/647002 - चर्चा वहाँ उपयोगी भी हो सकता है।

— मध्याह्न

Answer 3

2017-05 को फिर से लिखा गया

पायथन कोड लिखने और विभिन्न पैकेजों को प्रबंधित करने के दस साल से अधिक समय के बाद मैं इस नतीजे पर पहुंचा कि DIY शायद सबसे अच्छा तरीका नहीं है।

मैंने pbrअपने पैकेजों में संस्करण से निपटने के लिए पैकेज का उपयोग करना शुरू कर दिया । यदि आप अपने SCM के रूप में git का उपयोग कर रहे हैं, तो यह आपके वर्कफ़्लो में जादू की तरह फिट होगा, आपके हफ्तों के काम को बचाएगा (आपको आश्चर्य होगा कि समस्या कितनी जटिल हो सकती है)।

आज के रूप में pbr को # 11 सबसे अधिक इस्तेमाल किया जाने वाला पायथन पैकेज दिया गया है और इस स्तर तक पहुंचने में कोई गंदी चाल शामिल नहीं है: केवल एक ही था: एक सामान्य पैकेजिंग समस्या को बहुत सरल तरीके से ठीक करना।

pbr पैकेज के रखरखाव के बोझ को अधिक कर सकते हैं, केवल संस्करण तक सीमित नहीं है, लेकिन यह आपको इसके सभी लाभों को अपनाने के लिए मजबूर नहीं करता है।

तो आपको यह अंदाजा लगाने के लिए कि किसी एक प्रतिबद्धता में किस तरह से मवेशी को अपनाना अच्छा लगता है, मलबे को पैकेजिंग देखना है

संभवतः आपने देखा होगा कि संस्करण भंडार में बिल्कुल भी संग्रहीत नहीं है। PBR इसे Git शाखाओं और टैग से पता लगाता है।

जब आपके पास गिट रिपॉजिटरी न हो तो चिंता करने की कोई जरूरत नहीं है क्योंकि जब आप एप्लिकेशन को पैकेज या इंस्टॉल करते हैं तो pbr "कंपाइल" करता है और संस्करण को कैश करता है, इसलिए गिट पर कोई रनटाइम निर्भरता नहीं होती है।

पुराना हल

यहाँ मैंने अभी तक देखा सबसे अच्छा समाधान है और यह भी बताता है कि क्यों:

अंदर yourpackage/version.py:

# Store the version here so:
# 1) we don't load dependencies by storing it in __init__.py
# 2) we can import it in setup.py for the same reason
# 3) we can import it into your module module
__version__ = '0.12'

अंदर yourpackage/__init__.py:

from .version import __version__

अंदर setup.py:

exec(open('yourpackage/version.py').read())
setup(
    ...
    version=__version__,
    ...

यदि आप एक और दृष्टिकोण जानते हैं जो बेहतर प्रतीत होता है तो मुझे बताएं।

Comments

त्रुटि, नहीं। निष्पादन 3 (Python 3) में मौजूद नहीं है, इसलिए निष्पादन का उपयोग करना बेहतर है (खुला ()। पढ़ा।) ()।

— क्रिस्टोफ़ वू-ब्रुगियर

क्यों नहीं from .version import __version__setup.py में भी?

— अप्रैल

@Aprillion क्योंकि पैकेज लोड नहीं हो setup.pyरहा है जब वह चल रहा है - इसे आज़माएं, आपको एक त्रुटि मिलेगी (या कम से कम, मैंने :-))

— darthbith

एक खराब गेटवे में pbr परिणाम का लिंक।

— मर्सोज

pbr , कोई शक नहीं, एक महान उपकरण है, लेकिन आप प्रश्न को संबोधित करने में विफल रहे। आप वर्तमान संस्करण या इंस्टॉल किए गए पैकेज को bpr के माध्यम से कैसे एक्सेस कर सकते हैं ।

— nad2000

Answer 4

आस्थगित PEP 396 (मॉड्यूल संस्करण संख्या) के अनुसार , ऐसा करने का एक प्रस्तावित तरीका है। यह वर्णन करता है, मॉड्यूल के पालन के लिए औचित्य, ((वैकल्पिक रूप से वैकल्पिक) मानक के साथ। यहाँ एक स्निपेट है:

3) जब एक मॉड्यूल (या पैकेज) में एक संस्करण संख्या शामिल होती है, तो संस्करण SHOULD __version__विशेषता में उपलब्ध होगा ।

4) मॉड्यूल के लिए जो नेमस्पेस पैकेज के अंदर रहते हैं, मॉड्यूल SHOULD में __version__विशेषता शामिल होती है । नामस्थान पैकेज में स्वयं अपनी __version__विशेषता शामिल नहीं होनी चाहिए ।

5) __version__विशेषता का मूल्य एक स्ट्रिंग होना चाहिए।

Comments

वह पीईपी स्वीकार / मानकीकृत नहीं है, लेकिन आस्थगित (ब्याज की कमी के कारण)। इसलिए यह बताना थोड़ा भ्रामक है कि इसके द्वारा निर्दिष्ट " एक मानक तरीका है "।

— बुनकर

@ नौकर: ओह मेरी! मैंने कुछ नया सीखा। मुझे नहीं पता था कि मुझे जाँचने के लिए कुछ चाहिए था।

— शाम

ध्यान दें कि यह एक मानक नहीं है। अब मुझे शर्मिंदगी महसूस हो रही है, क्योंकि मैंने परियोजनाओं पर फीचर अनुरोधों को उठाया है ताकि उन्हें इस "मानक" का पालन करने के लिए कहा जा सके।

— Oddthinking

शायद आपको उस PEP पर मानकीकरण का काम करना चाहिए, जब से आप रुचि रखते हैं :)

— बुनकर

यह एक व्यक्तिगत मॉड्यूल को संस्करणित करने के लिए काम करेगा, लेकिन मुझे यकीन नहीं है कि यह एक पूर्ण परियोजना के संस्करण पर लागू होगा।

— Stevoisiak

Answer 5

हालांकि यह शायद बहुत देर हो चुकी है, पिछले उत्तर के लिए थोड़ा सरल विकल्प है:

__version_info__ = ('1', '2', '3')
__version__ = '.'.join(__version_info__)

(और संस्करण संख्याओं के ऑटो-इंक्रीमेंटिंग भागों को स्ट्रिंग में परिवर्तित करना काफी सरल होगा str() ।)

बेशक, मैंने जो देखा है, उसमें से लोग पहले उपयोग किए गए संस्करण की तरह कुछ का उपयोग करते हैं __version_info__, और इस तरह इसे टट्स के रूप में संग्रहीत करते हैं; हालाँकि, मुझे ऐसा करने में कोई बात नहीं दिख रही है, क्योंकि मुझे संदेह है कि ऐसी परिस्थितियाँ हैं जहाँ आप गणितीय कार्यों जैसे कि जोड़ और घटाव को किसी भी उद्देश्य के लिए जिज्ञासा या ऑटो-वृद्धि के अलावा किसी भी उद्देश्य के लिए करेंगे (और तब भी, int()और str()काफी आसानी से इस्तेमाल किया जा सकता है)। (दूसरी ओर, किसी और के कोड की संभावना है कि वह एक स्ट्रिंग ट्यूपल के बजाय संख्यात्मक ट्यूपल की उम्मीद कर रहा है और इस प्रकार विफल हो रहा है।)

यह, निश्चित रूप से, मेरा अपना दृष्टिकोण है, और मैं एक संख्यात्मक ट्यूपल का उपयोग करने पर दूसरों के इनपुट को खुशी से पसंद करूंगा।

---

जैसा कि शीज़ी ने मुझे याद दिलाया, (लेक्सिकल) संख्याओं की तुलना में अनिवार्य रूप से प्रत्यक्ष संख्यात्मक तुलनाओं के समान परिणाम नहीं है; इसके लिए प्रदान करने के लिए अग्रणी शून्य की आवश्यकता होगी। इसलिए अंत में, __version_info__पूर्णांक मूल्यों के एक समूह के रूप में भंडारण (या इसे जो भी कहा जाएगा) अधिक कुशल संस्करण की तुलना के लिए अनुमति देगा।

Comments

अच्छा (+1), लेकिन क्या आप स्ट्रिंग्स के बजाय संख्याओं को पसंद नहीं करेंगे? जैसे__version_info__ = (1,2,3)

— orip

स्ट्रिंग्स की तुलना खतरनाक हो सकती है जब संस्करण संख्या 9 से अधिक हो, उदाहरण के लिए '10' <'2'।

— D Coetzee

मैं इसे अच्छी तरह से करता हूं लेकिन __version_info__ = (0, 1, 0) __version__ = '.'.join(map(str, __version_info__))

— किलों

समस्या __version__ = '.'.join(__version_info__)यह है कि नहीं, या नहीं __version_info__ = ('1', '2', 'beta')होगा1.2.beta1.2beta1.2 beta

— nagisa

मुझे लगता है कि इस दृष्टिकोण के साथ समस्या यह है कि __version__ की घोषणा करने वाले कोड की पंक्तियों को कहां रखा जाए। यदि वे setup.py में हैं तो आपका प्रोग्राम उन्हें इसके पैकेज में से आयात नहीं कर सकता है। शायद यह आपके लिए कोई समस्या नहीं है, इस मामले में, ठीक है। यदि वे आपके प्रोग्राम के भीतर जाते हैं, तो आपका setup.py उन्हें आयात कर सकता है, लेकिन यह तब नहीं होना चाहिए, क्योंकि जब आपके प्रोग्राम की निर्भरताएं इंस्टॉल नहीं होती हैं, तो setup.py इंस्टॉल हो जाता है (setup.py का उपयोग यह निर्धारित करने के लिए किया जाता है कि निर्भरताएं क्या हैं। ।) इसलिए ज़ूको का जवाब: उत्पाद पैकेज को आयात किए बिना, मैन्युअल रूप से उत्पाद स्रोत फ़ाइल से मूल्य को पार्स करें

— जोनाथन हार्टले

Answer 6

इनमें से कई समाधान यहां gitसंस्करण टैग को नजरअंदाज करते हैं जिसका मतलब है कि आपको कई स्थानों पर संस्करण को ट्रैक करना होगा (खराब)। मैंने निम्न लक्ष्यों के साथ संपर्क किया:

• में एक टैग से सभी अजगर संस्करण संदर्भों को प्राप्त करें gitरेपो
• एक इनपुट के साथ स्वचालित git tag/ pushऔर setup.py uploadचरण जो कोई इनपुट नहीं लेता है।

यह काम किस प्रकार करता है:

1. एक make releaseकमांड से, git रेपो में अंतिम टैग किया गया संस्करण मिला और बढ़ा हुआ है। टैग को वापस धकेल दिया जाता है origin।

2. Makefileदुकानों में संस्करण src/_version.pyजहां यह द्वारा पढ़ा जाएगा setup.pyऔर यह भी रिलीज में शामिल थे। स्रोत नियंत्रण में जाँच न करें _version.py!

3. setup.pyकमांड नए संस्करण स्ट्रिंग से पढ़ता है package.__version__।

विवरण:

makefile

# remove optional 'v' and trailing hash "v1.0-N-HASH" -> "v1.0-N"
git_describe_ver = $(shell git describe --tags | sed -E -e 's/^v//' -e 's/(.*)-.*/\1/')
git_tag_ver      = $(shell git describe --abbrev=0)
next_patch_ver = $(shell python versionbump.py --patch $(call git_tag_ver))
next_minor_ver = $(shell python versionbump.py --minor $(call git_tag_ver))
next_major_ver = $(shell python versionbump.py --major $(call git_tag_ver))

.PHONY: ${MODULE}/_version.py
${MODULE}/_version.py:
    echo '__version__ = "$(call git_describe_ver)"' > $@

.PHONY: release
release: test lint mypy
    git tag -a $(call next_patch_ver)
    $(MAKE) ${MODULE}/_version.py
    python setup.py check sdist upload # (legacy "upload" method)
    # twine upload dist/*  (preferred method)
    git push origin master --tags

releaseलक्ष्य हमेशा 3 संस्करण अंकों की वृद्धि कर, लेकिन आप उपयोग कर सकते हैं next_minor_verयाnext_major_ver अन्य अंक बढ़ाने के लिए। आदेशों पर भरोसा करते हैंversionbump.py स्क्रिप्ट हैं जिसे रेपो की जड़ में जांचा जाता है

versionbump.py

"""An auto-increment tool for version strings."""

import sys
import unittest

import click
from click.testing import CliRunner  # type: ignore

__version__ = '0.1'

MIN_DIGITS = 2
MAX_DIGITS = 3


@click.command()
@click.argument('version')
@click.option('--major', 'bump_idx', flag_value=0, help='Increment major number.')
@click.option('--minor', 'bump_idx', flag_value=1, help='Increment minor number.')
@click.option('--patch', 'bump_idx', flag_value=2, default=True, help='Increment patch number.')
def cli(version: str, bump_idx: int) -> None:
    """Bumps a MAJOR.MINOR.PATCH version string at the specified index location or 'patch' digit. An
    optional 'v' prefix is allowed and will be included in the output if found."""
    prefix = version[0] if version[0].isalpha() else ''
    digits = version.lower().lstrip('v').split('.')

    if len(digits) > MAX_DIGITS:
        click.secho('ERROR: Too many digits', fg='red', err=True)
        sys.exit(1)

    digits = (digits + ['0'] * MAX_DIGITS)[:MAX_DIGITS]  # Extend total digits to max.
    digits[bump_idx] = str(int(digits[bump_idx]) + 1)  # Increment the desired digit.

    # Zero rightmost digits after bump position.
    for i in range(bump_idx + 1, MAX_DIGITS):
        digits[i] = '0'
    digits = digits[:max(MIN_DIGITS, bump_idx + 1)]  # Trim rightmost digits.
    click.echo(prefix + '.'.join(digits), nl=False)


if __name__ == '__main__':
    cli()  # pylint: disable=no-value-for-parameter

यह प्रक्रिया से संस्करण संख्या को बढ़ाने और बढ़ाने के लिए भारी उठाने का काम करता है git ।

__init__.py

my_module/_version.pyफ़ाइल में आयात किया जाता my_module/__init__.py। यहां कोई भी स्टैटिक इंस्टॉल कॉन्फिगर करें जिसे आप अपने मॉड्यूल के साथ वितरित करना चाहते हैं।

from ._version import __version__
__author__ = ''
__email__ = ''

setup.py

अंतिम चरण my_moduleमॉड्यूल से संस्करण की जानकारी को पढ़ना है ।

from setuptools import setup, find_packages

pkg_vars  = {}

with open("{MODULE}/_version.py") as fp:
    exec(fp.read(), pkg_vars)

setup(
    version=pkg_vars['__version__'],
    ...
    ...
)

बेशक, यह सब काम करने के लिए आपको शुरू करने के लिए अपने रेपो में कम से कम एक संस्करण टैग होना चाहिए।

git tag -a v0.0.1

Comments

वास्तव में - यह पूरा सूत्र यह भूल जाता है कि इस चर्चा में एक वीसीएस बहुत महत्वपूर्ण है। बस एक अवलोकन: संस्करण वृद्धि एक मैनुअल प्रक्रिया होनी चाहिए, इसलिए पसंदीदा तरीका होगा। 1. मैन्युअल रूप से एक टैग बनाएं और पुश करें। VCS टूल को उस टैग की खोज करने दें और जहां आवश्यक हो उसे संग्रहीत करें (वाह - यह SO संपादन इंटरफ़ेस वास्तव में मुझे अपंग कर रहा है - मुझे इसे नई कहानियों और IT STILL DOESN'T WORK से निपटने के लिए एक दर्जन बार संपादित करना पड़ा! @ # $% ^ & *)

— axd

versionbump.pyजब हम अजगर के लिए एक भयानक टक्कर पैकेज का उपयोग करने की कोई जरूरत नहीं है ।

— ओरन

@ ओरन मैंने वर्बंप को देखा। डॉक्स बहुत स्पष्ट नहीं हैं, और यह बहुत अच्छी तरह से टैगिंग को संभालता नहीं है। मेरे परीक्षण में यह कहा गया है कि यह दुर्घटना का कारण बनता है: subprocess। 'नॉन-जीरो एग्जिट स्टेटस 1. लौटा।

— सेमीकग्नी

_version.pyसंस्करण नियंत्रण के साथ नज़र क्यों नहीं रखी जानी चाहिए ?

— Stevoisiak

@StevenVascellaro यह रिलीज की प्रक्रिया को जटिल बनाता है। अब आपको यह सुनिश्चित करना है कि आप टैग हैं और कमिट _version.py में मूल्य से मेल खाते हैं। सिंगल वर्जन टैग का उपयोग करना क्लीनर IMO है और इसका मतलब है कि आप सीधे gitub UI से एक रिलीज़ बना सकते हैं।

— cmcginty

Answer 7

मैं पैकेज dir में JSON फ़ाइल का उपयोग करता हूं। यह ज़ूको की आवश्यकताओं के अनुरूप है।

अंदर pkg_dir/pkg_info.json:

{"version": "0.1.0"}

अंदर setup.py:

from distutils.core import setup
import json

with open('pkg_dir/pkg_info.json') as fp:
    _info = json.load(fp)

setup(
    version=_info['version'],
    ...
    )

अंदर pkg_dir/__init__.py:

import json
from os.path import dirname

with open(dirname(__file__) + '/pkg_info.json') as fp:
    _info = json.load(fp)

__version__ = _info['version']

मैंने अन्य जानकारी भी डाली pkg_info.json, जैसे लेखक। मुझे JSON का उपयोग करना पसंद है क्योंकि मैं मेटाडेटा के प्रबंधन को स्वचालित कर सकता हूं।

Comments

क्या आप विस्तार से बता सकते हैं कि मेटाडेटा प्रबंधन को स्वचालित करने के लिए जसन का उपयोग कैसे किया जाता है? धन्यवाद!

— रयानडिलन

Answer 8

यह भी ध्यान देने योग्य है कि __version__अर्ध-एसटीडी होने के साथ -साथ। अजगर में, __version_info__जो कि एक तुक है, साधारण मामलों में आप कुछ ऐसा कर सकते हैं:

__version__ = '1.2.3'
__version_info__ = tuple([ int(num) for num in __version__.split('.')])

... और आप __version__एक फ़ाइल से स्ट्रिंग प्राप्त कर सकते हैं , या जो भी हो।

Comments

क्या आपके पास इस उपयोग की उत्पत्ति के संबंध में कोई संदर्भ / लिंक है __version_info__?

— क्रेग मैकक्यून

वैसे यह sys.version से sys.version_info के समान मैपिंग है। अतः: docs.python.org/library/sys.html#sys.version_info

— जेम्स

मैपिंग को दूसरी दिशा ( __version_info__ = (1, 2, 3)और __version__ = '.'.join(map(str, __version_info__))) में करना आसान है ।

— एरिक ओ लेबिगोट

@ ईओएल - __version__ = '.'.join(str(i) for i in __version_info__)- थोड़ा लंबा लेकिन अधिक पायथोनिक ।

— आर्टऑफवर्फ

मुझे यकीन नहीं है कि आप जो प्रस्तावित करते हैं वह स्पष्ट रूप से अधिक पायथोनिक है, क्योंकि इसमें एक डमी चर होता है जिसकी वास्तव में आवश्यकता नहीं होती है और जिसका अर्थ व्यक्त करना थोड़ा कठिन होता है ( iजिसका कोई अर्थ नहीं है, version_numथोड़ा लंबा और अस्पष्ट है ...)। मैं भी map()पायथन के अस्तित्व को एक मजबूत संकेत के रूप में लेता हूं कि इसका उपयोग यहां किया जाना चाहिए, क्योंकि यहां हमें जो करने की आवश्यकता है वह है एक विशिष्ट उपयोग मामला map()(मौजूदा फ़ंक्शन के साथ उपयोग) -मैं कई अन्य उचित उपयोग नहीं देखता।

— एरिक ओ लेबिगॉट

Answer 9

एक अजगर पैकेज में एक संस्करण स्ट्रिंग एम्बेड करने के लिए एक मानक तरीका प्रतीत नहीं होता है। अधिकांश पैकेज मैंने देखे हैं कि आपके समाधान के कुछ प्रकार का उपयोग किया गया है, अर्थात ईटनर

1. संस्करण को एम्बेड करें setup.pyऔर केवल संस्करण जानकारी युक्त setup.pyएक मॉड्यूल उत्पन्न करें (जैसे version.py), जो आपके पैकेज द्वारा आयात किया गया है, या

2. रिवर्स: अपने पैकेज में ही संस्करण की जानकारी, और आयात कर दिया है कि में संस्करण स्थापित करने के लिए setup.py

Comments

मुझे आपकी सिफारिश पसंद है, लेकिन इस मॉड्यूल को setup.py से कैसे जनरेट किया जाए?

— सोरिन

मुझे विकल्प (1) का विचार पसंद है, यह एक फ़ाइल से संस्करण संख्या को पार्स करने के ज़ूको के उत्तर की तुलना में सरल लगता है। लेकिन आप यह सुनिश्चित नहीं कर सकते हैं कि जब कोई देवता आपके रेपो को क्लोन करता है तो वर्जनहोम बनाया जाता है। जब तक आप वर्जनहोम में जांच नहीं करते हैं, जो छोटी शिकन को खोल देता है जिसे आप वर्चुअम में बदल सकते हैं, कमिट, रिलीज, और उसके बाद वर्चुअरम में बदलाव के लिए (स्लैश भूलना) करना होगा।

— जोनाथन हार्टले

संभवत: आप खुले ("mypackage / version.py", "w") के साथ fp: fp.write ("__ version__ == '% s' \ n"% (__version__,) जैसे "" जैसे कुछ का उपयोग करके मॉड्यूल उत्पन्न कर सकते हैं। ) ""

— जोनाथन हार्टले

मुझे लगता है कि विकल्प 2 जेएबी के जवाब में टिप्पणियों के रूप में स्थापित करने के दौरान असफल होने की संभावना है।

— जोनाथन हार्टले

उस बारे में क्या? आपने अपने सॉफ़्टवेयर के मुख्य पैकेज __init__.py "में __version__ = '0.0.1'" (जहाँ संस्करण एक स्ट्रिंग है, निश्चित रूप से) रखा है। फिर बिंदु 2 पर जाएं: सेटअप में आप पैकेज से करते हैं। init__ v के रूप में __version__ आयात करते हैं, और फिर आप चर को अपने setup.py के संस्करण के रूप में सेट करते हैं। फिर mypack को my के रूप में आयात करें, मेरा .__ version__ प्रिंट करें संस्करण। संस्करण केवल एक ही स्थान पर संग्रहीत किया जाएगा, पूरे कोड से सुलभ, एक फ़ाइल में जो सॉफ़्टवेयर से संबंधित कुछ और आयात नहीं करता है।

— SeF

Answer 10

तीर इसे एक दिलचस्प तरीके से संभालता है।

अब ( 2e5031b से )

इन arrow/__init__.py:

__version__ = 'x.y.z'

इन setup.py:

from arrow import __version__

setup(
    name='arrow',
    version=__version__,
    # [...]
)

इससे पहले

इन arrow/__init__.py:

__version__ = 'x.y.z'
VERSION = __version__

इन setup.py:

def grep(attrname):
    pattern = r"{0}\W*=\W*'([^']+)'".format(attrname)
    strval, = re.findall(pattern, file_text)
    return strval

file_text = read(fpath('arrow/__init__.py'))

setup(
    name='arrow',
    version=grep('__version__'),
    # [...]
)

Comments

क्या है file_text?

— ely

अद्यतन समाधान वास्तव में हानिकारक है। जब setup.py चल रहा है, यह जरूरी नहीं कि स्थानीय फ़ाइल पथ से पैकेज का संस्करण दिखाई देगा। यह पहले से स्थापित संस्करण में वापस आ सकता है, उदाहरण के लिए pip install -e .विकास शाखा पर चलने से या परीक्षण करते समय कुछ। setup.py बिल्कुल उस पैकेज को आयात करने पर भरोसा नहीं करना चाहिए जो तैनाती के लिए मापदंडों को निर्धारित करने के लिए स्थापित करने की प्रक्रिया में है। ओह।

— ely

हाँ, मुझे नहीं पता कि तीर ने इस समाधान को वापस लेने का फैसला क्यों किया। इसके अलावा प्रतिबद्ध संदेश में कहा गया है " आधुनिक पायथन मानकों के साथ अपडेट किया गया सेटअप" ... An

— Anto

Answer 11

मैंने एक और शैली भी देखी:

>>> django.VERSION
(1, 1, 0, 'final', 0)

Comments

हां, मैंने भी देखा। BTW हर जवाब अन्य शैली लेता है तो अब मुझे नहीं पता कि शैली "मानक" क्या है। उल्लिखित

— PEPs की

एक और तरीका देखा गया; मोंगियो का पायथन क्लाइंट बिना अंडरस्कोर के सादे संस्करण का उपयोग करता है। तो यह काम करता है; $ python >>> आयात pymongo >>> pymongo.version '2.7'

— AnneTheAgile

लागू करने का .VERSIONमतलब यह नहीं है कि आपको लागू करने की आवश्यकता नहीं है __version__।

— एक्यूमेनस

क्या इस djangoपरियोजना में कार्यान्वयन की आवश्यकता है ?

— Stevoisiak

Answer 12

का उपयोग कर setuptoolsऔरpbr

संस्करण को प्रबंधित करने का कोई मानक तरीका नहीं है, लेकिन आपके पैकेज को प्रबंधित करने का मानक तरीका है setuptools ।

संस्करण को प्रबंधित करने के लिए मुझे जो सबसे अच्छा समाधान मिला है वह है इसका उपयोग setuptoolsकरनाpbr विस्तार के । यह अब मेरे संस्करण प्रबंधन का मानक तरीका है।

पूर्ण पैकेजिंग के लिए अपनी परियोजना स्थापित करना सरल परियोजनाओं के लिए ओवरकिल हो सकता है, लेकिन यदि आपको संस्करण का प्रबंधन करने की आवश्यकता है, तो आप शायद सब कुछ सेट करने के लिए सही स्तर पर हैं। ऐसा करने से आपका पैकेज PyPi पर निर्भर हो जाता है हो ताकि हर कोई इसे Pip के साथ डाउनलोड और उपयोग कर सके।

PBR अधिकांश मेटाडेटा को setup.pyउपकरण से बाहर ले जाती है और एक setup.cfgफ़ाइल में जिसे तब अधिकांश मेटाडेटा के लिए एक स्रोत के रूप में उपयोग किया जाता है, जिसमें संस्करण शामिल हो सकते हैं। यह मेटाडेटा को निष्पादन योग्य में पैक करने की अनुमति देता है जैसे pyinstallerयदि आवश्यक हो (यदि ऐसा है, तो आपको शायद इस जानकारी की आवश्यकता होगी ), और मेटाडेटा को अन्य पैकेज प्रबंधन / सेटअप स्क्रिप्ट से अलग करता है। आप setup.cfgमैन्युअल रूप से संस्करण स्ट्रिंग को सीधे अपडेट कर सकते हैं , और यह *.egg-infoआपके पैकेज रिलीज के निर्माण के दौरान फ़ोल्डर में खींच लिया जाएगा । आपकी स्क्रिप्ट तब विभिन्न तरीकों का उपयोग करके मेटाडेटा से संस्करण तक पहुंच सकती है (ये प्रक्रिया नीचे दिए गए अनुभागों में उल्लिखित हैं)।

वीसीएस / एससीएम के लिए गिट का उपयोग करते समय, यह सेटअप और भी बेहतर है, क्योंकि यह गिट से बहुत सारे मेटाडेटा में खींच लेगा, ताकि आपका रेपो मेटाडेटा के कुछ के लिए आपके सत्य का प्राथमिक स्रोत हो सकता है, जिसमें संस्करण, लेखक, चेंजलॉग्स शामिल हैं, आदि विशेष रूप से संस्करण के लिए, यह रेपो में git टैग के आधार पर वर्तमान प्रतिबद्ध के लिए एक संस्करण स्ट्रिंग बनाएगा।

• PyPA - SetupTools - Tutorial के साथ पायथन पैकेज की पैकेजिंग
• PBR नवीनतम बिल्ड उपयोग प्रलेखन - 8-लाइन setup.pyऔर setup.cfgमेटाडेटा के साथ एक फ़ाइल कैसे सेटअप करें ।

जैसा कि पीबीआर आपके गिट रेपो से सीधे संस्करण, लेखक, चैंज और अन्य जानकारी को खींच लेगा, इसलिए setup.cfgजब भी आपके पैकेज के लिए वितरण का उपयोग किया जाता है तो कुछ मेटाडेटा को छोड़ दिया जा सकता है और ऑटो उत्पन्न किया जा सकता है (उपयोग करते हुए setup.py)

वास्तविक समय वर्तमान संस्करण

setuptoolsवास्तविक समय का उपयोग करके नवीनतम जानकारी खींचेंगे setup.py:

python setup.py --version

यह नवीनतम संस्करण को या तो setup.cfgफ़ाइल से, या गिट रेपो से, नवीनतम प्रतिबद्ध के आधार पर खींचेगा जो कि बनाया गया था और टैग जो रेपो में मौजूद हैं। यह आदेश वितरण में संस्करण को अद्यतन नहीं करता है।

संस्करण को अद्यतन करना

जब आप setup.py( py setup.py sdistउदाहरण के लिए) के साथ एक वितरण बनाते हैं , तो सभी वर्तमान जानकारी को निकाला जाएगा और वितरण में संग्रहीत किया जाएगा। यह अनिवार्य रूप से setup.py --versionकमांड चलाता है और फिर उस संस्करण की जानकारी को package.egg-infoफ़ोल्डर में स्टोर करता है जो वितरण मेटाडेटा को संग्रहीत करता है।

संस्करण मेटा-डेटा को अद्यतन करने की प्रक्रिया पर ध्यान दें:

यदि आप git से संस्करण डेटा खींचने के लिए pbr का उपयोग नहीं कर रहे हैं, तो बस अपने setup.cfg को नए संस्करण की जानकारी के साथ सीधे अपडेट करें (आसान पर्याप्त है, लेकिन सुनिश्चित करें कि यह आपकी रिलीज़ प्रक्रिया का एक मानक हिस्सा है)।

यदि आप git का उपयोग कर रहे हैं, और आपको अपने मेटाडेटा फ़ोल्डर में git रेपो जानकारी को अपडेट करने का सबसे सरल तरीका केवल python setup.py sdistएक python setup.py bdist_xxxकमांड या बाइनरी वितरण ( कमांड का उपयोग या एक ) बनाने की आवश्यकता नहीं है, तो <mypackage>.egg-infoबस python setup.py installकमांड चलाना है । यह गिट रेपो से मेटाडेटा खींचने से संबंधित सभी पीबीआर फ़ंक्शन चलाएगा और आपके स्थानीय .egg-infoफ़ोल्डर को अपडेट करेगा , आपके द्वारा परिभाषित किसी भी प्रवेश-बिंदु के लिए स्क्रिप्ट निष्पादन स्थापित करें, और जब आप इस आदेश को चलाते हैं तो अन्य फ़ंक्शन आप आउटपुट से देख सकते हैं।

ध्यान दें कि .egg-infoफ़ोल्डर को आमतौर पर मानक रेफ़ॉन.gitignore फ़ाइलों (जैसे कि Gitignore.IO से ) में गिट रेपो में संग्रहीत होने से बाहर रखा गया है , क्योंकि यह आपके स्रोत से उत्पन्न हो सकता है। यदि इसे बाहर रखा गया है, तो सुनिश्चित करें कि आपके पास एक मानक "रिलीज़ प्रक्रिया" है, रिलीज़ से पहले मेटाडेटा को अपडेट करने के लिए, और जो भी पैकेज आप PyPi.org पर अपलोड करते हैं या अन्यथा वितरित करते हैं, इस डेटा को सही संस्करण में शामिल करना चाहिए। यदि आप चाहते हैं Git (यानी जोड़ने के लिए इस जानकारी को रोकने के लिए, आप अनदेखा किया जा रहा से विशिष्ट फ़ाइलों को बाहर कर सकते रेपो !*.egg-info/PKG_INFOके लिए .gitignore)

किसी स्क्रिप्ट से संस्करण को एक्सेस करना

आप पैकेज में ही पायथन स्क्रिप्ट्स के भीतर वर्तमान बिल्ड से मेटाडेटा एक्सेस कर सकते हैं। संस्करण के लिए, उदाहरण के लिए, ऐसा करने के कई तरीके हैं जो मैंने अब तक पाए हैं:

## This one is a new built-in as of Python 3.8.0 should become the standard
from importlib-metadata import version

v0 = version("mypackage")
print('v0 {}'.format(v0))

## I don't like this one because the version method is hidden
import pkg_resources  # part of setuptools

v1 = pkg_resources.require("mypackage")[0].version
print('v1 {}'.format(v1))

# Probably best for pre v3.8.0 - the output without .version is just a longer string with
# both the package name, a space, and the version string
import pkg_resources  # part of setuptools

v2 = pkg_resources.get_distribution('mypackage').version
print('v2 {}'.format(v2))

## This one seems to be slower, and with pyinstaller makes the exe a lot bigger
from pbr.version import VersionInfo

v3 = VersionInfo('mypackage').release_string()
print('v3 {}'.format(v3))

आप __init__.pyकुछ अन्य उत्तरों के समान संस्करण जानकारी निकालने के लिए इनमें से एक को सीधे पैकेज में रख सकते हैं :

__all__ = (
    '__version__',
    'my_package_name'
)

import pkg_resources  # part of setuptools

__version__ = pkg_resources.get_distribution("mypackage").version

Comments

अब सवाल का सीधा जवाब देने के लिए प्रति डाउन वोट रिफॉर्म किया गया।

— लाइटसीसी

Answer 13

सबसे सरल विश्वसनीय समाधान खोजने की कोशिश करने के कई घंटों के बाद, यहाँ भाग दिए गए हैं:

अपने पैकेज "/ mypackage" के फ़ोल्डर में एक वर्चस्व फ़ाइल बनाएँ।

# Store the version here so:
# 1) we don't load dependencies by storing it in __init__.py
# 2) we can import it in setup.py for the same reason
# 3) we can import it into your module module
__version__ = '1.2.7'

setup.py में:

exec(open('mypackage/version.py').read())
setup(
    name='mypackage',
    version=__version__,

मुख्य फ़ोल्डर init .py में:

from .version import __version__

exec()के बाद से setup.py मॉड्यूल आयात किया जा सकता से पहले चलाया जाता है समारोह, किसी भी आयात की स्क्रिप्ट के बाहर चलाता है। आपको अभी भी केवल एक ही स्थान पर एक फ़ाइल में संस्करण संख्या को प्रबंधित करने की आवश्यकता है, लेकिन दुर्भाग्य से यह setup.py में नहीं है। (यह नकारात्मक पक्ष है, लेकिन कोई आयात बग नहीं है)

Answer 14

यह सवाल पहले पूछे जाने के बाद से वर्दी वर्जनिंग और सम्मेलनों के समर्थन में बहुत सारे काम पूरे हो चुके हैं । पैलेटन पैकेजिंग उपयोगकर्ता गाइड में अब पालिटेबल विकल्प विस्तृत हैं । यह भी उल्लेखनीय है कि संस्करण संख्या योजनाएं PEP 440 प्रति पायथन में अपेक्षाकृत सख्त हैं , और इसलिए चीजों को रखना महत्वपूर्ण है यदि आपका पैकेज पनीर की दुकान पर जारी किया जाएगा ।

यहाँ संस्करण विकल्पों में से एक छोटा टूट गया है:

1. फ़ाइल को setup.py( setuptools ) में पढ़ें और संस्करण प्राप्त करें।
2. बाहरी बिल्ड टूल का उपयोग करें ( __init__.pyस्रोत नियंत्रण के साथ-साथ अद्यतन करने के लिए ), जैसे bump2version , परिवर्तन या zest.releaser ।
3. में मान सेट करें __version__एक विशिष्ट मॉड्यूल में एक वैश्विक चर के ।
4. मूल्य को एक साधारण VERSION पाठ फ़ाइल में दोनों सेटअप और कोड को पढ़ने के लिए रखें।
5. एक setup.pyरिलीज के माध्यम से मूल्य निर्धारित करें , और इसे रनटाइम पर लेने के लिए importlib.metadata का उपयोग करें । (चेतावनी, प्री-3.8 और पोस्ट-3.8 संस्करण हैं।)
6. __version__में sample/__init__.pyनमूना आयात करने के लिए मान सेट करें setup.py।
7. स्रोत नियंत्रण से संस्करण को निकालने के लिए setuptools_scm का उपयोग करें ताकि यह कैनोनिकल संदर्भ हो, कोड नहीं।

ध्यान दें कि (7) सबसे आधुनिक दृष्टिकोण हो सकता है (निर्माण मेटाडाटा कोड से स्वतंत्र है, स्वचालन द्वारा प्रकाशित)। यह भी ध्यान दें कि यदि सेटअप का उपयोग पैकेज रिलीज़ के लिए किया जाता है जो कि एक सरल python3 setup.py --versionसंस्करण को सीधे रिपोर्ट करेगा।

Answer 15

यदि आप NumPy डिस्टिलिट्स का उपयोग कर रहे हैं, तो इसके लायक क्या है, numpy.distutils.misc_util.Configurationएक make_svn_version_py()विधि है package.__svn_version__जो चर में संशोधन संख्या को अंदर एम्बेड करती है version।

Comments

क्या आप अधिक विवरण या उदाहरण दे सकते हैं कि यह कैसे काम करेगा?

— Stevoisiak

हम्म। 2020 में, इस (यह हमेशा था?) के लिए है FORTRAN । पैकेज "numpy.distutils फोरट्रान स्रोतों से निपटने के लिए NumPy का विस्तार करने वाले मानक पायथन डिस्टुटिल्स का हिस्सा है।"

— प्रवेश करें

Answer 16

1. version.pyफ़ाइल में केवल __version__ = <VERSION>परम के साथ एक फ़ाइल का उपयोग करें । में setup.pyफ़ाइल आयात __version__परम और में यह मूल्य डाल setup.pyइस तरह फ़ाइल: version=__version__
2. दूसरा तरीका सिर्फ एक setup.pyफ़ाइल का उपयोग करना है version=<CURRENT_VERSION>- CURRENT_VERSION हार्डकोड है।

चूँकि हम हर बार एक नया टैग (नया पैकेज संस्करण जारी करने के लिए तैयार) बनाने के लिए फ़ाइल में संस्करण को मैन्युअल रूप से बदलना नहीं चाहते हैं, हम निम्न का उपयोग कर सकते हैं ..

मैं अत्यधिक टक्कर पैकेज की सलाह देता हूं । मैं एक संस्करण टक्कर के लिए वर्षों से इसका उपयोग कर रहा हूं।

यदि आपके पास पहले से नहीं है तो version=<VERSION>अपनी setup.pyफ़ाइल में जोड़कर शुरू करें ।

हर बार जब आप किसी संस्करण से टकराते हैं तो आपको एक छोटी स्क्रिप्ट का उपयोग करना चाहिए:

bumpversion (patch|minor|major) - choose only one option
git push
git push --tags

फिर रेपो नामक एक फाइल जोड़ें .bumpversion.cfg:

[bumpversion]
current_version = <CURRENT_TAG>
commit = True
tag = True
tag_name = {new_version}
[bumpversion:file:<RELATIVE_PATH_TO_SETUP_FILE>]

ध्यान दें:

• आप फ़ाइल के __version__तहत पैरामीटर का उपयोग कर सकते हैं version.pyजैसे कि अन्य पोस्ट में सुझाव दिया गया था और इस तरह से bumpversion फ़ाइल को अपडेट करें: [bumpversion:file:<RELATIVE_PATH_TO_VERSION_FILE>]
• आप चाहिए git commit या git resetअपने रेपो में सब कुछ, अन्यथा आप एक गंदा रेपो त्रुटि प्राप्त होगी।
• सुनिश्चित करें कि आपके वर्चुअल वातावरण में बम्पवर्सन का पैकेज शामिल है, इसके बिना यह काम नहीं करेगा।

Comments

@cmcginty देरी के लिए क्षमा करें, कृपया मेरे उत्तर की जांच करें ^ ^ ^ ^ - ध्यान दें कि आपको कमिट करना होगा या गिट को अपने रेपो में सब कुछ रीसेट करना होगा और सुनिश्चित करें कि आपके वर्चुअल वातावरण में पैकेज शामिल है bumpversion, इसके बिना यह काम नहीं करेगा। नवीनतम संस्करण का उपयोग करें।

— ओरन

मैं थोड़ा स्पष्ट नहीं हूँ कि यहाँ क्या समाधान सुझाया जा रहा है। क्या आप मैन्युअल रूप से संस्करण को ट्रैक करने की अनुशंसा कर रहे हैं version.py, या इसके साथ ट्रैकिंग कर रहे हैं bumpversion?

— स्टेवोइसाक

@StevenVascellaro मैं सुझाव दे रहा हूं कि बम्पवर्सन का उपयोग करें, कभी भी मैन्युअल संस्करण का उपयोग न करें। मैंने जो समझाने की कोशिश की, वह है कि आप bumpversion को या तो संस्करण को setup.py फ़ाइल में अद्यतन करने के लिए निर्देशित कर सकते हैं या बेहतर अभी तक इसका उपयोग संस्करणहोम फ़ाइल अद्यतन करने के लिए कर सकते हैं। वर्जनहोम फाइल को अपडेट करने और __version__सेटअप वैल्यू में परम मान लेने के लिए यह अधिक आम बात है । मेरे समाधान का उपयोग उत्पादन में किया जाता है और यह एक आम बात है। नोट: बस स्पष्ट होने के लिए, स्क्रिप्ट के हिस्से के रूप में बम्पवर्सन का उपयोग करना सबसे अच्छा समाधान है, इसे अपने CI में डालें और यह स्वचालित संचालन होगा।

— ओरन

Answer 17

यदि आप सीवीएस (या आरसीएस) का उपयोग करते हैं और त्वरित समाधान चाहते हैं, तो आप उपयोग कर सकते हैं:

__version__ = "$Revision: 1.1 $"[11:-2]
__version_info__ = tuple([int(s) for s in __version__.split(".")])

(निश्चित रूप से, संशोधन संख्या सीवीएस द्वारा आपके लिए प्रतिस्थापित किया जाएगा।)

यह आपको एक प्रिंट-फ्रेंडली संस्करण और एक संस्करण जानकारी देता है, जिसका उपयोग आप यह जांचने के लिए कर सकते हैं कि आपके द्वारा आयात किए जा रहे मॉड्यूल में कम से कम अपेक्षित संस्करण है:

import my_module
assert my_module.__version_info__ >= (1, 1)

Comments

आप किस फाइल को सेविंग सेव __version__करने की सलाह दे रहे हैं ? इस समाधान के साथ संस्करण संख्या में वृद्धि कैसे होगी?

— Stevoisiak